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

#pragma once

namespace ActiveBasic{ namespace Common{ namespace Lexical{


class ResolveError
{
    int relationalObjectModuleIndex;
    std::string targetItemName;
public:
    ResolveError( int relationalObjectModuleIndex, const std::string targetItemName )
        : relationalObjectModuleIndex( relationalObjectModuleIndex )
        , targetItemName( targetItemName )
    {
    }

    ResolveError(ResolveError&& y)
        : relationalObjectModuleIndex(std::move(y.relationalObjectModuleIndex))
        , targetItemName(std::move(y.targetItemName))
    {
    }

    ResolveError(ResolveError const& y)
        : relationalObjectModuleIndex(y.relationalObjectModuleIndex)
        , targetItemName(y.targetItemName)
    {
    }

    ResolveError& operator =(ResolveError&& y)
    {
        relationalObjectModuleIndex = std::move(y.relationalObjectModuleIndex);
        targetItemName = std::move(y.targetItemName);
        return *this;
    }

    ResolveError& operator =(ResolveError const& y)
    {
        return *this = std::move(ResolveError(y));
    }

    int GetRelationalObjectModuleIndex() const
    {
        return relationalObjectModuleIndex;
    }
    const std::string &GetTargetItemName() const
    {
        return targetItemName;
    }
};
class ResolveErrors
    : public std::vector<ResolveError>
{
public:
    ResolveErrors() {}
    ResolveErrors(ResolveErrors&& y) : std::vector<ResolveError>(std::move(y)) {}
    ResolveErrors(ResolveErrors const& y) : std::vector<ResolveError>(y) {}
    ResolveErrors& operator =(ResolveErrors&& y)
    {
        std::vector<ResolveError>::operator =(std::move(y));
        return *this;
    }
    ResolveErrors& operator =(ResolveErrors const& y)
    {
        return *this = std::move(ResolveErrors(y));
    }

    void Add( const ResolveError &resolveError )
    {
        this->push_back( resolveError );
    }
};


}}}