LG.h

Go to the documentation of this file.

 
/*
 * This file is part of Algorithms library toolkit.
 * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
 
 * Algorithms library toolkit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 
 * Algorithms library toolkit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License
 * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <grammar/ContextFree/LG.h>
#include "../common/GrammarFromXMLParser.h"
#include "../common/GrammarToXMLComposer.h"
#include <grammar/AddRawRule.h>
 
#include <container/xml/ObjectsVariant.h>
 
namespace core {
 
template < class TerminalSymbolType, class NonterminalSymbolType >
struct xmlApi < grammar::LG < TerminalSymbolType, NonterminalSymbolType > > {
    static std::string xmlTagName() {
        return "LG";
    }
 
    static bool first ( const ext::deque < sax::Token >::const_iterator & input ) {
        return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
    }
 
    static grammar::LG < TerminalSymbolType, NonterminalSymbolType > parse ( ext::deque < sax::Token >::iterator & input );
 
    static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 
    static void compose ( ext::deque < sax::Token > & out, const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 
    static void composeRules ( ext::deque < sax::Token > & out, const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
};
 
template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::LG < TerminalSymbolType, NonterminalSymbolType > xmlApi < grammar::LG < TerminalSymbolType, NonterminalSymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
    sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
 
    ext::set < NonterminalSymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < NonterminalSymbolType > ( input );
    ext::set < TerminalSymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < TerminalSymbolType > ( input );
    NonterminalSymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < NonterminalSymbolType > ( input );
 
    grammar::LG < TerminalSymbolType, NonterminalSymbolType > grammar ( std::move ( initialSymbol ) );
 
    grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
    grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
 
    grammar::GrammarFromXMLParser::parseRules ( input, grammar );
 
    sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, xmlTagName ( ) );
    return grammar;
}
 
template < class TerminalSymbolType, class NonterminalSymbolType >
void xmlApi < grammar::LG < TerminalSymbolType, NonterminalSymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
    NonterminalSymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < NonterminalSymbolType > ( input );
    ext::vector < ext::variant < TerminalSymbolType, NonterminalSymbolType > > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < ext::variant < TerminalSymbolType, NonterminalSymbolType > > ( input );
 
    grammar::AddRawRule::addRawRule ( grammar, std::move ( lhs ), std::move ( rhs ) );
}
 
template < class TerminalSymbolType, class NonterminalSymbolType >
void xmlApi < grammar::LG < TerminalSymbolType, NonterminalSymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
    out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::START_ELEMENT );
 
    grammar::GrammarToXMLComposer::composeNonterminalAlphabet ( out, grammar.getNonterminalAlphabet ( ) );
    grammar::GrammarToXMLComposer::composeTerminalAlphabet ( out, grammar.getTerminalAlphabet ( ) );
    grammar::GrammarToXMLComposer::composeInitialSymbol ( out, grammar.getInitialSymbol ( ) );
    composeRules ( out, grammar );
 
    out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
}
 
template < class TerminalSymbolType, class NonterminalSymbolType >
void xmlApi < grammar::LG < TerminalSymbolType, NonterminalSymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
    out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
 
    for ( const auto & rule : grammar.getRules ( ) )
 
        for ( const auto & rhs : rule.second ) {
            out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
 
            grammar::GrammarToXMLComposer::composeRuleSingleSymbolLHS ( out, rule.first );
            grammar::GrammarToXMLComposer::composeRuleLGRHS ( out, rhs );
 
            out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
        }
 
    out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
}
 
} /* namespace core */