operand.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Operand_
 
    #define Om_Language_Operand_ \
    Om::Language::Operand
 
    #include "om/language/default_element.hpp"
    #include "om/owner.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include "boost/swap.hpp"
 
    #endif
 
    #define Om_Language_Operand_GetName_() \
    "operand"
 
namespace Om {
 
    namespace Language {
 
        // MARK: - Om::Language::Operand
 
        class Operand:
        public DefaultElement<Operand> {
 
        public: // MARK: public (static)
 
            static char const * GetName();
 
        public: // MARK: public (non-static)
 
            Operand();
 
            template <typename TheProgram>
            explicit Operand(
                std::auto_ptr<TheProgram>
            );
 
            Operand & operator =(Operand);
 
            virtual Program & operator *();
 
            virtual Program const & operator *() const;
 
            virtual void Clear();
 
            using DefaultElement<Operand>::Equals;
 
            bool Equals(Operand const &) const;
 
            Program * GetProgram();
 
            Program const * GetProgram() const;
 
            virtual bool IsEmpty() const;
 
            virtual void ParseElements(Reader &);
 
            virtual void ParseQuotedElements(Reader &);
 
            template <typename TheProgram>
            void SetProgram(
                std::auto_ptr<TheProgram>
            );
 
            void Swap(Operand &);
 
            virtual void TakeElements(Producer &);
 
            virtual void TakeElements(Producer const &);
 
            template <typename TheOperand>
            void TakeOperand(TheOperand &);
 
            template <typename TheOperator>
            void TakeOperator(TheOperator &);
 
            template <typename TheProducer>
            void TakeQuotedProducer(TheProducer &);
 
            template <typename TheSeparator>
            void TakeSeparator(TheSeparator &);
 
        private: // MARK: private (non-static)
 
            Owner<Program> thisProgram;
 
        };
 
        // MARK: - Om::Language::
 
        bool operator ==(
            Operand const &,
            Operand const &
        );
 
        bool operator !=(
            Operand const &,
            Operand const &
        );
 
    }
 
}
 
namespace boost {
 
    // MARK: - boost::
 
    template <>
    void swap(
        Om::Language::Operand &,
        Om::Language::Operand &
    );
 
}
 
    #include "om/language/operand.cpp"
 
#endif