# 2.2.10.2. rule/CompositionExpr.h¶

## 2.2.10.2.1. RCExp¶

In this namespace the data structures and operators for representing rule composition expressions are defined. An expression, RCExp, can be evaluated through the method Composer::eval. The result of an expression is a set of rules.

## 2.2.10.2.2. Class rule::RCExp::Union¶

class rule::RCExp::Union

Return the union of the subexpressions. I.e., flatten the subresult lists into a single list.

### 2.2.10.2.2.1. Synopsis¶

struct Union {
Union(std::vector<Expression> exps);
friend std::ostream &operator<<(std::ostream &s, const Union &par);
const std::vector<Expression> &getExpressions() const;
private:
std::vector<Expression> exps;
};


## 2.2.10.2.3. Class rule::RCExp::Bind¶

class rule::RCExp::Bind

Return the singleton list with the rule $$(\emptyset, \emptyset, G)$$ for the given graph $$G$$.

### 2.2.10.2.3.1. Synopsis¶

struct Bind {
Bind(std::shared_ptr<graph::Graph> g);
friend std::ostream &operator<<(std::ostream &s, const Bind &b);
std::shared_ptr<graph::Graph> getGraph() const;
private:
std::shared_ptr<graph::Graph> g;
};


## 2.2.10.2.4. Class rule::RCExp::Id¶

class rule::RCExp::Id

Return the singleton list with the rule $$(G, G, G)$$ for the given graph $$G$$.

### 2.2.10.2.4.1. Synopsis¶

struct Id {
Id(std::shared_ptr<graph::Graph> g);
friend std::ostream &operator<<(std::ostream &s, const Id &i);
std::shared_ptr<graph::Graph> getGraph() const;
private:
std::shared_ptr<graph::Graph> g;
};


## 2.2.10.2.5. Class rule::RCExp::Unbind¶

class rule::RCExp::Unbind

Return the singleton list with the rule $$(G, \emptyset, \emptyset)$$ for the given graph $$G$$.

### 2.2.10.2.5.1. Synopsis¶

struct Unbind {
Unbind(std::shared_ptr<graph::Graph> g);
friend std::ostream &operator<<(std::ostream &s, const Unbind &u);
std::shared_ptr<graph::Graph> getGraph() const;
private:
std::shared_ptr<graph::Graph> g;
};


## 2.2.10.2.6. Class rule::RCExp::Expression¶

class rule::RCExp::Expression

A generic rule composition expression.

### 2.2.10.2.6.1. Synopsis¶

struct Expression {
Expression(std::shared_ptr<Rule> r);
Expression(Union u);
Expression(Bind bind);
Expression(Id id);
Expression(Unbind unbind);
Expression(ComposeCommon compose);
Expression(ComposeParallel compose);
Expression(ComposeSub compose);
Expression(ComposeSuper compose);
template<typename Visitor>
typename Visitor::result_type applyVisitor(Visitor visitor) const {
return boost::apply_visitor(visitor, data);
}
friend std::ostream &operator<<(std::ostream &s, const Expression &exp);
private:
boost::variant<std::shared_ptr<Rule>, Union, Bind, Id, Unbind,
boost::recursive_wrapper<ComposeCommon>,
boost::recursive_wrapper<ComposeParallel>,
boost::recursive_wrapper<ComposeSub>,
boost::recursive_wrapper<ComposeSuper>
> data;
};


## 2.2.10.2.7. Class rule::RCExp::ComposeBase¶

class rule::RCExp::ComposeBase

The base class for the composition of two rule $$(L_1, K_1, R_1)$$ and $$(L_2, K_2, R_2)$$.

### 2.2.10.2.7.1. Synopsis¶

class ComposeBase {
protected:
ComposeBase(Expression first, Expression second, bool discardNonchemical);
public:
virtual ~ComposeBase();
friend std::ostream &operator<<(std::ostream &s, const ComposeBase &compose);
const Expression &getFirst() const;
const Expression &getSecond() const;
private:
virtual std::ostream &print(std::ostream &s) const = 0;
private:
Expression first, second;
};


## 2.2.10.2.8. Class rule::RCExp::ComposeCommon¶

class rule::RCExp::ComposeCommon

Compose the rules by all common subgraphs of $$R_1$$ and $$L_2$$, possibly limited to connected subgraphs or to the subgraphs of maximum size.

### 2.2.10.2.8.1. Synopsis¶

struct ComposeCommon : public ComposeBase {
ComposeCommon(Expression first, Expression second, bool discardNonchemical, bool maximum, bool connected);
bool getMaxmimum() const;
bool getConnected() const;
private:
std::ostream &print(std::ostream &s) const;
private:
bool maximum, connected;
};


## 2.2.10.2.9. Class rule::RCExp::ComposeParallel¶

class rule::RCExp::ComposeParallel

Compose the rules by the empty graph, i.e., create a rule representing the parallel application of two input rules.

### 2.2.10.2.9.1. Synopsis¶

struct ComposeParallel : public ComposeBase {
ComposeParallel(Expression first, Expression second, bool discardNonchemical);
private:
std::ostream &print(std::ostream &s) const;
};


## 2.2.10.2.10. Class rule::RCExp::ComposeSub¶

class rule::RCExp::ComposeSub

Compose the rules such that overlapping connected components of $$R_1$$ and $$L_2$$ have the $$L_2$$ component as a subgraph of $$R_1$$. The overlap is partial if not every connected component of $$L_2$$ is participating in the common subgraph.

### 2.2.10.2.10.1. Synopsis¶

struct ComposeSub : public ComposeBase {
ComposeSub(Expression first, Expression second, bool discardNonchemical, bool allowPartial);
bool getAllowPartial() const;
private:
std::ostream &print(std::ostream &s) const;
private:
bool allowPartial;
};


## 2.2.10.2.11. Class rule::RCExp::ComposeSuper¶

class rule::RCExp::ComposeSuper

Compose the rules such that overlapping connected components of $$R_1$$ and $$L_2$$ have the $$R_1$$ component as a subgraph of $$L_2$$. The overlap is partial if not every connected component of $$R_1$$ is participating in the common subgraph.

### 2.2.10.2.11.1. Synopsis¶

struct ComposeSuper : public ComposeBase {
ComposeSuper(Expression first, Expression second, bool discardNonchemical, bool allowPartial, bool enforceConstraints);
bool getAllowPartial() const;
bool getEnforceConstraints() const;
private:
std::ostream &print(std::ostream &s) const;
private:
bool allowPartial, enforceConstraints;
};