SGObject.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2008-2010 Soeren Sonnenburg
 * Written (W) 2011-2013 Heiko Strathmann
 * Written (W) 2013-2014 Thoralf Klein
 * Copyright (C) 2008-2010 Fraunhofer Institute FIRST and Max Planck Society
 */

#ifndef __SGOBJECT_H__
#define __SGOBJECT_H__

#include <shogun/lib/config.h>
#include <shogun/lib/common.h>
#include <shogun/lib/DataType.h>
#include <shogun/lib/ShogunException.h>
#include <shogun/base/Version.h>
#include <shogun/base/unique.h>
#include <shogun/io/SGIO.h>
#include <shogun/lib/tag.h>
#include <shogun/lib/any.h>

namespace shogun
{
class RefCount;
class SGIO;
class Parallel;
class Parameter;
class ParameterMap;
class SGParamInfo;
class CSerializableFile;

template <class T, class K> class CMap;

struct TParameter;
template <class T> class DynArray;
template <class T> class SGStringList;

/*******************************************************************************
 * define reference counter macros
 ******************************************************************************/

#ifdef USE_REFERENCE_COUNTING
#define SG_REF(x) { if (x) (x)->ref(); }
#define SG_UNREF(x) { if (x) { if ((x)->unref()==0) (x)=NULL; } }
#define SG_UNREF_NO_NULL(x) { if (x) { (x)->unref(); } }
#else
#define SG_REF(x)
#define SG_UNREF(x)
#define SG_UNREF_NO_NULL(x)
#endif

/*******************************************************************************
 * Macros for registering parameters/model selection parameters
 ******************************************************************************/

#define VA_NARGS_IMPL(_1, _2, _3, _4, _5, N, ...) N
#define VA_NARGS(...) VA_NARGS_IMPL(__VA_ARGS__, 5, 4, 3, 2, 1)

#define VARARG_IMPL2(base, count, ...) base##count(__VA_ARGS__)
#define VARARG_IMPL(base, count, ...) VARARG_IMPL2(base, count, __VA_ARGS__)
#define VARARG(base, ...) VARARG_IMPL(base, VA_NARGS(__VA_ARGS__), __VA_ARGS__)

#define SG_ADD4(param, name, description, ms_available) {\
        m_parameters->add(param, name, description);\
        if (ms_available)\
            m_model_selection_parameters->add(param, name, description);\
}

#define SG_ADD5(param, name, description, ms_available, gradient_available) {\
        m_parameters->add(param, name, description);\
        if (ms_available)\
            m_model_selection_parameters->add(param, name, description);\
        if (gradient_available)\
            m_gradient_parameters->add(param, name, description);\
}

#define SG_ADD(...) VARARG(SG_ADD, __VA_ARGS__)

/*******************************************************************************
 * End of macros for registering parameters/model selection parameters
 ******************************************************************************/

enum EModelSelectionAvailability {
    MS_NOT_AVAILABLE=0,
    MS_AVAILABLE=1,
};

enum EGradientAvailability
{
    GRADIENT_NOT_AVAILABLE=0,
    GRADIENT_AVAILABLE=1
};

class CSGObject
{
public:
    CSGObject();

    CSGObject(const CSGObject& orig);

    virtual ~CSGObject();

#ifdef USE_REFERENCE_COUNTING

    int32_t ref();

    int32_t ref_count();

    int32_t unref();
#endif //USE_REFERENCE_COUNTING

#ifdef TRACE_MEMORY_ALLOCS
    static void list_memory_allocs();
#endif

    virtual CSGObject *shallow_copy() const;

    virtual CSGObject *deep_copy() const;

    virtual const char* get_name() const = 0;

    virtual bool is_generic(EPrimitiveType* generic) const;

    template<class T> void set_generic();

    void unset_generic();

    virtual void print_serializable(const char* prefix="");

    virtual bool save_serializable(CSerializableFile* file,
            const char* prefix="");

    virtual bool load_serializable(CSerializableFile* file,
            const char* prefix="");

    void set_global_io(SGIO* io);

    SGIO* get_global_io();

    void set_global_parallel(Parallel* parallel);

    Parallel* get_global_parallel();

    void set_global_version(Version* version);

    Version* get_global_version();

    SGStringList<char> get_modelsel_names();

    void print_modsel_params();

    char* get_modsel_param_descr(const char* param_name);

    index_t get_modsel_param_index(const char* param_name);

    void build_gradient_parameter_dictionary(CMap<TParameter*, CSGObject*>* dict);

    bool has(const std::string& name) const
    {
        BaseTag tag(name);
        return has_with_base_tag(tag);
    }

    template <typename T>
    bool has(const Tag<T>& tag) const
    {
        return has<T>(tag.name());
    }

    template <typename T, typename U=void>
    bool has(const std::string& name) const
    {
        BaseTag tag(name);
        if(!has_with_base_tag(tag))
            return false;
        const Any value = get_with_base_tag(tag);
        return value.same_type<T>();
    }

    template <typename T>
    void set(const Tag<T>& _tag, const T& value)
    {
        if(has_with_base_tag(_tag))
        {
            if(has<T>(_tag.name()))
                set_with_base_tag(_tag, erase_type(value));
            else
            {
                SG_ERROR("Type for parameter with name \"%s\" is not correct.\n",
                    _tag.name().c_str());
            }
        }
        else
        {
            SG_ERROR("\"%s\" does not have a parameter with name \"%s\".\n",
                get_name(), _tag.name().c_str());
        }
    }

    template <typename T, typename U=void>
    void set(const std::string& name, const T& value)
    {
        Tag<T> tag(name);
        set(tag, value);
    }

    template <typename T>
    T get(const Tag<T>& _tag) const
    {
        const Any value = get_with_base_tag(_tag);
        try
        {
            return recall_type<T>(value);
        }
        catch(std::logic_error)
        {
            SG_ERROR("Type for parameter with name \"%s\" is not correct in \"%s\".\n",
                    _tag.name().c_str(), get_name());
        }
    }

    template <typename T, typename U=void>
    T get(const std::string& name) const
    {
        Tag<T> tag(name);
        return get(tag);
    }

protected:
    virtual void load_serializable_pre() throw (ShogunException);

    virtual void load_serializable_post() throw (ShogunException);

    virtual void save_serializable_pre() throw (ShogunException);

    virtual void save_serializable_post() throw (ShogunException);

    template <typename T>
    void register_param(Tag<T>& _tag, const T& value)
    {
        set_with_base_tag(_tag, erase_type(value));
    }

    template <typename T>
    void register_param(const std::string& name, const T& value)
    {
        BaseTag tag(name);
        set_with_base_tag(tag, erase_type(value));
    }

public:
    virtual void update_parameter_hash();

    virtual bool parameter_hash_changed();

    virtual bool equals(CSGObject* other, float64_t accuracy=0.0, bool tolerant=false);

    virtual CSGObject* clone();

private:
    void set_global_objects();
    void unset_global_objects();
    void init();

    bool has_with_base_tag(const BaseTag& _tag) const;

    void set_with_base_tag(const BaseTag& _tag, const Any& any);
    
    Any get_with_base_tag(const BaseTag& _tag) const;

    void get_parameter_incremental_hash(uint32_t& hash, uint32_t& carry,
            uint32_t& total_length);

    class Self;
    Unique<Self> self;

public:
    SGIO* io;

    Parallel* parallel;

    Version* version;

    Parameter* m_parameters;

    Parameter* m_model_selection_parameters;

    Parameter* m_gradient_parameters;

    uint32_t m_hash;

private:

    EPrimitiveType m_generic;
    bool m_load_pre_called;
    bool m_load_post_called;
    bool m_save_pre_called;
    bool m_save_post_called;

    RefCount* m_refcount;
};
}
#endif // __SGOBJECT_H__