Skip to content
Snippets Groups Projects
Commit 506c86fe authored by Jan Trávníček's avatar Jan Trávníček
Browse files

continue with graphs

parent 71043489
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 429 additions and 379 deletions
alib2data/src/XmlApi.cpp
+ 0
− 39
View file @ 506c86fe
......@@ -33,12 +33,10 @@
namespace alib {
 
const regexp::RegExpFromXMLParser FromXMLParsers::regexpParser;
const graph::GraphFromXMLParser FromXMLParsers::graphParser;
const alib::ObjectFromXMLParser FromXMLParsers::objectParser;
const container::ContainerFromXMLParser FromXMLParsers::containerParser;
 
const regexp::RegExpToXMLComposer ToXMLComposers::regexpComposer;
const graph::GraphToXMLComposer ToXMLComposers::graphComposer;
const alib::ObjectToXMLComposer ToXMLComposers::objectComposer;
const container::ContainerToXMLComposer ToXMLComposers::containerComposer;
 
......@@ -117,43 +115,6 @@ void xmlApi<alib::Object>::compose(std::deque<sax::Token>& output, const alib::O
}
 
 
graph::Graph xmlApi<graph::Graph>::parse(std::deque<sax::Token>::iterator& input) {
return FromXMLParsers::graphParser.parseGraph(input);
}
bool xmlApi<graph::Graph>::first(const std::deque<sax::Token>::const_iterator& input) {
return FromXMLParsers::graphParser.first(input);
}
void xmlApi<graph::Graph>::compose(std::deque<sax::Token>& output, const graph::Graph& data) {
ToXMLComposers::graphComposer.compose(output, data);
}
graph::DirectedGraph xmlApi<graph::DirectedGraph>::parse(std::deque<sax::Token>::iterator& input) {
return FromXMLParsers::graphParser.parseDirectedGraph(input);
}
bool xmlApi<graph::DirectedGraph>::first(const std::deque<sax::Token>::const_iterator& input) {
return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAPH_DIRECTED_GRAPH);
}
void xmlApi<graph::DirectedGraph>::compose(std::deque<sax::Token>& output, const graph::DirectedGraph& data) {
ToXMLComposers::graphComposer.compose(output, data);
}
graph::UndirectedGraph xmlApi<graph::UndirectedGraph>::parse(std::deque<sax::Token>::iterator& input) {
return FromXMLParsers::graphParser.parseUndirectedGraph(input);
}
bool xmlApi<graph::UndirectedGraph>::first(const std::deque<sax::Token>::const_iterator& input) {
return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::GRAPH_UNDIRECTED_GRAPH);
}
void xmlApi<graph::UndirectedGraph>::compose(std::deque<sax::Token>& output, const graph::UndirectedGraph& data) {
ToXMLComposers::graphComposer.compose(output, data);
}
regexp::RegExp xmlApi<regexp::RegExp>::parse(std::deque<sax::Token>::iterator& input) {
return FromXMLParsers::regexpParser.parseRegExp(input);
}
......
alib2data/src/XmlApi.hpp
+ 0
− 26
View file @ 506c86fe
......@@ -20,12 +20,10 @@
#include "XmlTagNames.h"
 
#include "regexp/RegExpFromXMLParser.h"
#include "graph/GraphFromXMLParser.h"
#include "object/ObjectFromXMLParser.h"
#include "container/ContainerFromXMLParser.hpp"
 
#include "regexp/RegExpToXMLComposer.h"
#include "graph/GraphToXMLComposer.h"
#include "object/ObjectToXMLComposer.h"
#include "container/ContainerToXMLComposer.hpp"
 
......@@ -177,28 +175,6 @@ struct xmlApi<Object> {
};
 
 
template<>
struct xmlApi<graph::Graph> {
static graph::Graph parse(std::deque<sax::Token>::iterator& input);
static bool first(const std::deque<sax::Token>::const_iterator& input);
static void compose(std::deque<sax::Token>& output, const graph::Graph& data);
};
template<>
struct xmlApi<graph::DirectedGraph> {
static graph::DirectedGraph parse(std::deque<sax::Token>::iterator& input);
static bool first(const std::deque<sax::Token>::const_iterator& input);
static void compose(std::deque<sax::Token>& output, const graph::DirectedGraph& data);
};
template<>
struct xmlApi<graph::UndirectedGraph> {
static graph::UndirectedGraph parse(std::deque<sax::Token>::iterator& input);
static bool first(const std::deque<sax::Token>::const_iterator& input);
static void compose(std::deque<sax::Token>& output, const graph::UndirectedGraph& data);
};
template<>
struct xmlApi<regexp::RegExp> {
static regexp::RegExp parse(std::deque<sax::Token>::iterator& input);
......@@ -231,7 +207,6 @@ struct xmlApi<container::Container> {
class FromXMLParsers {
public:
static const regexp::RegExpFromXMLParser regexpParser;
static const graph::GraphFromXMLParser graphParser;
static const ObjectFromXMLParser objectParser;
static const container::ContainerFromXMLParser containerParser;
 
......@@ -332,7 +307,6 @@ private:
 
public:
static const regexp::RegExpToXMLComposer regexpComposer;
static const graph::GraphToXMLComposer graphComposer;
static const ObjectToXMLComposer objectComposer;
static const container::ContainerToXMLComposer containerComposer;
 
......
alib2data/src/graph/GraphBase.h
+ 3
− 0
View file @ 506c86fe
......@@ -10,6 +10,8 @@
 
#include "common/Macros.h"
#include "../object/ObjectBase.h"
#include <deque>
#include "../sax/Token.h"
 
namespace graph {
 
......@@ -43,6 +45,7 @@ public:
virtual GraphBase* clone() const = 0;
virtual GraphBase* plunder() && = 0;
 
virtual void compose(std::deque<sax::Token>& out) const = 0;
};
 
} // namespace graph
......
alib2data/src/graph/GraphFromXMLParser.cpp deleted 100644 → 0
+ 0
− 209
View file @ 71043489
/*
* GraphFeatures.h
*
* Created on: Jun 19, 2014
* Author: David Rosca
*/
#include "GraphFromXMLParser.h"
#include "../sax/ParserException.h"
#include "../XmlApi.hpp"
#include "Graph.h"
#include "GraphClasses.h"
namespace graph {
bool GraphFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const
{
if (alib::xmlApi<DirectedGraph>::first(input)) {
return true;
}
return false;
}
Graph GraphFromXMLParser::parseGraph(std::deque<sax::Token>::iterator& input) const
{
if (alib::xmlApi<DirectedGraph>::first(input)) {
return Graph(parseDirectedGraph(input));
} else if (alib::xmlApi<UndirectedGraph>::first(input)) {
return Graph(parseUndirectedGraph(input));
}
throw exception::AlibException();
}
DirectedGraph GraphFromXMLParser::parseDirectedGraph(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAPH_DIRECTED_GRAPH);
DirectedGraph graph(parseRepresentation(input));
parseNodes(input, graph);
parseDirectedEdges(input, graph);
parseNodeValues(input, graph);
parseDirectedEdgeValues(input, graph);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAPH_DIRECTED_GRAPH);
return graph;
}
UndirectedGraph GraphFromXMLParser::parseUndirectedGraph(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::GRAPH_UNDIRECTED_GRAPH);
UndirectedGraph graph(parseRepresentation(input));
parseNodes(input, graph);
parseUndirectedEdges(input, graph);
parseNodeValues(input, graph);
parseUndirectedEdgeValues(input, graph);
popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::GRAPH_UNDIRECTED_GRAPH);
return graph;
}
REPRESENTATION GraphFromXMLParser::parseRepresentation(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "representation");
REPRESENTATION r = representationFromString(popTokenData(input, sax::Token::TokenType::CHARACTER));
popToken(input, sax::Token::TokenType::END_ELEMENT, "representation");
return r;
}
Node GraphFromXMLParser::parseNode(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "node");
Node n = Node(alib::xmlApi<label::Label>::parse(input));
popToken(input, sax::Token::TokenType::END_ELEMENT, "node");
return n;
}
DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
popToken(input, sax::Token::TokenType::START_ELEMENT, "from");
Node from = parseNode(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "from");
label::Label name = alib::xmlApi<label::Label>::parse(input);
popToken(input, sax::Token::TokenType::START_ELEMENT, "to");
Node to = parseNode(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
return DirectedEdge(std::move(from), std::move(to), std::move(name));
}
UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
popToken(input, sax::Token::TokenType::START_ELEMENT, "first");
Node first = parseNode(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "first");
label::Label name = alib::xmlApi<label::Label>::parse(input);
popToken(input, sax::Token::TokenType::START_ELEMENT, "second");
Node second = parseNode(input);
popToken(input, sax::Token::TokenType::END_ELEMENT, "second");
popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
return UndirectedEdge(std::move(first), std::move(second), std::move(name));
}
int GraphFromXMLParser::parseValue(std::deque<sax::Token>::iterator& input) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "value");
int value = std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER));
popToken(input, sax::Token::TokenType::END_ELEMENT, "value");
return value;
}
template<typename T>
void GraphFromXMLParser::parseNodes(std::deque<sax::Token>::iterator& input, T &graph) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "nodes");
while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph.addNode(parseNode(input));
}
popToken(input, sax::Token::TokenType::END_ELEMENT, "nodes");
}
void GraphFromXMLParser::parseDirectedEdges(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph.addEdge(parseDirectedEdge(input));
}
popToken(input, sax::Token::TokenType::END_ELEMENT, "edges");
}
void GraphFromXMLParser::parseUndirectedEdges(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph.addEdge(parseUndirectedEdge(input));
}
popToken(input, sax::Token::TokenType::END_ELEMENT, "edges");
}
template<typename T>
void GraphFromXMLParser::parseNodeValues(std::deque<sax::Token>::iterator& input, T &graph) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "nodevalues");
while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph::Node node = parseNode(input);
int value = parseValue(input);
graph.setNodeValue(std::move(node), value);
}
popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues");
}
void GraphFromXMLParser::parseDirectedEdgeValues(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph::DirectedEdge edge = parseDirectedEdge(input);
int value = parseValue(input);
graph.setEdgeValue(std::move(edge), value);
}
popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
}
void GraphFromXMLParser::parseUndirectedEdgeValues(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const
{
popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph::UndirectedEdge edge = parseUndirectedEdge(input);
int value = parseValue(input);
graph.setEdgeValue(std::move(edge), value);
}
popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
}
} // namespace graph
alib2data/src/graph/GraphFromXMLParser.h deleted 100644 → 0
+ 0
− 51
View file @ 71043489
/*
* GraphFeatures.h
*
* Created on: Jun 19, 2014
* Author: David Rosca
*/
#ifndef GRAPH_FROM_XML_PARSER_H_
#define GRAPH_FROM_XML_PARSER_H_
#include "../sax/FromXMLParserHelper.h"
#include "GraphFeatures.h"
#include "../alphabet/SymbolFeatures.h"
#include "../XmlApiBase.h"
namespace graph {
// Parser used to get Graph from XML parsed into list of tokens.
class GraphFromXMLParser : public sax::FromXMLParserHelper
{
public:
GraphFromXMLParser() {}
bool first(const std::deque<sax::Token>::const_iterator& input) const;
private:
Graph parseGraph(std::deque<sax::Token>::iterator& input) const;
DirectedGraph parseDirectedGraph(std::deque<sax::Token>::iterator& input) const;
UndirectedGraph parseUndirectedGraph(std::deque<sax::Token>::iterator& input) const;
REPRESENTATION parseRepresentation(std::deque<sax::Token>::iterator& input) const;
Node parseNode(std::deque<sax::Token>::iterator& input) const;
DirectedEdge parseDirectedEdge(std::deque<sax::Token>::iterator& input) const;
UndirectedEdge parseUndirectedEdge(std::deque<sax::Token>::iterator& input) const;
int parseValue(std::deque<sax::Token>::iterator& input) const;
template<typename T>
void parseNodes(std::deque<sax::Token>::iterator& input, T &graph) const;
void parseDirectedEdges(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const;
void parseUndirectedEdges(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const;
template<typename T>
void parseNodeValues(std::deque<sax::Token>::iterator& input, T &graph) const;
void parseDirectedEdgeValues(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) const;
void parseUndirectedEdgeValues(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) const;
template<typename T, typename Enable> friend struct alib::xmlApi;
};
} // namespace graph
#endif // GRAPH_FROM_XML_PARSER_H_
alib2data/src/graph/GraphToXMLComposer.h deleted 100644 → 0
+ 0
− 52
View file @ 71043489
/*
* GraphFeatures.h
*
* Created on: Jun 19, 2014
* Author: David Rosca
*/
#ifndef GRAPH_TO_XML_COMPOSER_H_
#define GRAPH_TO_XML_COMPOSER_H_
#include <set>
#include <deque>
#include "GraphFeatures.h"
#include "../sax/Token.h"
#include "../XmlApiBase.h"
namespace graph {
// This class contains methods to print XML representation of graph to the output stream.
class GraphToXMLComposer
{
public:
GraphToXMLComposer() {}
private:
void composeNode(std::deque<sax::Token>& out, const Node &node) const;
void composeEdge(std::deque<sax::Token>& out, const DirectedEdge &edge) const;
void composeEdge(std::deque<sax::Token>& out, const UndirectedEdge &edge) const;
void compose(std::deque<sax::Token> &out, const GraphBase &graph) const;
void compose(std::deque<sax::Token> &out, const Graph &graph) const;
void compose(std::deque<sax::Token> &out, const DirectedGraph &graph) const;
void compose(std::deque<sax::Token> &out, const UndirectedGraph &graph) const;
void composeRepresentation(std::deque<sax::Token> &out, const std::string &representation) const;
void composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes) const;
template<typename T>
void composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges) const;
template<typename T>
void composeNodeValues(std::deque<sax::Token> &out, const T &graph) const;
template<typename T>
void composeEdgeValues(std::deque<sax::Token> &out, const T &graph) const;
template<typename T, typename Enable> friend struct alib::xmlApi;
};
} // namespace graph
#endif // GRAPH_TO_XML_COMPOSER_H_
alib2data/src/graph/common/GraphFromXMLParser.cpp 0 → 100644
+ 125
− 0
View file @ 506c86fe
/*
* GraphFeatures.h
*
* Created on: Jun 19, 2014
* Author: David Rosca
*/
#include "GraphFromXMLParser.h"
#include "../../sax/ParserException.h"
#include "../../XmlApi.hpp"
#include "../Graph.h"
#include "../GraphClasses.h"
namespace graph {
REPRESENTATION GraphFromXMLParser::parseRepresentation(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "representation");
REPRESENTATION r = representationFromString(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER));
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "representation");
return r;
}
Node GraphFromXMLParser::parseNode(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "node");
Node n = Node(alib::xmlApi<label::Label>::parse(input));
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "node");
return n;
}
DirectedEdge GraphFromXMLParser::parseDirectedEdge(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "from");
Node from = parseNode(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "from");
label::Label name = alib::xmlApi<label::Label>::parse(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "to");
Node to = parseNode(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
return DirectedEdge(std::move(from), std::move(to), std::move(name));
}
UndirectedEdge GraphFromXMLParser::parseUndirectedEdge(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "edge");
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "first");
Node first = parseNode(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "first");
label::Label name = alib::xmlApi<label::Label>::parse(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "second");
Node second = parseNode(input);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "second");
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "edge");
return UndirectedEdge(std::move(first), std::move(second), std::move(name));
}
int GraphFromXMLParser::parseValue(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "value");
int value = std::stoi(sax::FromXMLParserHelper::popTokenData(input, sax::Token::TokenType::CHARACTER));
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "value");
return value;
}
void GraphFromXMLParser::parseDirectedEdges(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph.addEdge(parseDirectedEdge(input));
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "edges");
}
void GraphFromXMLParser::parseUndirectedEdges(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "edges");
while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph.addEdge(parseUndirectedEdge(input));
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "edges");
}
void GraphFromXMLParser::parseDirectedEdgeValues(std::deque<sax::Token>::iterator& input, DirectedGraph &graph) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph::DirectedEdge edge = parseDirectedEdge(input);
int value = parseValue(input);
graph.setEdgeValue(std::move(edge), value);
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
}
void GraphFromXMLParser::parseUndirectedEdgeValues(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "edgevalues");
while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph::UndirectedEdge edge = parseUndirectedEdge(input);
int value = parseValue(input);
graph.setEdgeValue(std::move(edge), value);
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "edgevalues");
}
} // namespace graph
alib2data/src/graph/common/GraphFromXMLParser.h 0 → 100644
+ 66
− 0
View file @ 506c86fe
/*
* GraphFeatures.h
*
* Created on: Jun 19, 2014
* Author: David Rosca
*/
#ifndef GRAPH_FROM_XML_PARSER_H_
#define GRAPH_FROM_XML_PARSER_H_
#include "../../sax/FromXMLParserHelper.h"
#include "../GraphFeatures.h"
#include "../../alphabet/SymbolFeatures.h"
#include "../../XmlApiBase.h"
#include "Node.h"
namespace graph {
// Parser used to get Graph from XML parsed into list of tokens.
class GraphFromXMLParser {
public:
static REPRESENTATION parseRepresentation(std::deque<sax::Token>::iterator& input);
static Node parseNode(std::deque<sax::Token>::iterator& input);
static DirectedEdge parseDirectedEdge(std::deque<sax::Token>::iterator& input);
static UndirectedEdge parseUndirectedEdge(std::deque<sax::Token>::iterator& input);
static int parseValue(std::deque<sax::Token>::iterator& input);
template<typename T>
static void parseNodes(std::deque<sax::Token>::iterator& input, T &graph);
static void parseDirectedEdges(std::deque<sax::Token>::iterator& input, DirectedGraph &graph);
static void parseUndirectedEdges(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph);
template<typename T>
static void parseNodeValues(std::deque<sax::Token>::iterator& input, T &graph);
static void parseDirectedEdgeValues(std::deque<sax::Token>::iterator& input, DirectedGraph &graph);
static void parseUndirectedEdgeValues(std::deque<sax::Token>::iterator& input, UndirectedGraph &graph);
};
template<typename T>
void GraphFromXMLParser::parseNodes(std::deque<sax::Token>::iterator& input, T &graph) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "nodes");
while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph.addNode(parseNode(input));
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "nodes");
}
template<typename T>
void GraphFromXMLParser::parseNodeValues(std::deque<sax::Token>::iterator& input, T &graph) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "nodevalues");
while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
graph::Node node = parseNode(input);
int value = parseValue(input);
graph.setNodeValue(std::move(node), value);
}
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "nodevalues");
}
} // namespace graph
#endif // GRAPH_FROM_XML_PARSER_H_
alib2data/src/graph/GraphToXMLComposer.cpp → alib2data/src/graph/common/GraphToXMLComposer.cpp
+ 69
− 0
View file @ 506c86fe
......@@ -6,23 +6,21 @@
*/
 
#include "GraphToXMLComposer.h"
#include "../XmlApi.hpp"
#include "../../XmlApi.hpp"
 
#include "GraphRepresentation.h"
#include "Graph.h"
#include "GraphClasses.h"
#include "../GraphRepresentation.h"
#include "../Graph.h"
#include "../GraphClasses.h"
 
namespace graph {
 
void GraphToXMLComposer::composeNode(std::deque<sax::Token>& out, const Node &node) const
{
void GraphToXMLComposer::composeNode(std::deque<sax::Token>& out, const Node &node) {
out.emplace_back("node", sax::Token::TokenType::START_ELEMENT);
alib::xmlApi<label::Label>::compose(out, node.getName());
out.emplace_back("node", sax::Token::TokenType::END_ELEMENT);
}
 
void GraphToXMLComposer::composeEdge(std::deque<sax::Token>& out, const DirectedEdge &edge) const
{
void GraphToXMLComposer::composeEdge(std::deque<sax::Token>& out, const DirectedEdge &edge) {
out.emplace_back("edge", sax::Token::TokenType::START_ELEMENT);
 
out.emplace_back("from", sax::Token::TokenType::START_ELEMENT);
......@@ -38,8 +36,7 @@ void GraphToXMLComposer::composeEdge(std::deque<sax::Token>& out, const Directed
out.emplace_back("edge", sax::Token::TokenType::END_ELEMENT);
}
 
void GraphToXMLComposer::composeEdge(std::deque<sax::Token>& out, const UndirectedEdge &edge) const
{
void GraphToXMLComposer::composeEdge(std::deque<sax::Token>& out, const UndirectedEdge &edge) {
out.emplace_back("edge", sax::Token::TokenType::START_ELEMENT);
 
out.emplace_back("first", sax::Token::TokenType::START_ELEMENT);
......@@ -55,51 +52,13 @@ void GraphToXMLComposer::composeEdge(std::deque<sax::Token>& out, const Undirect
out.emplace_back("edge", sax::Token::TokenType::END_ELEMENT);
}
 
void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const GraphBase &graph) const
{
graph.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
}
void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const Graph &graph) const
{
graph.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
}
void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const DirectedGraph &graph) const
{
out.emplace_back(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT);
composeRepresentation(out, representationToString(graph.getRepresentation()));
composeNodes(out, graph.getNodes());
composeEdges(out, graph.getEdges());
composeNodeValues(out, graph);
composeEdgeValues(out, graph);
out.emplace_back(alib::Names::GRAPH_DIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT);
}
void GraphToXMLComposer::compose(std::deque<sax::Token> &out, const UndirectedGraph &graph) const
{
out.emplace_back(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::START_ELEMENT);
composeRepresentation(out, representationToString(graph.getRepresentation()));
composeNodes(out, graph.getNodes());
composeEdges(out, graph.getEdges());
composeNodeValues(out, graph);
composeEdgeValues(out, graph);
out.emplace_back(alib::Names::GRAPH_UNDIRECTED_GRAPH, sax::Token::TokenType::END_ELEMENT);
}
void GraphToXMLComposer::composeRepresentation(std::deque<sax::Token> &out, const std::string &representation) const
{
void GraphToXMLComposer::composeRepresentation(std::deque<sax::Token> &out, const std::string &representation) {
out.emplace_back("representation", sax::Token::TokenType::START_ELEMENT);
out.emplace_back(representation, sax::Token::TokenType::CHARACTER);
out.emplace_back("representation", sax::Token::TokenType::END_ELEMENT);
}
 
void GraphToXMLComposer::composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes) const
{
void GraphToXMLComposer::composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes) {
out.emplace_back("nodes", sax::Token::TokenType::START_ELEMENT);
for (const Node &node : nodes) {
composeNode(out, node);
......@@ -107,40 +66,4 @@ void GraphToXMLComposer::composeNodes(std::deque<sax::Token> &out, const std::se
out.emplace_back("nodes", sax::Token::TokenType::END_ELEMENT);
}
 
template<typename T>
void GraphToXMLComposer::composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges) const
{
out.emplace_back("edges", sax::Token::TokenType::START_ELEMENT);
for (const auto &edge : edges) {
composeEdge(out, edge);
}
out.emplace_back("edges", sax::Token::TokenType::END_ELEMENT);
}
template<typename T>
void GraphToXMLComposer::composeNodeValues(std::deque<sax::Token> &out, const T &graph) const
{
out.emplace_back("nodevalues", sax::Token::TokenType::START_ELEMENT);
for (auto i : graph.nodeValues) {
composeNode(out, i.first);
out.emplace_back("value", sax::Token::TokenType::START_ELEMENT);
out.emplace_back(std::itos(i.second), sax::Token::TokenType::CHARACTER);
out.emplace_back("value", sax::Token::TokenType::END_ELEMENT);
}
out.emplace_back("nodevalues", sax::Token::TokenType::END_ELEMENT);
}
template<typename T>
void GraphToXMLComposer::composeEdgeValues(std::deque<sax::Token> &out, const T &graph) const
{
out.emplace_back("edgevalues", sax::Token::TokenType::START_ELEMENT);
for (auto &i : graph.edgeValues) {
composeEdge(out, i.first);
out.emplace_back("value", sax::Token::TokenType::START_ELEMENT);
out.emplace_back(std::itos(i.second), sax::Token::TokenType::CHARACTER);
out.emplace_back("value", sax::Token::TokenType::END_ELEMENT);
}
out.emplace_back("edgevalues", sax::Token::TokenType::END_ELEMENT);
}
} // namespace graph
alib2data/src/graph/common/GraphToXMLComposer.h 0 → 100644
+ 75
− 0
View file @ 506c86fe
/*
* GraphFeatures.h
*
* Created on: Jun 19, 2014
* Author: David Rosca
*/
#ifndef GRAPH_TO_XML_COMPOSER_H_
#define GRAPH_TO_XML_COMPOSER_H_
#include <set>
#include <deque>
#include "../GraphFeatures.h"
#include "../../sax/Token.h"
#include "../../XmlApiBase.h"
namespace graph {
// This class contains methods to print XML representation of graph to the output stream.
class GraphToXMLComposer
{
public:
static void composeNode(std::deque<sax::Token>& out, const Node &node);
static void composeEdge(std::deque<sax::Token>& out, const DirectedEdge &edge);
static void composeEdge(std::deque<sax::Token>& out, const UndirectedEdge &edge);
static void composeRepresentation(std::deque<sax::Token> &out, const std::string &representation);
static void composeNodes(std::deque<sax::Token> &out, const std::set<Node> &nodes);
template<typename T>
static void composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges);
template<typename T>
static void composeNodeValues(std::deque<sax::Token> &out, const T &graph);
template<typename T>
static void composeEdgeValues(std::deque<sax::Token> &out, const T &graph);
};
template<typename T>
void GraphToXMLComposer::composeEdges(std::deque<sax::Token> &out, const std::set<T> &edges) {
out.emplace_back("edges", sax::Token::TokenType::START_ELEMENT);
for (const auto &edge : edges) {
composeEdge(out, edge);
}
out.emplace_back("edges", sax::Token::TokenType::END_ELEMENT);
}
template<typename T>
void GraphToXMLComposer::composeNodeValues(std::deque<sax::Token> &out, const T &graph) {
out.emplace_back("nodevalues", sax::Token::TokenType::START_ELEMENT);
for (auto i : graph.nodeValues) {
composeNode(out, i.first);
out.emplace_back("value", sax::Token::TokenType::START_ELEMENT);
out.emplace_back(std::itos(i.second), sax::Token::TokenType::CHARACTER);
out.emplace_back("value", sax::Token::TokenType::END_ELEMENT);
}
out.emplace_back("nodevalues", sax::Token::TokenType::END_ELEMENT);
}
template<typename T>
void GraphToXMLComposer::composeEdgeValues(std::deque<sax::Token> &out, const T &graph) {
out.emplace_back("edgevalues", sax::Token::TokenType::START_ELEMENT);
for (auto &i : graph.edgeValues) {
composeEdge(out, i.first);
out.emplace_back("value", sax::Token::TokenType::START_ELEMENT);
out.emplace_back(std::itos(i.second), sax::Token::TokenType::CHARACTER);
out.emplace_back("value", sax::Token::TokenType::END_ELEMENT);
}
out.emplace_back("edgevalues", sax::Token::TokenType::END_ELEMENT);
}
} // namespace graph
#endif // GRAPH_TO_XML_COMPOSER_H_
alib2data/src/graph/directed/DirectedGraph.cpp
+ 40
− 1
View file @ 506c86fe
......@@ -14,6 +14,12 @@
#include <algorithm>
#include <sstream>
 
#include "../../sax/FromXMLParserHelper.h"
#include "../common/GraphFromXMLParser.h"
#include "../common/GraphToXMLComposer.h"
#include "../Graph.h"
#include "../../XmlApi.hpp"
namespace graph {
 
DirectedGraph::DirectedGraph(REPRESENTATION representation)
......@@ -234,4 +240,37 @@ void DirectedGraph::init()
}
}
 
} // namespace graph
const std::string DirectedGraph::XML_TAG_NAME = "DirectedGraph";
DirectedGraph DirectedGraph::parse(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, DirectedGraph::XML_TAG_NAME);
DirectedGraph graph(GraphFromXMLParser::parseRepresentation(input));
GraphFromXMLParser::parseNodes(input, graph);
GraphFromXMLParser::parseDirectedEdges(input, graph);
GraphFromXMLParser::parseNodeValues(input, graph);
GraphFromXMLParser::parseDirectedEdgeValues(input, graph);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, DirectedGraph::XML_TAG_NAME);
return graph;
}
void DirectedGraph::compose(std::deque<sax::Token>& out) const {
out.emplace_back(DirectedGraph::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
GraphToXMLComposer::composeRepresentation(out, representationToString(this->getRepresentation()));
GraphToXMLComposer::composeNodes(out, this->getNodes());
GraphToXMLComposer::composeEdges(out, this->getEdges());
GraphToXMLComposer::composeNodeValues(out, *this);
GraphToXMLComposer::composeEdgeValues(out, *this);
out.emplace_back(DirectedGraph::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
}
} /* namespace graph */
namespace alib {
xmlApi<graph::Graph>::ParserRegister<graph::DirectedGraph> directedGraphParserRegister = xmlApi<graph::Graph>::ParserRegister<graph::DirectedGraph>(graph::DirectedGraph::XML_TAG_NAME, graph::DirectedGraph::parse);
} /* namespace alib */
alib2data/src/graph/directed/DirectedGraph.h
+ 6
− 0
View file @ 506c86fe
......@@ -79,6 +79,12 @@ public:
return typeId(*this);
}
 
const static std::string XML_TAG_NAME;
static DirectedGraph parse(std::deque<sax::Token>::iterator& input);
void compose(std::deque<sax::Token>& out) const;
private:
void init();
 
......
alib2data/src/graph/undirected/UndirectedGraph.cpp
+ 39
− 1
View file @ 506c86fe
......@@ -14,6 +14,12 @@
#include <algorithm>
#include <sstream>
 
#include "../../sax/FromXMLParserHelper.h"
#include "../common/GraphFromXMLParser.h"
#include "../common/GraphToXMLComposer.h"
#include "../Graph.h"
#include "../../XmlApi.hpp"
namespace graph {
 
UndirectedGraph::UndirectedGraph(REPRESENTATION representation)
......@@ -234,5 +240,37 @@ void UndirectedGraph::init()
}
}
 
} // namespace graph
const std::string UndirectedGraph::XML_TAG_NAME = "UndirectedGraph";
UndirectedGraph UndirectedGraph::parse(std::deque<sax::Token>::iterator& input) {
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, UndirectedGraph::XML_TAG_NAME);
UndirectedGraph graph(GraphFromXMLParser::parseRepresentation(input));
GraphFromXMLParser::parseNodes(input, graph);
GraphFromXMLParser::parseUndirectedEdges(input, graph);
GraphFromXMLParser::parseNodeValues(input, graph);
GraphFromXMLParser::parseUndirectedEdgeValues(input, graph);
sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, UndirectedGraph::XML_TAG_NAME);
return graph;
}
void UndirectedGraph::compose(std::deque<sax::Token>& out) const {
out.emplace_back(UndirectedGraph::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
GraphToXMLComposer::composeRepresentation(out, representationToString(this->getRepresentation()));
GraphToXMLComposer::composeNodes(out, this->getNodes());
GraphToXMLComposer::composeEdges(out, this->getEdges());
GraphToXMLComposer::composeNodeValues(out, *this);
GraphToXMLComposer::composeEdgeValues(out, *this);
out.emplace_back(UndirectedGraph::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
}
} /* namespace graph */
namespace alib {
xmlApi<graph::Graph>::ParserRegister<graph::UndirectedGraph> undirectedGraphParserRegister = xmlApi<graph::Graph>::ParserRegister<graph::UndirectedGraph>(graph::UndirectedGraph::XML_TAG_NAME, graph::UndirectedGraph::parse);
 
} /* namespace alib */
alib2data/src/graph/undirected/UndirectedGraph.h
+ 6
− 0
View file @ 506c86fe
......@@ -79,6 +79,12 @@ public:
return typeId(*this);
}
 
const static std::string XML_TAG_NAME;
static UndirectedGraph parse(std::deque<sax::Token>::iterator& input);
void compose(std::deque<sax::Token>& out) const;
private:
void init();
 
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment