patrick/plasp
Archived
1
0
Fork 0
Code Issues 12 Releases 8 Activity

Hiding implementation details in variant classes.

Browse Source
This commit is contained in:
Patrick Lühne 2017-05-17 20:09:07 +02:00
parent ff1d582605
commit 2042d6329d
Signed by: patrick
GPG Key ID: 05F3611E97A70ABF
1 changed files with 35 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
lib/pddlparse/include/pddlparse/ASTForward.h
View File

@ -85,32 +85,40 @@ using Requirements = std::vector<Requirement>;
// Variants // Variants
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
namespace detail
{
using TermT = Variant< using TermT = Variant<
Constant, Constant,
Variable>; Variable>;
}
class Term : public TermT class Term : public detail::TermT
{ {
using TermT::TermT; using detail::TermT::TermT;
}; };
using Terms = std::vector<Term>; using Terms = std::vector<Term>;
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
namespace detail
{
using AtomicFormulaT = Variant< using AtomicFormulaT = Variant<
Predicate, Predicate,
Unsupported>; Unsupported>;
}
class AtomicFormula : public AtomicFormulaT class AtomicFormula : public detail::AtomicFormulaT
{ {
using AtomicFormulaT::AtomicFormulaT; using detail::AtomicFormulaT::AtomicFormulaT;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class Precondition; class Precondition;
namespace detail
{
using PreconditionT = Variant< using PreconditionT = Variant<
AtomicFormula, AtomicFormula,
And<Precondition>, And<Precondition>,
@ -120,10 +128,11 @@ using PreconditionT = Variant<
Not<Precondition>, Not<Precondition>,
Or<Precondition>, Or<Precondition>,
Unsupported>; Unsupported>;
}
class Precondition : public PreconditionT class Precondition : public detail::PreconditionT
{ {
using PreconditionT::PreconditionT; using detail::PreconditionT::PreconditionT;
}; };
using Preconditions = std::vector<Precondition>; using Preconditions = std::vector<Precondition>;
@ -132,6 +141,8 @@ using Preconditions = std::vector<Precondition>;
class Effect; class Effect;
namespace detail
{
using EffectT = Variant< using EffectT = Variant<
AtomicFormula, AtomicFormula,
And<Effect>, And<Effect>,
@ -139,45 +150,55 @@ using EffectT = Variant<
Not<Effect>, Not<Effect>,
When<Precondition, Effect>, When<Precondition, Effect>,
Unsupported>; Unsupported>;
}
class Effect : public EffectT class Effect : public detail::EffectT
{ {
using EffectT::EffectT; using detail::EffectT::EffectT;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
namespace detail
{
using TypeT = Variant< using TypeT = Variant<
Either<PrimitiveType>, Either<PrimitiveType>,
PrimitiveType>; PrimitiveType>;
}
class Type : public TypeT class Type : public detail::TypeT
{ {
using TypeT::TypeT; using detail::TypeT::TypeT;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
namespace detail
{
using LiteralT = Variant< using LiteralT = Variant<
AtomicFormula, AtomicFormula,
Not<AtomicFormula>>; Not<AtomicFormula>>;
}
class Literal : public LiteralT class Literal : public detail::LiteralT
{ {
using LiteralT::LiteralT; using detail::LiteralT::LiteralT;
}; };
using Literals = std::vector<Literal>; using Literals = std::vector<Literal>;
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
namespace detail
{
using FactT = Variant< using FactT = Variant<
AtomicFormula, AtomicFormula,
At<Literal>>; At<Literal>>;
}
class Fact : public FactT class Fact : public detail::FactT
{ {
using FactT::FactT; using detail::FactT::FactT;
}; };
using Facts = std::vector<Fact>; using Facts = std::vector<Fact>;