Started implementing PDDL type parsing.
This commit is contained in:
parent
1c4c035acc
commit
a989f5f86e
|
|
@ -0,0 +1,57 @@
|
|||
#ifndef __PLASP__PDDL__CONSISTENCY_EXCEPTION_H
|
||||
#define __PLASP__PDDL__CONSISTENCY_EXCEPTION_H
|
||||
|
||||
#include <exception>
|
||||
#include <string>
|
||||
|
||||
namespace plasp
|
||||
{
|
||||
namespace pddl
|
||||
{
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// ConsistencyException
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class ConsistencyException: public std::exception
|
||||
{
|
||||
public:
|
||||
explicit ConsistencyException()
|
||||
: ConsistencyException("Unspecified consistency error")
|
||||
{
|
||||
}
|
||||
|
||||
explicit ConsistencyException(const char *message)
|
||||
: ConsistencyException(static_cast<std::string>(message))
|
||||
{
|
||||
}
|
||||
|
||||
explicit ConsistencyException(const std::string &message)
|
||||
: m_message{message}
|
||||
{
|
||||
}
|
||||
|
||||
~ConsistencyException() throw()
|
||||
{
|
||||
}
|
||||
|
||||
const char *what() const throw()
|
||||
{
|
||||
if (m_message.empty())
|
||||
return "Unspecified consistency error";
|
||||
|
||||
return m_message.c_str();
|
||||
}
|
||||
|
||||
private:
|
||||
std::string m_message;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,7 +1,10 @@
|
|||
#ifndef __PLASP__PDDL__DOMAIN_H
|
||||
#define __PLASP__PDDL__DOMAIN_H
|
||||
|
||||
#include <unordered_map>
|
||||
|
||||
#include <plasp/pddl/Requirement.h>
|
||||
#include <plasp/pddl/Type.h>
|
||||
#include <plasp/utils/Parser.h>
|
||||
|
||||
namespace plasp
|
||||
|
|
@ -20,9 +23,12 @@ class Domain
|
|||
public:
|
||||
static Domain fromPDDL(utils::Parser &parser);
|
||||
|
||||
using TypesHashMap = std::unordered_map<std::string, Type>;
|
||||
|
||||
public:
|
||||
const std::string &name() const;
|
||||
const Requirement::Types &requirements() const;
|
||||
const TypesHashMap &types() const;
|
||||
|
||||
private:
|
||||
Domain() = default;
|
||||
|
|
@ -30,10 +36,16 @@ class Domain
|
|||
void parseSection(utils::Parser &parser);
|
||||
|
||||
void parseRequirementsSection(utils::Parser &parser);
|
||||
bool hasRequirement(Requirement::Type requirement) const;
|
||||
void computeDerivedRequirements();
|
||||
|
||||
void parseTypingSection(utils::Parser &parser);
|
||||
|
||||
void checkConsistency();
|
||||
|
||||
std::string m_name;
|
||||
Requirement::Types m_requirements;
|
||||
TypesHashMap m_types;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef __PLASP__PDDL__TYPE_H
|
||||
#define __PLASP__PDDL__TYPE_H
|
||||
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <plasp/utils/Parser.h>
|
||||
|
||||
namespace plasp
|
||||
{
|
||||
namespace pddl
|
||||
{
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Type
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class Type
|
||||
{
|
||||
public:
|
||||
Type(std::string name);
|
||||
|
||||
public:
|
||||
void setDirty(bool isDirty = true);
|
||||
bool isDirty() const;
|
||||
|
||||
const std::string &name() const;
|
||||
|
||||
void addParentType(const Type &parentType);
|
||||
const std::vector<const Type *> &parentTypes() const;
|
||||
|
||||
private:
|
||||
bool m_isDirty;
|
||||
|
||||
std::string m_name;
|
||||
|
||||
std::vector<const Type *> m_parentTypes;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -26,6 +26,7 @@ class Parser
|
|||
|
||||
char currentCharacter() const;
|
||||
void advance();
|
||||
bool advanceIf(char expectedCharacter);
|
||||
bool atEndOfFile() const;
|
||||
|
||||
template<typename Type>
|
||||
|
|
@ -54,8 +55,6 @@ class Parser
|
|||
private:
|
||||
void checkStream() const;
|
||||
|
||||
bool advanceIf(char expectedCharacter);
|
||||
|
||||
uint64_t parseIntegerBody();
|
||||
|
||||
std::istream &m_istream;
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include <algorithm>
|
||||
|
||||
#include <plasp/pddl/ConsistencyException.h>
|
||||
#include <plasp/pddl/Identifier.h>
|
||||
#include <plasp/utils/ParserException.h>
|
||||
|
||||
|
|
@ -38,6 +39,8 @@ Domain Domain::fromPDDL(utils::Parser &parser)
|
|||
|
||||
domain.computeDerivedRequirements();
|
||||
|
||||
domain.checkConsistency();
|
||||
|
||||
return domain;
|
||||
}
|
||||
|
||||
|
|
@ -57,6 +60,13 @@ const Requirement::Types &Domain::requirements() const
|
|||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const Domain::TypesHashMap &Domain::types() const
|
||||
{
|
||||
return m_types;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Domain::parseSection(utils::Parser &parser)
|
||||
{
|
||||
parser.expect<std::string>("(:");
|
||||
|
|
@ -90,7 +100,7 @@ void Domain::parseSection(utils::Parser &parser)
|
|||
if (sectionIdentifier == "requirements")
|
||||
parseRequirementsSection(parser);
|
||||
else if (sectionIdentifier == "types")
|
||||
skipSection();
|
||||
parseTypingSection(parser);
|
||||
else if (sectionIdentifier == "constants")
|
||||
skipSection();
|
||||
else if (sectionIdentifier == "predicates")
|
||||
|
|
@ -128,16 +138,17 @@ void Domain::parseRequirementsSection(utils::Parser &parser)
|
|||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
bool Domain::hasRequirement(Requirement::Type requirement) const
|
||||
{
|
||||
const auto match = std::find(m_requirements.cbegin(), m_requirements.cend(), requirement);
|
||||
|
||||
return match != m_requirements.cend();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Domain::computeDerivedRequirements()
|
||||
{
|
||||
const auto hasRequirement =
|
||||
[&](const auto requirement)
|
||||
{
|
||||
const auto match = std::find(m_requirements.cbegin(), m_requirements.cend(), requirement);
|
||||
|
||||
return match != m_requirements.cend();
|
||||
};
|
||||
|
||||
const auto addRequirementUnique =
|
||||
[&](const auto requirement)
|
||||
{
|
||||
|
|
@ -180,5 +191,68 @@ void Domain::computeDerivedRequirements()
|
|||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Domain::parseTypingSection(utils::Parser &parser)
|
||||
{
|
||||
// Parses a single type identifier
|
||||
const auto parseType =
|
||||
[&]() -> auto &
|
||||
{
|
||||
parser.skipWhiteSpace();
|
||||
|
||||
const auto typeName = parser.parseIdentifier(isIdentifier);
|
||||
const auto insertionResult = m_types.emplace(std::make_pair(typeName, Type(typeName)));
|
||||
auto &type = insertionResult.first->second;
|
||||
|
||||
// Flag type for potentially upcoming parent type declaration
|
||||
type.setDirty();
|
||||
|
||||
parser.skipWhiteSpace();
|
||||
|
||||
return type;
|
||||
};
|
||||
|
||||
// Parses a type and potentially its parent type
|
||||
while (parser.currentCharacter() != ')')
|
||||
{
|
||||
parseType();
|
||||
|
||||
// Check for type inheritance
|
||||
if (!parser.advanceIf('-'))
|
||||
continue;
|
||||
|
||||
// If existing, parse parent type
|
||||
auto &parentType = parseType();
|
||||
|
||||
parentType.setDirty(false);
|
||||
|
||||
// Assign parent type to all types that were previously flagged
|
||||
std::for_each(m_types.begin(), m_types.end(),
|
||||
[&](auto &childType)
|
||||
{
|
||||
if (!childType.second.isDirty())
|
||||
return;
|
||||
|
||||
childType.second.addParentType(parentType);
|
||||
childType.second.setDirty(false);
|
||||
});
|
||||
}
|
||||
|
||||
parser.expect<std::string>(")");
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Domain::checkConsistency()
|
||||
{
|
||||
if (!m_types.empty() && !hasRequirement(Requirement::Type::Typing))
|
||||
{
|
||||
throw ConsistencyException("Domain contains typing information but does not declare typing requirement");
|
||||
|
||||
m_requirements.push_back(Requirement::Type::Typing);
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,58 @@
|
|||
#include <plasp/pddl/Type.h>
|
||||
|
||||
namespace plasp
|
||||
{
|
||||
namespace pddl
|
||||
{
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Type
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
Type::Type(std::string name)
|
||||
: m_isDirty{false},
|
||||
m_name{name}
|
||||
{
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Type::setDirty(bool isDirty)
|
||||
{
|
||||
m_isDirty = isDirty;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
bool Type::isDirty() const
|
||||
{
|
||||
return m_isDirty;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const std::string &Type::name() const
|
||||
{
|
||||
return m_name;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Type::addParentType(const Type &parentType)
|
||||
{
|
||||
m_parentTypes.emplace_back(&parentType);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const std::vector<const Type *> &Type::parentTypes() const
|
||||
{
|
||||
return m_parentTypes;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -13,7 +13,8 @@ class PDDLParserTests : public ::testing::Test
|
|||
{
|
||||
protected:
|
||||
PDDLParserTests()
|
||||
: m_blocksworldDomainFile(readFile("data/blocksworld-domain.pddl"))
|
||||
: m_blocksworldDomainFile(readFile("data/blocksworld-domain.pddl")),
|
||||
m_storageDomainFile(readFile("data/storage-domain.pddl"))
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -32,11 +33,12 @@ class PDDLParserTests : public ::testing::Test
|
|||
}
|
||||
|
||||
std::stringstream m_blocksworldDomainFile;
|
||||
std::stringstream m_storageDomainFile;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_F(PDDLParserTests, ParseValidPDDLFile)
|
||||
TEST_F(PDDLParserTests, ParseBlocksWorldDomain)
|
||||
{
|
||||
try
|
||||
{
|
||||
|
|
@ -46,9 +48,62 @@ TEST_F(PDDLParserTests, ParseValidPDDLFile)
|
|||
|
||||
const auto &domain = description.domain();
|
||||
|
||||
ASSERT_EQ(domain.name(), "BLOCKS");
|
||||
|
||||
ASSERT_EQ(domain.requirements().size(), 2u);
|
||||
ASSERT_EQ(domain.requirements()[0], plasp::pddl::Requirement::Type::STRIPS);
|
||||
ASSERT_EQ(domain.requirements()[1], plasp::pddl::Requirement::Type::Typing);
|
||||
|
||||
ASSERT_EQ(domain.types().size(), 1u);
|
||||
|
||||
const auto blockType = domain.types().find("block");
|
||||
ASSERT_NE(blockType, domain.types().cend());
|
||||
|
||||
ASSERT_EQ(blockType->second.name(), "block");
|
||||
ASSERT_EQ(blockType->second.parentTypes().size(), 0u);
|
||||
}
|
||||
catch (const std::exception &e)
|
||||
{
|
||||
FAIL() << e.what();
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_F(PDDLParserTests, ParseStorageDomain)
|
||||
{
|
||||
try
|
||||
{
|
||||
const auto description = plasp::pddl::Description::fromStream(m_storageDomainFile);
|
||||
|
||||
ASSERT_NO_THROW(description.domain());
|
||||
|
||||
const auto &domain = description.domain();
|
||||
|
||||
ASSERT_EQ(domain.name(), "Storage-Propositional");
|
||||
|
||||
ASSERT_EQ(domain.requirements().size(), 1u);
|
||||
ASSERT_EQ(domain.requirements()[0], plasp::pddl::Requirement::Type::Typing);
|
||||
|
||||
const auto area = domain.types().find("area");
|
||||
ASSERT_NE(area, domain.types().cend());
|
||||
const auto hoist = domain.types().find("hoist");
|
||||
ASSERT_NE(hoist, domain.types().cend());
|
||||
const auto object = domain.types().find("object");
|
||||
ASSERT_NE(object, domain.types().cend());
|
||||
const auto storearea = domain.types().find("storearea");
|
||||
ASSERT_NE(storearea, domain.types().cend());
|
||||
const auto surface= domain.types().find("surface");
|
||||
ASSERT_NE(surface, domain.types().cend());
|
||||
|
||||
const auto &hoistParents = hoist->second.parentTypes();
|
||||
ASSERT_EQ(hoistParents.size(), 1u);
|
||||
ASSERT_TRUE(std::find(hoistParents.cbegin(), hoistParents.cend(), &object->second) != hoistParents.cend());
|
||||
|
||||
const auto &areaParents = area->second.parentTypes();
|
||||
ASSERT_EQ(areaParents.size(), 2u);
|
||||
ASSERT_TRUE(std::find(areaParents.cbegin(), areaParents.cend(), &object->second) != areaParents.cend());
|
||||
ASSERT_TRUE(std::find(areaParents.cbegin(), areaParents.cend(), &surface->second) != areaParents.cend());
|
||||
}
|
||||
catch (const std::exception &e)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -0,0 +1,46 @@
|
|||
(define (domain Storage-Propositional)
|
||||
(:requirements :typing)
|
||||
(:types hoist surface place area - object
|
||||
container depot - place
|
||||
storearea transitarea - area
|
||||
area crate - surface)
|
||||
|
||||
(:predicates (clear ?s - storearea)
|
||||
(in ?x - (either storearea crate) ?p - place)
|
||||
(available ?h - hoist)
|
||||
(lifting ?h - hoist ?c - crate)
|
||||
(at ?h - hoist ?a - area)
|
||||
(on ?c - crate ?s - storearea)
|
||||
(connected ?a1 ?a2 - area)
|
||||
(compatible ?c1 ?c2 - crate))
|
||||
|
||||
(:action lift
|
||||
:parameters (?h - hoist ?c - crate ?a1 - storearea ?a2 - area ?p - place)
|
||||
:precondition (and (connected ?a1 ?a2) (at ?h ?a2) (available ?h)
|
||||
(on ?c ?a1) (in ?a1 ?p))
|
||||
:effect (and (not (on ?c ?a1)) (clear ?a1)
|
||||
(not (available ?h)) (lifting ?h ?c) (not (in ?c ?p))))
|
||||
|
||||
(:action drop
|
||||
:parameters (?h - hoist ?c - crate ?a1 - storearea ?a2 - area ?p - place)
|
||||
:precondition (and (connected ?a1 ?a2) (at ?h ?a2) (lifting ?h ?c)
|
||||
(clear ?a1) (in ?a1 ?p))
|
||||
:effect (and (not (lifting ?h ?c)) (available ?h)
|
||||
(not (clear ?a1)) (on ?c ?a1) (in ?c ?p)))
|
||||
|
||||
(:action move
|
||||
:parameters (?h - hoist ?from ?to - storearea)
|
||||
:precondition (and (at ?h ?from) (clear ?to) (connected ?from ?to))
|
||||
:effect (and (not (at ?h ?from)) (at ?h ?to) (not (clear ?to)) (clear ?from)))
|
||||
|
||||
(:action go-out
|
||||
:parameters (?h - hoist ?from - storearea ?to - transitarea)
|
||||
:precondition (and (at ?h ?from) (connected ?from ?to))
|
||||
:effect (and (not (at ?h ?from)) (at ?h ?to) (clear ?from)))
|
||||
|
||||
(:action go-in
|
||||
:parameters (?h - hoist ?from - transitarea ?to - storearea)
|
||||
:precondition (and (at ?h ?from) (connected ?from ?to) (clear ?to))
|
||||
:effect (and (not (at ?h ?from)) (at ?h ?to) (not (clear ?to))))
|
||||
)
|
||||
|
||||
Reference in New Issue