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-2012 Heiko Strathmann
 * 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/SGStringList.h>
#include <shogun/lib/ShogunException.h>

#include <shogun/base/Parallel.h>
#include <shogun/base/Version.h>

#include <shogun/io/SGIO.h>


#ifdef HAVE_PTHREAD
#include <pthread.h>
#endif //HAVE_PTHREAD

namespace shogun
{
class IO;
class Parallel;
class Version;
class Parameter;
class ParameterMap;
class SGParamInfo;
class CSerializableFile;

template <class T, class K> class CMap;

struct TParameter;
template <class T> class DynArray;

// 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 SG_ADD(param, name, description, ms_available) {\
        m_parameters->add(param, name, description);\
        if (ms_available)\
            m_model_selection_parameters->add(param, name, description);\
}
/*******************************************************************************
 * End of macros for registering parameters/model selection parameters
 ******************************************************************************/

enum EModelSelectionAvailability {
    MS_NOT_AVAILABLE=0, MS_AVAILABLE
};

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

    virtual CSGObject *shallow_copy() const
    {
        SG_NOTIMPLEMENTED
        return NULL;
    }

    virtual CSGObject *deep_copy() const
    {
        SG_NOTIMPLEMENTED
        return NULL;
    }

    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="", int32_t param_version=VERSION_PARAMETER);

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

    DynArray<TParameter*>* load_file_parameters(const SGParamInfo* param_info,
            int32_t file_version, CSerializableFile* file,
            const char* prefix="");

    DynArray<TParameter*>* load_all_file_parameters(int32_t file_version,
            int32_t current_version,
            CSerializableFile* file, const char* prefix="");

    void map_parameters(DynArray<TParameter*>* param_base,
            int32_t& base_version,
            DynArray<const SGParamInfo*>* target_param_infos);

    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_parameter_dictionary(CMap<TParameter*, CSGObject*>& dict);

#ifdef TRACE_MEMORY_ALLOCS
    static void list_memory_allocs()
    {
            shogun::list_memory_allocs();
    }
#endif

protected:
    virtual TParameter* migrate(DynArray<TParameter*>* param_base,
            const SGParamInfo* target);

    virtual void one_to_one_migration_prepare(DynArray<TParameter*>* param_base,
            const SGParamInfo* target, TParameter*& replacement,
            TParameter*& to_migrate, char* old_name=NULL);

    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);

public:
    virtual bool update_parameter_hash();

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

    bool is_param_new(const SGParamInfo param_info) const;

    bool save_parameter_version(CSerializableFile* file, const char* prefix="",
            int32_t param_version=VERSION_PARAMETER);

    int32_t load_parameter_version(CSerializableFile* file,
            const char* prefix="");

    /*Gets an incremental hash of all parameters as well as the parameters
     * of CSGObject children of the current object's parameters.
     *
     * @param param Parameter to hash
     * @param current hash
     * @param carry value for Murmur3 incremental hash
     * @param total_length total byte length of all hashed
     * parameters so far. Byte length of parameters will be added
     * to the total length
     */
    void get_parameter_incremental_hash(Parameter* param,
            uint32_t& hash, uint32_t& carry, uint32_t& total_length);

public:
    SGIO* io;

    Parallel* parallel;

    Version* version;

    Parameter* m_parameters;

    Parameter* m_model_selection_parameters;

    ParameterMap* m_parameter_map;

    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;

    int32_t m_refcount;

#ifdef HAVE_PTHREAD
    PTHREAD_LOCK_T m_ref_lock;
#endif //HAVE_PTHREAD
};
}
#endif // __SGOBJECT_H__