SkillID.cpp

Go to the documentation of this file.

#include "SkillID.h"
 
#include <optional>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
namespace armarx
{
    namespace skills
    {
        bool
        SkillID::operator==(const SkillID& other) const
        {
            return this->toString() == other.toString();
        }
 
        bool
        SkillID::operator!=(const SkillID& other) const
        {
            return not(*this == other);
        }
 
        bool
        SkillID::operator<(const SkillID& other) const
        {
            return toString() < other.toString();
        }
 
        bool
        SkillID::operator<=(const SkillID& other) const
        {
            return toString() <= other.toString();
        }
 
        SkillID
        SkillID::FromIce(const manager::dto::SkillID& s)
        {
            return SkillID{.providerId =
                               skills::ProviderID{.providerName = s.providerId.providerName},
                           .skillName = s.skillName};
        }
 
        SkillID
        SkillID::FromIce(const provider::dto::SkillID& s,
                         const std::optional<ProviderID>& providerId)
        {
            if (providerId.has_value())
            {
                return SkillID{.providerId = *providerId, .skillName = s.skillName};
            }
            return SkillID{.skillName = s.skillName};
        }
 
        manager::dto::SkillID
        SkillID::toManagerIce() const
        {
            ARMARX_CHECK(isFullySpecified()) << "Got: " << toString();
            return {providerId->toManagerIce(), skillName};
        }
 
        provider::dto::SkillID
        SkillID::toProviderIce() const
        {
            return {skillName};
        }
 
        std::string
        SkillID::toString() const
        {
            if (providerId.has_value())
            {
                return providerId->providerName + NAME_SEPARATOR + skillName;
            }
            return NAME_SEPARATOR + skillName;
        }
 
        bool
        SkillID::isFullySpecified() const
        {
            return isSkillSpecified() and isProviderSpecified();
        }
 
        bool
        SkillID::isSkillSpecified() const
        {
            return not skillName.empty();
        }
 
        bool
        SkillID::isProviderSpecified() const
        {
            if (not providerId.has_value())
            {
                return false;
            }
            return not providerId->providerName.empty();
        }
    } // namespace skills
 
    std::ostream&
    skills::operator<<(std::ostream& os, const SkillID& id)
    {
        return os << "'" << id.toString() << "'";
    }
} // namespace armarx