core/fwAtoms/include/fwAtoms/Base.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2015.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWATOMS_BASE_HPP__
#define __FWATOMS_BASE_HPP__


#include <string>

#include <fwCore/base.hpp>

#include "fwAtoms/factory/new.hpp"
#include "fwAtoms/registry/detail.hpp"
#include "fwAtoms/config.hpp"


namespace fwAtoms
{

class FWATOMS_CLASS_API Base : public ::fwCore::BaseObject
{
public:
    typedef ::fwAtoms::factory::Key Key;

    FWATOMS_API static const std::string s_VERSION;

    template <typename T>
    class Registrar
    {
    public:
        Registrar()
        {
            ::fwAtoms::registry::get()->addFactory(T::classname(), &::fwAtoms::factory::New<T>);
        }
    };

    typedef enum
    {
        BOOLEAN = 1,
        NUMERIC,
        STRING,
        OBJECT,
        SEQUENCE,
        MAP,
        BLOB
    } AtomType;

    fwCoreNonInstanciableClassDefinitionsMacro( (Base)(::fwCore::BaseObject) );
    fwCoreAllowSharedFromThis();

    virtual ~Base()
    {
    }

    virtual Base::sptr clone() const = 0;

    bool isValue() const
    {
        return (type() == BOOLEAN) || (type() == NUMERIC) || (type() == STRING);
    }

    bool isBoolean() const
    {
        return (type() == BOOLEAN);
    }

    bool isNumeric() const
    {
        return (type() == NUMERIC);
    }

    bool isString() const
    {
        return (type() == STRING);
    }

    bool isSequence() const
    {
        return (type() == SEQUENCE);
    }

    bool isMapping() const
    {
        return (type() == MAP);
    }

    bool isBlob() const
    {
        return (type() == BLOB);
    }

    bool isObject() const
    {
        return (type() == OBJECT);
    }

    FWATOMS_API virtual std::string getString() const;

    virtual AtomType type() const = 0;

protected:
    Base()
    {
    }

};

}

#endif /* __FWATOMS_BASE_HPP__ */