Blackboard.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <AtomsCore/Metadata/Metadata.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/StringMetadata.h>
#include <Atoms/BehaviourTree/BlackboardValue.h>
#include <map>
 
namespace Atoms
{
    struct BlackboardEntry
    {
        enum Flags {
            None = 0,
            LinkMetadata = 1,
            CacheMetadata = 2
        };
 
        std::string name;
        AtomsPtr<AtomsCore::Metadata> value;
        short flags;
    };
 
    class BlackboardInstance;
 
    class ATOMS_EXPORT Blackboard
    {
    public:
 
        Blackboard();
 
        ~Blackboard();
 
        BlackboardEntry& entry(size_t index);
 
        size_t addEntry(const std::string& name, AtomsPtr<AtomsCore::Metadata>& metadata, short flags = 0);
 
        void updateEntry(const std::string& name, AtomsPtr<AtomsCore::Metadata>& metadata);
 
        size_t addEntry(const std::string& name, AtomsCore::Metadata* metadata, short flags = 0);
 
        inline size_t size() const { return m_entries.size(); }
 
        inline void setParent(Blackboard* parent) { m_parent = parent; }
 
        Blackboard* parent() { return m_parent; }
        const Blackboard* parent() const { return m_parent; }
 
        BlackboardEntryPosition entryPosition(const std::string& name) const;
 
        unsigned int entryType(const std::string& name) const;
 
        std::string entryTypeStr(const std::string& name) const;
 
        void initializeInstance(BlackboardInstance& instance, bool clone=true);
 
        void clear();
 
    private:
 
        std::vector<BlackboardEntry> m_entries;
 
        Blackboard* m_parent;
 
    };
 
    class ATOMS_EXPORT BlackboardInstance
    {
    public:
        BlackboardInstance();
 
        ~BlackboardInstance();
 
        inline size_t size() const { return values.size(); }
 
        AtomsPtr<AtomsCore::Metadata>& entry(size_t index) { assert(values.size() > index);  return values[index]; }
        const AtomsPtr<AtomsCore::Metadata>& entry(size_t index) const { assert(values.size() > index);  return values[index]; }
 
    public:
        std::vector<AtomsPtr<AtomsCore::Metadata>> values;
 
        BlackboardInstance* parent;
 
        Blackboard* blackboard;
    };
 
 
    template <typename T, typename M>
    inline void getBlackboardValueFromAttributes(const AtomsCore::MapMetadata* attributes, Blackboard* blackboard, const std::string& attributeName, BlackboardValue<M>& blackboardValue)
    {
        blackboardValue.position.valueIndex = -1;
        blackboardValue.position.parentIndex = 0;
        auto attrPtr = attributes->getTypedEntry<T>(attributeName);
        if (attrPtr)
        {
            blackboardValue.value = attrPtr->value();
        }
 
        auto properties = attributes->getTypedEntry<AtomsCore::MapMetadata>(attributeName + "#properties");
        if (properties && blackboard)
        {
            auto blackboardKey = properties->getTypedEntry<AtomsCore::StringMetadata>("blackboard_key");
            if (blackboardKey && !blackboardKey->get().empty())
            {
                auto bbPosition = blackboard->entryPosition(blackboardKey->get());
                blackboardValue.position = bbPosition;
            }
        }
    }
 
    inline void getBlackboardKeyPositionFromAttributes(const AtomsCore::MapMetadata* attributes, Blackboard* blackboard, const std::string& attributeName, BlackboardValue<std::string>& blackboardValue)
    {
        blackboardValue.position.valueIndex = -1;
        blackboardValue.position.parentIndex = 0;
        auto attrPtr = attributes->getTypedEntry<AtomsCore::StringMetadata>(attributeName);
        if (attrPtr)
        {
            auto bbPosition = blackboard->entryPosition(attrPtr->get());
            blackboardValue.position = bbPosition;
        }
 
        auto properties = attributes->getTypedEntry<AtomsCore::MapMetadata>(attributeName + "#properties");
        if (properties && blackboard)
        {
            auto blackboardKey = properties->getTypedEntry<AtomsCore::StringMetadata>("blackboard_key");
            if (blackboardKey && !blackboardKey->get().empty())
            {
                auto bbPosition = blackboard->entryPosition(blackboardKey->get());
                blackboardValue.position = bbPosition;
            }
        }
    }
 
    template <>
    inline void getBlackboardValueFromAttributes<AtomsCore::Metadata, AtomsPtr<AtomsCore::Metadata>>(const AtomsCore::MapMetadata* attributes, Blackboard* blackboard, const std::string& attributeName, BlackboardMetadataValue& blackboardValue)
    {
        blackboardValue.position.valueIndex = -1;
        blackboardValue.position.parentIndex = 0;
        auto attrPtr = attributes->getEntry(attributeName);
        if (attrPtr)
        {
            blackboardValue.value = attrPtr->clone();
        }
 
        auto properties = attributes->getTypedEntry<AtomsCore::MapMetadata>(attributeName + "#properties");
        if (properties && blackboard)
        {
            auto blackboardKey = properties->getTypedEntry<AtomsCore::StringMetadata>("blackboard_key");
            if (blackboardKey && !blackboardKey->get().empty())
            {
                auto bbPosition = blackboard->entryPosition(blackboardKey->get());
                blackboardValue.position = bbPosition;
            }
        }
    }
}