Identity.cpp

Go to the documentation of this file.

#include "Identity.h"

#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>

#include <vector>
#include <iostream>
#include <sstream>

#include "SpicaException.h"

using namespace boost::algorithm;

namespace castor { namespace spica {

        Identity::Identity() :
                id(0), concept(""), rep(""), name("")
        {
        }

        Identity::Identity(const Identifier identifier) :
                id(0), concept(""), rep(""), name("")
        {

                std::vector<std::string> result;

                split(result, identifier, is_any_of(";"));

                for (size_t i = 0; i < result.size(); i++) {

                        std::vector<std::string> keyvalue;

                        split(keyvalue, result[i], is_any_of("="));

                        if (keyvalue.size() != 2) {
                                std::ostringstream ss;
                                ss << "Unable to parse component " << i << " of identifier " << identifier << std::endl;
                                std::cout << ss.str() << std::endl;
                                throw SpicaException(ss.str());
                        }

                        trim(keyvalue[0]);
                        to_lower(keyvalue[0]);

                        if (keyvalue[0] == "id") {

                                this->id = boost::lexical_cast<SpicaId>(keyvalue[1]);

                        } else if (keyvalue[0] == "concept") {

                                this->concept = keyvalue[1];

                        } else if (keyvalue[0] == "rep") {

                                this->rep = keyvalue[1];

                        } else if (keyvalue[0] == "name") {

                                this->name = keyvalue[1];
                        }

                }
        }

        Identity::Identity(SpicaId id, const std::string concept, const std::string rep, const std::string name) :
                id(id), concept(concept), rep(rep), name(name)
        {
        }

        Identity::Identity(const Identity &other) :
                id(other.id), concept(other.concept), rep(other.rep), name(other.name)
        {
        }

        bool Identity::isMatch(const Identifier other) const {
                return isMatch(Identity(other));
        }

        bool Identity::isMatch(const Identity &other) const {
                return (!(*this < other) && !(other < *this));
        }


        bool Identity::hasId() const {
                return (this->id > 0);
        }

        SpicaId Identity::getId() const {
                return this->id;
        }

        bool Identity::hasConcept() const {
                return (this->concept.size() > 0);
        }

        const std::string Identity::getConcept() const {
                return this->concept;
        }

        bool Identity::hasRep() const {
                return (this->rep.size() > 0);
        }

        const std::string Identity::getRep() const {
                return this->rep;
        }

        bool Identity::hasName() const {
                return (this->name.size() > 0);
        }

        const std::string Identity::getName() const {
                return this->name;
        }

        std::string Identity::str() const {

                std::ostringstream ss;

                int count = 0;

                if (hasId()) {
                        ss << "id=" << this->id;
                        count++;
                }

                if (hasName()) {
                        ss << (count > 0 ? ";" : "") << "name=" << this->name;
                        count++;

                } else if (hasConcept()) {
                        ss << (count > 0 ? ";" : "") << "concept=" << this->concept;
                        count++;

                } else if (hasRep()) {
                        ss << (count > 0 ? ";" : "") << "rep=" << this->rep;
                        count++;
                }

                return ss.str();
        }
        
        Identity &Identity::operator=(const Identity &other) {

                this->id = other.id;
                this->concept = other.concept;
                this->rep = other.rep;
                this->name = other.name;

                return *this;
        }

        Identity &Identity::operator=(const Identifier other) {

                Identity identity(other);

                this->id = identity.id;
                this->concept = identity.concept;
                this->rep = identity.rep;
                this->name = identity.name;

                return *this;
        }

        bool operator==(const Identity &one,
                                        const Identity &other)
        {
                return (!(one < other) && !(other < one));
        }

        bool operator<(const Identity &one,
                                   const Identity &other)
        {

                if (one.hasId() && other.hasId()) {
                        if (one.getId() < other.getId()) return true;
                        if (one.getId() != other.getId()) return false;
                }

                if (one.hasConcept() && other.hasConcept()) {
                        if (one.getConcept() < other.getConcept()) return true;
                        if (one.getConcept() != other.getConcept()) return false;
                }

                if (one.hasRep() && other.hasRep()) {
                        if (one.getRep() < other.getRep()) return true;
                        if (one.getRep() != other.getRep()) return false;
                }

                if (one.hasName() && other.hasName()) {
                        if (one.getName() < other.getName()) return true;
                        if (one.getName() != other.getName()) return false;
                }

                return false;
        }


} }