repo_node.h

#pragma once

#include "repo_bson.h"

namespace repo{
    namespace core{
        namespace model{
            enum class NodeType{
                CAMERA, MAP, MATERIAL, MESH, METADATA, REFERENCE,
                REVISION, TEXTURE, TRANSFORMATION, UNKNOWN
            };

            class REPO_API_EXPORT RepoNode : public RepoBSON
            {
            public:

                RepoNode(RepoBSON bson,
                    const std::unordered_map<std::string, std::pair<std::string, std::vector<uint8_t>>> &binMapping =
                    std::unordered_map<std::string, std::pair<std::string, std::vector<uint8_t>>>());

                RepoNode() : RepoBSON() {};

                virtual ~RepoNode();

                virtual bool positionDependant() { return false; }

                /*
                *   ------------- Delusional modifiers --------------
                *   These are like "setters" but not. We are actually
                *   creating a new bson object with the changed field
                */

                RepoNode cloneAndAddParent(
                    const repoUUID &parent,
                    const bool     &newUniqueID = false,
                    const bool     &newSharedID = false,
                    const bool     &overwrite = false) const;

                RepoNode cloneAndAddParent(
                    const std::vector<repoUUID> &parents) const;

                virtual RepoNode cloneAndApplyTransformation(
                    const std::vector<float> &matrix) const
                {
                    return RepoNode(copy(), bigFiles);
                }

                RepoNode cloneAndChangeName(
                    const std::string &newName,
                    const bool &newUniqueID = true
                    ) const
                {
                    return cloneAndAddFields(new RepoBSON(BSON(REPO_NODE_LABEL_NAME << newName)), newUniqueID);
                }

                RepoNode cloneAndRemoveParent(
                    const repoUUID &parent,
                    const bool     &newUniqueID = true) const;

                virtual RepoNode cloneAndAddFields(
                    const RepoBSON *changes,
                    const bool     &newUniqueID = true) const;

                /*
                *   ------------- Convenience getters --------------
                */

                std::string getName() const
                {
                    return std::string(getStringField(REPO_NODE_LABEL_NAME));
                }

                repoUUID getSharedID() const { return getUUIDField(REPO_NODE_LABEL_SHARED_ID); }

                virtual std::string getType() const
                {
                    return getStringField(REPO_NODE_LABEL_TYPE);
                }

                virtual NodeType getTypeAsEnum() const;

                repoUUID getUniqueID() const{ return getUUIDField(REPO_NODE_LABEL_ID); }

                std::vector<repoUUID> getParentIDs() const;

                /*
                *   ------------- Compare operations --------------
                */
                bool operator==(const RepoNode& other) const
                {
                    return getUniqueID() == other.getUniqueID() && getSharedID() == other.getSharedID();
                }

                bool operator<(const RepoNode& other) const
                {
                    repoUUID sharedID = getSharedID();

                    if (sharedID == other.getSharedID()){
                        return getUniqueID() < other.getUniqueID();
                    }
                    else{
                        return sharedID < other.getSharedID();
                    }
                }

                virtual bool sEqual(const RepoNode &other) const
                {
                    //On a node level, it is impossible to tell if
                    //one node is semantically the same as other.
                    //One does not expect this to be ever called
                    repoWarning << "sEqual() is called for RepoNode* this is not expected!";
                    return false; //returns false just incase.
                }

                bool operator>(const RepoNode& other) const
                {
                    repoUUID sharedID = getSharedID();

                    if (sharedID == other.getSharedID()){
                        return getUniqueID() > other.getUniqueID();
                    }
                    else{
                        return sharedID > other.getSharedID();
                    }
                }

            protected:

                /*
                *   ------------- node fields --------------
                */

                //FIXME: Convenience fields, should these really exist?

                std::string type; 
            };
            struct RepoNodeComparator
            {
                bool operator()(const RepoNode* a, const RepoNode* b) const
                {
                    return *a < *b;
                }
            };

            typedef std::set<RepoNode *, RepoNodeComparator> RepoNodeSet;
        } //namespace model
    } //namespace core
} //namespace repo