SGObject.cpp

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-2009 Soeren Sonnenburg
 * Copyright (C) 2008-2009 Fraunhofer Institute FIRST and Max Planck Society
 */

#include "base/SGObject.h"
#include "lib/io.h"
#include "base/Parallel.h"
#include "base/init.h"
#include "base/Version.h"
#include "base/Parameter.h"

#include <stdlib.h>
#include <stdio.h>


namespace shogun
{
    class CMath;
    class Parallel;
    class IO;
    class Version;

    extern CMath* sg_math;
    extern Parallel* sg_parallel;
    extern IO* sg_io;
    extern Version* sg_version;

    template<> void CSGObject::set_generic<bool>()
    {
        m_generic = PT_BOOL;
    }

    template<> void CSGObject::set_generic<char>()
    {
        m_generic = PT_CHAR;
    }

    template<> void CSGObject::set_generic<int8_t>()
    {
        m_generic = PT_INT8;
    }

    template<> void CSGObject::set_generic<uint8_t>()
    {
        m_generic = PT_UINT8;
    }

    template<> void CSGObject::set_generic<int16_t>()
    {
        m_generic = PT_INT16;
    }

    template<> void CSGObject::set_generic<uint16_t>()
    {
        m_generic = PT_UINT16;
    }

    template<> void CSGObject::set_generic<int32_t>()
    {
        m_generic = PT_INT32;
    }

    template<> void CSGObject::set_generic<uint32_t>()
    {
        m_generic = PT_UINT32;
    }

    template<> void CSGObject::set_generic<int64_t>()
    {
        m_generic = PT_INT64;
    }

    template<> void CSGObject::set_generic<uint64_t>()
    {
        m_generic = PT_UINT64;
    }

    template<> void CSGObject::set_generic<float32_t>()
    {
        m_generic = PT_FLOAT32;
    }

    template<> void CSGObject::set_generic<float64_t>()
    {
        m_generic = PT_FLOAT64;
    }

    template<> void CSGObject::set_generic<floatmax_t>()
    {
        m_generic = PT_FLOATMAX;
    }

} /* namespace shogun  */

using namespace shogun;

CSGObject::CSGObject()
{
    init();
    set_global_objects();
    pthread_mutex_init(&m_ref_mutex, NULL);

    SG_GCDEBUG("SGObject created (%p)\n", this);
}

CSGObject::CSGObject(const CSGObject& orig)
:io(orig.io), parallel(orig.parallel), version(orig.version)
{
    init();
    set_global_objects();
}

CSGObject::~CSGObject()
{
    SG_GCDEBUG("SGObject destroyed (%p)\n", this);

    pthread_mutex_destroy(&m_ref_mutex);
    unset_global_objects();
    delete m_parameters;
}

void CSGObject::set_global_objects(void)
{
    if (!sg_io || !sg_parallel || !sg_version)
    {
        fprintf(stderr, "call init_shogun() before using the library, dying.\n");
        exit(1);
    }

    SG_REF(sg_io);
    SG_REF(sg_parallel);
    SG_REF(sg_version);

    io=sg_io;
    parallel=sg_parallel;
    version=sg_version;
}

void CSGObject::unset_global_objects(void)
{
    SG_UNREF(version);
    SG_UNREF(parallel);
    SG_UNREF(io);
}

void CSGObject::set_io(IO* new_io)
{
    SG_UNREF(sg_io);
    sg_io=new_io;
    SG_REF(sg_io);
}

IO* CSGObject::get_io()
{
    SG_REF(sg_io);
    return sg_io;
}

void CSGObject::set_parallel(Parallel* new_parallel)
{
    SG_UNREF(sg_parallel);
    sg_parallel=new_parallel;
    SG_REF(sg_parallel);
}

Parallel* CSGObject::get_parallel()
{
    SG_REF(sg_parallel);
    return sg_parallel;
}

void CSGObject::set_version(Version* new_version)
{
    SG_UNREF(sg_version);
    sg_version=new_version;
    SG_REF(sg_version);
}

Version* CSGObject::get_version()
{
    SG_REF(sg_version);
    return sg_version;
}

bool CSGObject::is_generic(EPrimitiveType* generic) const
{
    *generic = m_generic;

    return m_generic != PT_NOT_GENERIC;
}

void CSGObject::unset_generic()
{
    m_generic = PT_NOT_GENERIC;
}

void CSGObject::print_serializable(const char* prefix)
{
    SG_PRINT("\n%s\n================================================================================\n", get_name());
    m_parameters->print(prefix);
}

bool CSGObject::save_serializable(CSerializableFile* file,
                                   const char* prefix)
{
    SG_DEBUG("START SAVING CSGObject '%s'\n", get_name());
    try
    {
        save_serializable_pre();
    }
    catch (ShogunException e)
    {
        SG_SWARNING("%s%s::save_serializable_pre(): ShogunException: "
                   "%s\n", prefix, get_name(),
                   e.get_exception_string());
        return false;
    }
    if (!m_save_pre_called)
    {
        SG_SWARNING("%s%s::save_serializable_pre(): Implementation "
                   "error: BASE_CLASS::LOAD_SERIALIZABLE_PRE() not "
                   "called!\n", prefix, get_name());
        return false;
    }

    if (!m_parameters->save(file, prefix))
        return false;

    try
    {
        save_serializable_post();
    }
    catch (ShogunException e)
    {
        SG_SWARNING("%s%s::save_serializable_post(): ShogunException: "
                   "%s\n", prefix, get_name(),
                   e.get_exception_string());
        return false;
    }

    if (!m_save_post_called)
    {
        SG_SWARNING("%s%s::save_serializable_post(): Implementation "
                   "error: BASE_CLASS::LOAD_SERIALIZABLE_POST() not "
                   "called!\n", prefix, get_name());
        return false;
    }

    if (prefix == NULL || *prefix == '\0')
        file->close();

    SG_DEBUG("DONE SAVING CSGObject '%s'\n", get_name());

    return true;;
}

bool CSGObject::load_serializable(CSerializableFile* file,
                                   const char* prefix)
{
    SG_DEBUG("START LOADING CSGObject '%s'\n", get_name());
    try
    {
        load_serializable_pre();
    }
    catch (ShogunException e)
    {
        SG_SWARNING("%s%s::load_serializable_pre(): ShogunException: "
                   "%s\n", prefix, get_name(),
                   e.get_exception_string());
        return false;
    }
    if (!m_load_pre_called)
    {
        SG_SWARNING("%s%s::load_serializable_pre(): Implementation "
                   "error: BASE_CLASS::LOAD_SERIALIZABLE_PRE() not "
                   "called!\n", prefix, get_name());
        return false;
    }

    if (!m_parameters->load(file, prefix))
        return false;

    try
    {
        load_serializable_post();
    }
    catch (ShogunException e)
    {
        SG_SWARNING("%s%s::load_serializable_post(): ShogunException: "
                   "%s\n", prefix, get_name(),
                   e.get_exception_string());
        return false;
    }

    if (!m_load_post_called)
    {
        SG_SWARNING("%s%s::load_serializable_post(): Implementation "
                   "error: BASE_CLASS::LOAD_SERIALIZABLE_POST() not "
                   "called!\n", prefix, get_name());
        return false;
    }
    SG_DEBUG("DONE LOADING CSGObject '%s'\n", get_name());

    return true;
}

void CSGObject::load_serializable_pre() throw (ShogunException)
{
    m_load_pre_called = true;
}

void CSGObject::load_serializable_post() throw (ShogunException)
{
    m_load_post_called = true;
}

void CSGObject::save_serializable_pre() throw (ShogunException)
{
    m_save_pre_called = true;
}

void CSGObject::save_serializable_post() throw (ShogunException)
{
    m_save_post_called = true;
}

void CSGObject::init()
{
    m_refcount = 0;
    io = NULL;
    parallel = NULL;
    version = NULL;
    m_parameters = new Parameter();
    m_generic = PT_NOT_GENERIC;
    m_load_pre_called = false;
    m_load_post_called = false;
}