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

#pragma once

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

    // XMLVACYp
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 )
    {
    }
    CConst()
    {
    }
    ~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 );
};
class Consts : public Jenga::Common::Hashmap<CConst>
{
    // XMLVACYp
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:

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

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

    // XMLVACYp
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 );
};
class ConstMacros
    : public Jenga::Common::Hashmap<ConstMacro>
{
    // XMLVACYp
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:
    bool Add( const Symbol &symbol, const char *parameterStr );
    ConstMacro *Find( const Symbol &name );
};