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

#pragma once

class Parameter : public Type
{
    std::string varName;
    bool isRef;
    bool isArray;
    Subscripts subscripts;

    std::string initValue;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - Parameter" );

        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Type );
        ar & BOOST_SERIALIZATION_NVP( varName );
        ar & BOOST_SERIALIZATION_NVP( isRef );
        ar & BOOST_SERIALIZATION_NVP( isArray );
        ar & BOOST_SERIALIZATION_NVP( subscripts );
        ar & BOOST_SERIALIZATION_NVP( initValue );
    }

public:
    Parameter( const std::string &varName, const Type &type, bool isRef = false, const std::string initValue = "" );
    Parameter( const Parameter &param, const Type &type );
    Parameter( const Parameter &param );
    Parameter(Parameter&& param)
        : varName(std::move(param.varName))
        , isRef(std::move(param.isRef))
        , isArray(std::move(param.isArray))
        , subscripts(std::move(param.subscripts))
        , initValue(std::move(param.initValue)) {}
    Parameter();
    ~Parameter();

    Parameter& operator =(Parameter&& y)
    {
        varName = std::move(y.varName);
        isRef = std::move(y.isRef);
        isArray = std::move(y.isArray);
        subscripts = std::move(y.subscripts);
        initValue = std::move(y.initValue);
        return *this;
    }

    Parameter& operator =(Parameter const& y)
    {
        return *this = std::move(Parameter(y));
    }
    
    void SetArray( const Subscripts &subscripts ){
        isArray = true;
        this->subscripts = subscripts;
    }

    const std::string &GetVarName() const
    {
        return varName;
    }

    bool IsRef() const
    {
        return isRef;
    }
    bool IsArray() const
    {
        return isArray;
    }
    const Subscripts &GetSubscripts() const
    {
        return subscripts;
    }

    const std::string &GetInitValue() const
    {
        return initValue;
    }

    bool Equals( const Parameter &param, bool isContravariant ) const;
    bool Equals( const Types &actualTypeParametersForThisProc, const Parameter &param, bool isContravariant ) const;
};

class Parameters : public std::vector<Parameter *>
{
    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing - Parameters" );

        ar & boost::serialization::make_nvp("vector_Parameter", boost::serialization::base_object<std::vector<Parameter *>>(*this));
    }

public:
    Parameters() : std::vector<Parameter *>() {}
    Parameters(Parameters&& y) : std::vector<Parameter *>(std::move(y)) {}
    Parameters(Parameters const& y) : std::vector<Parameter *>(y) {}

    Parameters& operator =(Parameters&& y)
    {
        std::vector<Parameter *>::operator =(std::move(y));
        return *this;
    }

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

    bool Equals( const Parameters &params, bool isContravariant = false ) const;
    bool Equals( const Types &actualTypeParametersForThisProc, const Parameters &params, bool isContravariant = false ) const;

    int GetMemorySize() const
    {
        return (int)this->size() * PTR_SIZE;
    }
};