source: dev/trunk/ab5.0/abdev/ab_common/include/Lexical/RelationalObjectModuleItem.h

#pragma once

class ObjectModule;

namespace ActiveBasic{ namespace Common{ namespace Lexical{


class RelationalObjectModuleItem
    : public Symbol
{
    int relationalObjectModuleIndex;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Symbol );
        ar & BOOST_SERIALIZATION_NVP( relationalObjectModuleIndex );
    }

protected:
    RelationalObjectModuleItem(RelationalObjectModuleItem&& relationalObjectModuleItem)
        : Symbol(std::move(relationalObjectModuleItem))
        , relationalObjectModuleIndex(std::move(relationalObjectModuleItem.relationalObjectModuleIndex))
        , isNeedResolve(std::move(false))
    {
    }

    RelationalObjectModuleItem( const RelationalObjectModuleItem &relationalObjectModuleItem )
        : Symbol( relationalObjectModuleItem )
        , relationalObjectModuleIndex( relationalObjectModuleItem.relationalObjectModuleIndex )
        , isNeedResolve( false )
    {
    }

    RelationalObjectModuleItem( const Symbol &symbol )
        : Symbol( symbol )
        , relationalObjectModuleIndex( 0 )
        , isNeedResolve( false )
    {
    }

    RelationalObjectModuleItem()
        : relationalObjectModuleIndex( -1 )
        , isNeedResolve( false )
    {
    }

    RelationalObjectModuleItem& operator =(RelationalObjectModuleItem&& y)
    {
        Symbol::operator =(std::move(y));
        relationalObjectModuleIndex = std::move(y.relationalObjectModuleIndex);
        isNeedResolve = std::move(y.isNeedResolve);
        return *this;
    }

    RelationalObjectModuleItem& operator =(RelationalObjectModuleItem const& y)
    {
        Symbol::operator =(y);
        relationalObjectModuleIndex = y.relationalObjectModuleIndex;
        isNeedResolve = y.isNeedResolve;
        return *this;
    }

public:
    int GetRelationalObjectModuleIndex() const
    {
        return relationalObjectModuleIndex;
    }
    void SetRelationalObjectModuleIndex( int relationalObjectModuleIndex )
    {
        this->relationalObjectModuleIndex = relationalObjectModuleIndex;
    }

    virtual void ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable )
    {
        this->relationalObjectModuleIndex = relationTable[this->relationalObjectModuleIndex];
    }

    bool IsExternal() const
    {
        return ( relationalObjectModuleIndex != 0 );
    }

    bool isNeedResolve;
    bool IsNeedResolve() const
    {
        return isNeedResolve;
    }
    void NeedResolve()
    {
        isNeedResolve = true;
    }

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


}}}