lexicon.hpp

Go to the documentation of this file.

 
#ifndef Om_Language_Lexicon_
 
    #define Om_Language_Lexicon_ \
    Om::Language::Lexicon
 
    #include "om/language/pair.hpp"
    #include "om/language/translator.hpp"
    #include "om/list.hpp"
    #include "om/source/default_source.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include "boost/ptr_container/ptr_map.hpp"
 
    #endif
 
    #define Om_Language_Lexicon_GetName_() \
    "lexicon"
 
namespace Om {
 
    namespace Language {
 
        class Evaluation;
 
        // MARK: - Om::Language::Lexicon
 
        class Lexicon:
        public DefaultProgram<Lexicon>,
        public Translator {
 
        public: // MARK: public (static)
 
            class ElementRange;
 
            static char const * GetName();
 
        public: // MARK: public (non-static)
 
            Lexicon();
 
            Lexicon(Lexicon const &);
 
            Lexicon & operator =(Lexicon);
 
            void BackGivePair(Consumer &);
 
            virtual void Clear();
 
            Pair const & Find(Operator const &) const;
 
            void FrontGivePair(Consumer &);
 
            virtual std::auto_ptr<
                Om::Source::Source<Element const>
            > GetElementRange() const;
 
            virtual void GiveElements(Consumer &);
 
            virtual void GiveElements(Consumer &) const;
 
            virtual bool IsEmpty() const;
 
            virtual void ParseElements(Reader &);
 
            virtual void ParseQuotedElements(Reader &);
 
            void Swap(Lexicon &);
 
            template <typename TheOperand>
            void TakeOperand(TheOperand &);
 
            template <typename TheOperator>
            void TakeOperator(TheOperator &);
 
            template <typename TheProducer>
            void TakeQuotedProducer(TheProducer &);
 
            template <typename TheSeparator>
            void TakeSeparator(TheSeparator &);
 
            virtual bool Translate(
                Evaluation &,
                Operator const &
            ) const;
 
        private: // MARK: private (static)
 
            typedef List<Pair> PairList;
 
            typedef boost::ptr_map<
                std::string,
                PairList::Node
            > Map;
 
            template <typename TheNode>
            static void GiveElements(
                TheNode * theFirstNode,
                Consumer & theConsumer
            );
 
        private: // MARK: private (non-static)
 
            PairList::Node & GetOperandTaker();
 
            template <typename TheOperator>
            PairList::Node & GetOperandTaker(TheOperator &);
 
            void GivePair(
                PairList::NodeIndex const,
                Consumer &
            );
 
            Map thisMap;
 
            PairList thisPairList;
 
        };
 
        // MARK: - Om::Language::Lexicon::ElementRange
 
        class Lexicon::ElementRange:
        public Om::Source::DefaultSource<
            Element const,
            ElementRange
        > {
 
        public: // MARK: public (non-static)
 
            ElementRange();
 
            explicit ElementRange(Lexicon const &);
 
            virtual bool operator !() const;
 
            virtual Element const & operator *() const;
 
            using Om::Source::DefaultSource<
                Element const,
                ElementRange
            >::Equals;
 
            bool Equals(ElementRange const &) const;
 
            virtual void Pop();
 
        private: // MARK: private (non-static)
 
            PairList::Node const * thisNode;
 
            char thisOffset;
 
        };
 
        // MARK: - Om::Language::
 
        bool operator ==(
            Lexicon::ElementRange const &,
            Lexicon::ElementRange const &
        );
 
        bool operator !=(
            Lexicon::ElementRange const &,
            Lexicon::ElementRange const &
        );
 
    }
 
}
 
namespace boost {
 
    // MARK: - boost::
 
    template <>
    void swap(
        Om::Language::Lexicon &,
        Om::Language::Lexicon &
    );
 
}
 
    #include "om/language/lexicon.cpp"
 
#endif