CSG.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/ContextSensitive/CSG.h>
#include "../common/GrammarFromXMLParser.h"
#include "../common/GrammarToXMLComposer.h"
 
namespace core {
 
template < class SymbolType >
struct xmlApi < grammar::CSG < SymbolType > > {
    static std::string xmlTagName() {
        return "CSG";
    }
 
    static bool first ( const ext::deque < sax::Token >::const_iterator & input ) {
        return sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
    }
 
    static grammar::CSG < SymbolType > parse ( ext::deque < sax::Token >::iterator & input );
 
    static void parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CSG < SymbolType > & grammar );
 
    static void compose ( ext::deque < sax::Token > & out, const grammar::CSG < SymbolType > & grammar );
 
    static void composeRules ( ext::deque < sax::Token > & out, const grammar::CSG < SymbolType > & grammar );
};
 
template < class SymbolType >
grammar::CSG < SymbolType > xmlApi < grammar::CSG < SymbolType > >::parse ( ext::deque < sax::Token >::iterator & input ) {
    sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, xmlTagName ( ) );
 
    ext::set < SymbolType > nonterminalAlphabet = grammar::GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
    ext::set < SymbolType > terminalAlphabet = grammar::GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
    SymbolType initialSymbol = grammar::GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
    grammar::CSG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
    grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
    grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
 
    grammar::GrammarFromXMLParser::parseRules ( input, grammar );
 
    bool generatesEpsilon = grammar::GrammarFromXMLParser::parseGeneratesEpsilon ( input );
    grammar.setGeneratesEpsilon ( generatesEpsilon );
 
    sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, xmlTagName ( ) );
    return grammar;
}
 
template < class SymbolType >
void xmlApi < grammar::CSG < SymbolType > >::parseRule ( ext::deque < sax::Token >::iterator & input, grammar::CSG < SymbolType > & grammar ) {
    ext::vector < SymbolType > lContext = grammar::GrammarFromXMLParser::parseRuleLContext < SymbolType > ( input );
    SymbolType lhs = grammar::GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
    ext::vector < SymbolType > rContext = grammar::GrammarFromXMLParser::parseRuleRContext < SymbolType > ( input );
    ext::vector < SymbolType > rhs = grammar::GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
    grammar.addRule ( std::move ( lContext ), std::move ( lhs ), std::move ( rContext ), std::move ( rhs ) );
}
 
template < class SymbolType >
void xmlApi < grammar::CSG < SymbolType > >::compose ( ext::deque < sax::Token > & out, const grammar::CSG < SymbolType > & 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 );
    grammar::GrammarToXMLComposer::composeGeneratesEpsilon ( out, grammar.getGeneratesEpsilon ( ) );
 
    out.emplace_back ( xmlTagName ( ), sax::Token::TokenType::END_ELEMENT );
}
 
template < class SymbolType >
void xmlApi < grammar::CSG < SymbolType > >::composeRules ( ext::deque < sax::Token > & out, const grammar::CSG < SymbolType > & 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::composeRuleLContext ( out, std::get < 0 > ( rule.first ) );
            grammar::GrammarToXMLComposer::composeRuleSingleSymbolLHS ( out, std::get < 1 > ( rule.first ) );
            grammar::GrammarToXMLComposer::composeRuleRContext ( out, std::get < 2 > ( rule.first ) );
            grammar::GrammarToXMLComposer::composeRuleRHS ( out, rhs );
 
            out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
        }
 
    out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
}
 
} /* namespace core */