consumer.cpp

Go to the documentation of this file.

 
#ifndef Om_Language_Consumer_
 
    #include "om/language/consumer.hpp"
 
#else
 
    #include "om/language/reader.hpp"
 
    #ifndef Om_Macro_Precompilation_
 
        #include <cassert>
        #include <stdexcept>
 
    #endif
 
// MARK: - Om::Language::Consumer
 
    #define Type_ \
    Om::Language::Consumer
 
// MARK: public (non-static)
 
inline Type_::~Consumer() {}
 
template<
    typename TheOperator,
    typename TheSeparator
>
inline void Type_::Parse(Reader & theReader) {
    while (theReader) {
        assert(Symbol::theEndOperandSymbol != *theReader);
        switch (*theReader) {
        case Symbol::theStartOperandSymbol:
            theReader.Pop();
            {
                // Ensure that this does not resolve to the copy constructor.
                Om::Source::Source<CodePoint const> & theCodePointSource = theReader;
 
                Reader theOperandReader(theCodePointSource);
                this->ParseQuotedElements(theOperandReader);
            }
            if (!theReader) {
                return;
            }
            assert(Symbol::theEndOperandSymbol == *theReader);
            theReader.Pop();
            continue;
        Om_Language_Symbol_SeparatorSymbol_GetCases_():
            {
                TheSeparator theSeparator(theReader);
                this->TakeElement(theSeparator);
            }
            continue;
        default:
            {
                TheOperator theOperator(theReader);
                this->TakeElement(theOperator);
            }
            // Fall through.
        }
    }
}
 
inline void Type_::ParseElements(Reader &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::ParseQuotedElements(Reader &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElement(Operand &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElement(Null &) {}
 
inline void Type_::TakeElement(Null const &) {}
 
inline void Type_::TakeElement(Operand const &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElement(Operator &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElement(Operator const &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElement(Separator &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElement(Separator const &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElements(Producer &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeElements(Producer const &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeQuotedElements(Producer &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
inline void Type_::TakeQuotedElements(Producer const &) {
    assert(0);
    throw std::logic_error("Pure virtual function called.");
}
 
    #undef Type_
 
#endif