operator.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Operator_
 
    #define Om_Language_Operator_ \
    Om::Language::Operator
 
    #include "om/language/default_atom.hpp"
    #include "om/language/symbol/operand_symbol.hpp"
    #include "om/language/symbol/operator_symbol.hpp"
    #include "om/language/symbol/separator_symbol.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include "boost/locale/boundary.hpp"
 
    #endif
 
    #define Om_Language_Operator_GetName_() \
    "operator"
 
namespace Om {
 
    namespace Language {
 
        // MARK: - Om::Language::Operator
 
        class Operator:
        public DefaultAtom<Operator> {
 
        public: // MARK: public (static)
 
            static char const * GetName();
 
        public: // MARK: public (non-static)
 
            Operator();
 
            explicit Operator(std::string const &);
 
            explicit Operator(
                char const theCodeUnitIterator[]
            );
 
            explicit Operator(
                Om::Source::Source<CodePoint const> &
            );
 
            explicit Operator(Symbol::OperandSymbol const);
 
            explicit Operator(Symbol::OperatorSymbol const);
 
            explicit Operator(Symbol::SeparatorSymbol const);
 
            Operator & operator =(Operator);
 
            void BackGiveCodePoint(Consumer &);
 
            template <boost::locale::boundary::boundary_type theSegment>
            void BackGiveSegment(Consumer &);
 
            template <typename TheConsumer>
            void Decode(TheConsumer &) const;
 
            template <typename TheProducer>
            void Encode(TheProducer &);
 
            void FrontGiveCodePoint(Consumer &);
 
            template <boost::locale::boundary::boundary_type theSegment>
            void FrontGiveSegment(Consumer &);
 
            void Normalize();
 
            virtual void ParseElements(Reader &);
 
            virtual void ParseQuotedElements(Reader &);
 
            template <typename TheOperand>
            void TakeOperand(TheOperand &);
 
            template <typename TheOperator>
            void TakeOperator(TheOperator &);
 
            template <typename TheProducer>
            void TakeQuotedProducer(TheProducer &);
 
            template <typename TheSeparator>
            void TakeSeparator(TheSeparator &);
 
        };
 
    }
 
}
 
namespace boost {
 
    // MARK: - boost::
 
    template <>
    void swap(
        Om::Language::Operator &,
        Om::Language::Operator &
    );
 
}
 
    #include "om/language/operator.cpp"
 
#endif