knowrob::GraphRestructuring Class Reference

#include <GraphRestructuring.h>

Inheritance diagram for knowrob::GraphRestructuring:

Collaboration diagram for knowrob::GraphRestructuring:

Public Member Functions
	GraphRestructuring ()
void	addRule (std::shared_ptr< GraphTransformationRule > rule)
bool	configure (const boost::property_tree::ptree &opts) override
	GraphRestructuring ()
void	addRule (std::shared_ptr< GraphTransformationRule > rule)
bool	configure (const boost::property_tree::ptree &opts) override
Public Member Functions inherited from knowrob::GraphTransformation
	GraphTransformation ()=default
virtual	~GraphTransformation ()=default
void	setOrigin (std::string_view origin)
auto	origin () const
void	apply (OntologySource &ontologySource, const TripleHandler &callback)
	GraphTransformation ()=default
virtual	~GraphTransformation ()=default
void	setOrigin (std::string_view origin)
auto	origin () const
void	apply (OntologySource &ontologySource, const TripleHandler &callback)

Protected Member Functions
void	doTransformation (GraphTransformationRule &rule)
bool	readFromFile (const std::string &filename)
void	initializeTransformation () override
void	finalizeTransformation () override
void	pushInputTriples (const TripleContainerPtr &triples) override
void	doTransformation (GraphTransformationRule &rule)
bool	readFromFile (const std::string &filename)
void	initializeTransformation () override
void	finalizeTransformation () override
void	pushInputTriples (const TripleContainerPtr &triples) override
Protected Member Functions inherited from knowrob::GraphTransformation
void	initializeNext ()
void	finalizeNext ()
void	setNext (const std::shared_ptr< GraphTransformation > &next)
void	setNext (const TripleHandler &next)
void	pushOutputTriples (const TripleContainerPtr &triples)
void	initializeNext ()
void	finalizeNext ()
void	setNext (const std::shared_ptr< GraphTransformation > &next)
void	setNext (const TripleHandler &next)
void	pushOutputTriples (const TripleContainerPtr &triples)

Static Protected Member Functions
static TriplePatternPtr	readTriplePattern (const std::string &filename)
static TriplePatternPtr	readTriplePattern (const std::string &filename)

Protected Attributes
std::unique_ptr< RedlandModel >	model_
std::vector< std::shared_ptr< GraphTransformationRule > >	rules_
Protected Attributes inherited from knowrob::GraphTransformation
TripleHandler	next_
std::shared_ptr< GraphTransformation >	nextTransformation_
std::string	origin_

Additional Inherited Members
Static Public Member Functions inherited from knowrob::GraphTransformation
static std::shared_ptr< GraphTransformation >	create (const boost::property_tree::ptree &config)
static std::shared_ptr< GraphTransformation >	create (const boost::property_tree::ptree &config)

Detailed Description

A graph transformation that restructures and possibly renames entities in the input graph.

Definition at line 19 of file GraphRestructuring.h.

Constructor & Destructor Documentation

GraphRestructuring() [1/2]

GraphRestructuring::GraphRestructuring

(

)

Definition at line 15 of file GraphRestructuring.cpp.

        : GraphTransformation(),
          model_(nullptr) {
}

GraphRestructuring() [2/2]

knowrob::GraphRestructuring::GraphRestructuring

(

)

Member Function Documentation

addRule() [1/2]

void GraphRestructuring::addRule

(

std::shared_ptr< GraphTransformationRule >

rule

)

Adds a rule to this transformation.

Parameters

rule

a rule.

Definition at line 20 of file GraphRestructuring.cpp.

                                                                            {
    rules_.push_back(std::move(rule));
}

addRule() [2/2]

void knowrob::GraphRestructuring::addRule

(

std::shared_ptr< GraphTransformationRule >

rule

)

Adds a rule to this transformation.

Parameters

rule

a rule.

configure() [1/2]

bool GraphRestructuring::configure ( const boost::property_tree::ptree &  config )

overridevirtual

Configure the transformation with the given options.

Parameters

config

the options

Returns

true if the configuration was successful

Implements knowrob::GraphTransformation.

Definition at line 24 of file GraphRestructuring.cpp.

                                                                      {
    auto o_user = opts.get_optional<std::string>(GRAPH_RESTRUCTURING_SETTING_FILE);
    bool status = true;
    if (o_user) {
        try {
            status = readFromFile(*o_user);
        } catch (const std::exception &e) {
            KB_WARN("Error reading renaming from file {}: {}", *o_user, e.what());
            status = false;
        }
    }
    return status;
}

configure() [2/2]

bool knowrob::GraphRestructuring::configure ( const boost::property_tree::ptree &  config )

overridevirtual

Configure the transformation with the given options.

Parameters

config

the options

Returns

true if the configuration was successful

Implements knowrob::GraphTransformation.

doTransformation() [1/2]

void GraphRestructuring::doTransformation ( GraphTransformationRule &  rule )

protected

Definition at line 129 of file GraphRestructuring.cpp.

                                                                       {
    // collect matching originals, and apply the transformation by finding and applying
    // a substitution mapping to the pattern predicates.
    auto originals = std::make_shared<TriplePatternContainer>();
    auto transformed = std::make_shared<TriplePatternContainer>();
    // perform query and record transformations
    model_->query(rule.getSPARQLQuery(), [&](const BindingsPtr &bindings) {
        // apply the substitution mapping to the pattern term
        for (auto &p: rule.to()) {
            auto x = applyBindings(p, *bindings);
            x->setGraphName(origin_);
            transformed->push_back(x);
        }
        // apply the substitution mapping to the query term
        for (auto &p: rule.from()) {
            originals->push_back(applyBindings(p, *bindings));
        }
    });
    // update the model
    model_->removeAll(originals);
    model_->insertAll(transformed);
}

doTransformation() [2/2]

void knowrob::GraphRestructuring::doTransformation ( GraphTransformationRule &  rule )

protected

finalizeTransformation() [1/2]

void GraphRestructuring::finalizeTransformation ( )

overrideprotectedvirtual

Finalize the transformation.

Implements knowrob::GraphTransformation.

Definition at line 111 of file GraphRestructuring.cpp.

                                                {
    // do the transformation after last triple has been received
    for (auto &rule: rules_) {
        doTransformation(*rule);
    }
    // push into next stage
    initializeNext();
    model_->batch([this](const TripleContainerPtr &triples) {
        pushOutputTriples(triples);
    });
    finalizeNext();
    model_ = nullptr;
}

finalizeTransformation() [2/2]

void knowrob::GraphRestructuring::finalizeTransformation ( )

overrideprotectedvirtual

Finalize the transformation.

Implements knowrob::GraphTransformation.

initializeTransformation() [1/2]

void GraphRestructuring::initializeTransformation ( )

overrideprotectedvirtual

Initialize the transformation.

Implements knowrob::GraphTransformation.

Definition at line 105 of file GraphRestructuring.cpp.

                                                  {
    model_ = std::make_unique<RedlandModel>();
    model_->setStorageType(RedlandStorageType::MEMORY);
    model_->setOrigin(origin_);
}

initializeTransformation() [2/2]

void knowrob::GraphRestructuring::initializeTransformation ( )

overrideprotectedvirtual

Initialize the transformation.

Implements knowrob::GraphTransformation.

pushInputTriples() [1/2]

void GraphRestructuring::pushInputTriples ( const TripleContainerPtr &  triples )

overrideprotectedvirtual

Push input triples to the transformation.

Parameters

triples

the input triples

Implements knowrob::GraphTransformation.

Definition at line 125 of file GraphRestructuring.cpp.

                                                                           {
    model_->insertAll(triples);
}

pushInputTriples() [2/2]

void knowrob::GraphRestructuring::pushInputTriples ( const TripleContainerPtr &  triples )

overrideprotectedvirtual

Push input triples to the transformation.

Parameters

triples

the input triples

Implements knowrob::GraphTransformation.

readFromFile() [1/2]

bool GraphRestructuring::readFromFile ( const std::string &  filename )

protected

Definition at line 38 of file GraphRestructuring.cpp.

                                                               {
    std::ifstream file(filename);
    std::string line, entry;
 
    while (std::getline(file, line, '.')) {
        entry += line;
        if (file.peek() != '\n') continue;
 
        file.ignore();
        std::stringstream ss(entry);
        std::string part1, part2;
 
        // split the entry into two parts at the '<-' separator
        std::getline(ss, part1, '<');
        ss.ignore(2); // ignore the '-' and ' '
        std::getline(ss, part2);
        if (part1.size() < 5 || part2.size() < 5) {
            KB_WARN("Error reading transformation from file {}: Invalid Syntax.", filename);
            return false;
        }
 
        // remove the brackets
        part1 = part1.substr(1, part1.size() - 2);
        part2 = part2.substr(1, part2.size() - 2);
 
        std::vector<TriplePatternPtr> x, y;
        std::stringstream ss1(part1), ss2(part2);
        std::string item;
 
        while (std::getline(ss1, item, ',')) {
            auto pat = readTriplePattern(item);
            if (pat) {
                x.push_back(pat);
            } else {
                KB_WARN("Error reading transformation from file {}: Invalid triple pattern \"{}\".", filename, item);
                return false;
            }
        }
        while (std::getline(ss2, item, ',')) {
            auto pat = readTriplePattern(item);
            if (pat) {
                y.push_back(pat);
            } else {
                KB_WARN("Error reading transformation from file {}: Invalid triple pattern \"{}\".", filename, item);
                return false;
            }
        }
        addRule(std::make_shared<GraphTransformationRule>(x, y));
 
        entry.clear();
    }
 
    return true;
}

readFromFile() [2/2]

bool knowrob::GraphRestructuring::readFromFile ( const std::string &  filename )

protected

readTriplePattern() [1/2]

TriplePatternPtr GraphRestructuring::readTriplePattern ( const std::string &  filename )

staticprotected

Definition at line 93 of file GraphRestructuring.cpp.

                                                                                  {
    auto p = QueryParser::parsePredicate(stringForm);
    if (!p) return nullptr;
    try {
        auto p_rdf = TriplePattern::getRDFPredicate(p);
        return std::make_shared<TriplePattern>(p_rdf);
    } catch (const std::exception &e) {
        KB_WARN("Error reading transformation from file: {}", e.what());
        return nullptr;
    }
}

readTriplePattern() [2/2]

static TriplePatternPtr knowrob::GraphRestructuring::readTriplePattern ( const std::string &  filename )

staticprotected

Member Data Documentation

model_

std::unique_ptr< RedlandModel > knowrob::GraphRestructuring::model_

protected

Definition at line 33 of file GraphRestructuring.h.

rules_

std::vector< std::shared_ptr< GraphTransformationRule > > knowrob::GraphRestructuring::rules_

protected

Definition at line 34 of file GraphRestructuring.h.

---

The documentation for this class was generated from the following files:

• build/_CPack_Packages/Linux/DEB/knowrob-2.1.0-Linux/usr/include/knowrob/semweb/GraphRestructuring.h
• src/semweb/GraphRestructuring.cpp