Started implementing PDDL type parsing.

This commit is contained in:
Patrick Lühne 2016-05-30 20:43:36 +02:00
parent 1c4c035acc
commit a989f5f86e
8 changed files with 362 additions and 13 deletions

View File

@ -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

View File

@ -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;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

48
include/plasp/pddl/Type.h Normal file
View File

@ -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

View File

@ -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;

View File

@ -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)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Domain::computeDerivedRequirements()
{
const auto hasRequirement =
[&](const auto requirement)
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 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);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}

58
src/plasp/pddl/Type.cpp Normal file
View File

@ -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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}

View File

@ -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)
{

View File

@ -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))))
)