source: dev/trunk/ab5.0/abdev/ab_common/include/Lexical/Const.h@ 829

#pragma once

class CConst
    : public RelationalObjectModuleItem
    , public Jenga::Common::ObjectInHashmap<CConst>
{
    Type type;
    _int64 i64data;

    // XML繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ逕ｨ
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - CConst" );

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( RelationalObjectModuleItem );

        if( ActiveBasic::Common::Environment::IsRemoveExternal() )
        {
            if( this->IsExternal() )
            {
                this->NeedResolve();
                return;
            }
        }

        ar & BOOST_SERIALIZATION_NVP( type );
        ar & BOOST_SERIALIZATION_NVP( i64data );
    }

public:
    CConst( const Symbol &symbol, const Type &newType, _int64 i64data)
        : RelationalObjectModuleItem( symbol )
        , type( newType )
        , i64data( i64data )
    {
    }
    CConst( const Symbol &symbol, int value)
        : RelationalObjectModuleItem( symbol )
        , type( Type(DEF_LONG) )
        , i64data( value )
    {
    }
private:
    CConst()
        : RelationalObjectModuleItem()
        , type()
        , i64data()
    {
    }
public:
    ~CConst()
    {
    }

    virtual const std::string &GetKeyName() const
    {
        return GetName();
    }

    Type GetType()
    {
        return type;
    }
    _int64 GetWholeData()
    {
        return i64data;
    }
    double GetDoubleData();

    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );

private:
    CConst(CConst const&);
    CConst& operator =(CConst const&);
};
class Consts : public Jenga::Common::Hashmap<CConst>
{
    // XML繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ逕ｨ
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - Consts" );

        ar & boost::serialization::make_nvp("Hashmap_CConst",
            boost::serialization::base_object<Jenga::Common::Hashmap<CConst>>(*this));
    }

public:
    Consts() {}

    void Add( const Symbol &symbol, _int64 i64data, const Type &type );
    void Add( const Symbol &symbol, int value);

private:
    CConst *GetObjectPtr( const Symbol &symbol );
public:

    int GetBasicType( const Symbol &symbol );
    _int64 GetWholeData( const Symbol &symbol );
    double GetDoubleData( const Symbol &symbol );
    bool IsStringPtr( const Symbol &symbol, bool isUnicode );

private:
    Consts(Consts const&);
    Consts& operator =(Consts const&);
};

class ConstMacro
    : public RelationalObjectModuleItem
    , public Jenga::Common::ObjectInHashmap<ConstMacro>
{
    std::vector<std::string> parameters;
    std::string expression;

    // XML繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ逕ｨ
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - ConstMacro" );

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( RelationalObjectModuleItem );

        if( ActiveBasic::Common::Environment::IsRemoveExternal() )
        {
            if( this->IsExternal() )
            {
                this->NeedResolve();
                return;
            }
        }

        ar & BOOST_SERIALIZATION_NVP( parameters );
        ar & BOOST_SERIALIZATION_NVP( expression );
    }

public:
    ConstMacro( const Symbol &symbol, const std::vector<std::string> &parameters, const std::string &expression )
        : RelationalObjectModuleItem( symbol )
        , parameters( parameters )
        , expression( expression )
    {
    }
    ConstMacro()
    {
    }
    ~ConstMacro()
    {
    }

    virtual const std::string &GetKeyName() const
    {
        return GetName();
    }

    const std::vector<std::string> &GetParameters() const
    {
        return parameters;
    }
    const std::string &GetExpression() const
    {
        return expression;
    }

    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );

private:
    ConstMacro(ConstMacro const&);
    ConstMacro& operator =(ConstMacro const&);
};
class ConstMacros
    : public Jenga::Common::Hashmap<ConstMacro>
{
    // XML繧ｷ繝ｪ繧｢繝ｩ繧､繧ｺ逕ｨ
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - ConstMacros" );

        ar & boost::serialization::make_nvp("Hashmap_ConstMacro",
            boost::serialization::base_object<Jenga::Common::Hashmap<ConstMacro>>(*this));
    }

public:
    ConstMacros() {}

    bool Add( const Symbol &symbol, const char *parameterStr );
    ConstMacro *Find( const Symbol &name );

private:
    ConstMacros(ConstMacros const&);
    ConstMacros& operator =(ConstMacros const&);
};