Dict.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
 * Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
// Header
#include "Dict.h"
 
// ArmarX
#include <SimoxUtility/algorithm/string/string_conversion.h>
 
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/util/CPPUtility/trace.h>
 
#include <RobotAPI/libraries/aron/core/data/variant/Factory.h>
 
namespace armarx::aron::data
{
 
    // constructors
    Dict::Dict(const Path& path) :
        detail::ContainerVariant<data::dto::Dict, Dict>::ContainerVariant(data::Descriptor::DICT,
                                                                          path)
    {
    }
 
    Dict::Dict(const data::dto::DictPtr& o, const Path& path) :
        detail::ContainerVariant<data::dto::Dict, Dict>::ContainerVariant(o,
                                                                          data::Descriptor::DICT,
                                                                          path)
    {
        for (const auto& [key, dataPtr] : this->aron->elements)
        {
            childrenNavigators[key] = Variant::FromAronDTO(dataPtr, path.withElement(key));
        }
    }
 
    Dict::Dict(const std::map<std::string, VariantPtr>& m, const Path& path) : Dict(path)
    {
        for (const auto& [key, dataPtr] : m)
        {
            addElement(key, dataPtr);
        }
    }
 
    // operators
    bool
    Dict::operator==(const Dict& other) const
    {
        for (const auto& [key, nav] : childrenNavigators)
        {
            if (not(other.hasElement(key)))
            {
                return false;
            }
            if (!nav)
            {
                return !((bool)other.getElement(key));
            }
            if (not(*nav == *other.getElement(key)))
            {
                return false;
            }
        }
        return true;
    }
 
    bool
    Dict::operator==(const DictPtr& other) const
    {
        if (!other)
        {
            return false;
        }
        return *this == *other;
    }
 
    VariantPtr
    Dict::operator[](const std::string& s) const
    {
        return getElement(s);
    }
 
    Dict&
    Dict::operator=(const Dict& other)
    {
        this->aron = other.aron;
        this->childrenNavigators = other.childrenNavigators;
        return *this;
    }
 
    DictPtr
    Dict::clone(const Path& p) const
    {
        DictPtr ret(new Dict(p));
        ret->setImportance(getImportance());
        for (const auto& [key, val] : getElements())
        {
            if (val)
            {
                ret->addElement(key, val->cloneAsVariant());
            }
            else
            {
                ret->addElement(key, nullptr);
            }
        }
        return ret;
    }
 
    // static methods
    DictPtr
    Dict::FromAronDictDTO(const data::dto::DictPtr& aron)
    {
        if (!aron)
        {
            return nullptr;
        }
        return std::make_shared<Dict>(aron);
    }
 
    data::dto::DictPtr
    Dict::ToAronDictDTO(const DictPtr& navigator)
    {
        return navigator ? navigator->toAronDictDTO() : nullptr;
    }
 
    data::dto::DictPtr
    Dict::toAronDictDTO() const
    {
        return aron;
    }
 
    // public member functions
    std::vector<std::string>
    Dict::getAllKeys() const
    {
        std::vector<std::string> ret;
        for (const auto& [key, _] : childrenNavigators)
        {
            ret.push_back(key);
        }
        return ret;
    }
 
    std::string
    Dict::getAllKeysAsString() const
    {
        return simox::alg::to_string(getAllKeys(), ", ");
    }
 
    void
    Dict::addElement(const std::string& key, const VariantPtr& data)
    {
        // Please note that the data may be null (indicating that a non existing maybetype has been added)
 
        if (hasElement(key))
        {
            ARMARX_TRACE;
            throw error::AronException(__PRETTY_FUNCTION__,
                                       "The key '" + key + "' already exists in a aron dict.");
        }
        setElement(key, data);
    }
 
    void
    Dict::addElementCopy(const std::string& key, const VariantPtr& data)
    {
        // Please note that the data may be null (indicating that a non existing maybetype has been added)
 
        if (hasElement(key))
        {
            ARMARX_TRACE;
            throw error::AronException(__PRETTY_FUNCTION__,
                                       "The key '" + key + "' already exists in a aron dict.");
        }
        setElementCopy(key, data);
    }
 
    void
    Dict::mergeAndReplace(const DictPtr& d)
    {
        if (d == nullptr)
        {
            return;
        }
 
        // merge and overwrite
        for (const auto& [k, v] : d->getElements())
        {
            this->setElement(k, v);
        }
    }
 
    void
    Dict::mergeAndReplaceCopy(const DictPtr& d)
    {
        if (d == nullptr)
        {
            return;
        }
 
        // merge and overwrite
        for (const auto& [k, v] : d->getElements())
        {
            this->setElementCopy(k, v);
        }
    }
 
    bool
    Dict::hasElement(const std::string& key) const
    {
        return childrenNavigators.count(key) > 0;
    }
 
    VariantPtr
    Dict::getElement(const std::string& key) const
    {
        auto it = childrenNavigators.find(key);
        if (it == childrenNavigators.end())
        {
            ARMARX_TRACE;
            throw error::AronException(__PRETTY_FUNCTION__,
                                       "Could not find key '" + key +
                                           "'. But I found the following keys: [" +
                                           simox::alg::join(this->getAllKeys(), ", ") + "]",
                                       getPath());
        }
        return it->second;
    }
 
    std::map<std::string, VariantPtr>
    Dict::getElements() const
    {
        return childrenNavigators;
    }
 
    void
    Dict::setElement(const std::string& key, const VariantPtr& data)
    {
        // Please note that the data may be null (indicating that a non existing maybetype has been added)
 
        if (data)
        {
            const auto& p = data->getPath();
            if (not p.hasDirectPrefix(this->getPath()))
            {
                ARMARX_DEBUG << deactivateSpam(5)
                             << "An element added to a dict does not have a correct path set. This "
                                "may cause errors. Please use setElemetCopy() instead.";
            }
        }
 
        this->childrenNavigators[key] = data;
        if (data)
        {
            this->aron->elements[key] = data->toAronDTO();
        }
        else
        {
            this->aron->elements[key] = nullptr;
        }
    }
 
    void
    Dict::setElementCopy(const std::string& key, const VariantPtr& data)
    {
        // Please note that the data may be null (indicating that a non existing maybetype has been added)
 
        VariantPtr copy = nullptr;
        if (data)
        {
            Path newPath = getPath().withElement(key);
            copy = data->cloneAsVariant(newPath);
        }
        setElement(key, copy);
    }
 
    void
    Dict::removeElement(const std::string& key)
    {
        childrenNavigators.erase(key);
        aron->elements.erase(key);
    }
 
    void
    Dict::clear()
    {
        childrenNavigators.clear();
        aron->elements.clear();
    }
 
    VariantPtr
    Dict::at(const std::string& s) const
    {
        return getElement(s);
    }
 
    // virtual implementations
    std::string
    Dict::getShortName() const
    {
        return "Dict";
    }
 
    std::string
    Dict::getFullName() const
    {
        return "armarx::aron::data::Dict";
    }
 
    // TODO
    type::VariantPtr
    Dict::recalculateType() const
    {
        ARMARX_TRACE;
        throw error::NotImplementedYetException(__PRETTY_FUNCTION__);
    }
 
    bool
    Dict::fullfillsType(const type::VariantPtr& type) const
    {
        if (!type)
            return true;
 
        type::Descriptor typeDesc = type->getDescriptor();
 
        switch (typeDesc)
        {
            case type::Descriptor::OBJECT:
            {
                ARMARX_TRACE;
                auto objectTypeNav = type::Object::DynamicCastAndCheck(type);
 
                // here we need to iterate over the elements of the type. That must be fulfilled.
                // If this dict has more members that its fine.
                for (const auto& [key, childTypeNav] : objectTypeNav->getMemberTypes())
                {
                    if (!this->hasElement(key))
                    {
                        return false; // key must exist
                    }
 
                    if (!childTypeNav)
                    {
                        continue; // no information whih is fine --> continue
                    }
 
                    auto childNav = this->getElement(key);
                    if (childNav)
                    {
                        if (not childNav->fullfillsType(childTypeNav))
                        {
                            return false;
                        }
                        // else childnav fulfills type which is fine --> continue
                        continue;
                    }
                    else
                    {
                        if (childTypeNav->getMaybe() == type::Maybe::NONE)
                        {
                            return false;
                        }
                        // else: childTypeNav == maybe && nav == null which is fine --> continue
                        continue;
                    }
                }
                return true;
            }
            case type::Descriptor::DICT:
            {
                ARMARX_TRACE;
                auto dictTypeNav = type::Dict::DynamicCastAndCheck(type);
                for (const auto& [key, childNav] : childrenNavigators)
                {
                    (void)key;
                    auto childTypeNav = dictTypeNav->getAcceptedType();
                    if (!childNav)
                    {
                        if (childTypeNav && childTypeNav->getMaybe() == type::Maybe::NONE)
                        {
                            return false;
                        }
                        // else childTypeNav is null or maybe and childNav is null which is fine.
                        continue;
                    }
                    if (!childNav->fullfillsType(childTypeNav))
                    {
                        return false;
                    }
                }
                return true;
            }
            default:
                return false;
        }
    }
 
    std::vector<VariantPtr>
    Dict::getChildren() const
    {
        std::vector<VariantPtr> ret(childrenNavigators.size());
        for (const auto& [key, nav] : childrenNavigators)
        {
            ret.push_back(nav);
        }
        return ret;
    }
 
    size_t
    Dict::childrenSize() const
    {
        return childrenNavigators.size();
    }
 
    VariantPtr
    Dict::navigateAbsolute(const Path& path) const
    {
        if (!path.hasElement())
        {
            ARMARX_TRACE;
            throw error::AronException(
                __PRETTY_FUNCTION__, "Could not navigate without a valid path", path);
        }
        std::string el = path.getFirstElement();
        if (!hasElement(el))
        {
            ARMARX_TRACE;
            throw error::ValueNotValidException(
                __PRETTY_FUNCTION__, "Could not find an element of a path.", el, path);
        }
 
        if (path.size() == 1)
        {
            return childrenNavigators.at(el);
        }
        else
        {
            Path next = path.withDetachedFirstElement();
            if (!childrenNavigators.at(el))
            {
                ARMARX_TRACE;
                throw error::AronException(__PRETTY_FUNCTION__,
                                           "Could not navigate into a NULL member. Seems like the "
                                           "member is optional and not set.",
                                           next);
            }
            return childrenNavigators.at(el)->navigateAbsolute(next);
        }
    }
} // namespace armarx::aron::data