TiledGraphEdge.h

#pragma once

#include "Graphs.h"
#include "TiledGraphNode.h"
#include <sstream>

namespace Eegeo
{
    namespace Graphs
    {
        struct TiledGraphEdgeId
        {
            TiledGraphEdgeId()
                : CellKey(Eegeo::Streaming::MortonKey(0))
                , LocalEdgeId(-1)
            {}

            TiledGraphEdgeId(
                const Eegeo::Streaming::MortonKey& cellKey,
                int localEdgeId
            )
                : CellKey(cellKey)
                , LocalEdgeId(localEdgeId)
            {}

            TiledGraphEdgeId(const TiledGraphEdgeId& other)
                : CellKey(other.CellKey)
                , LocalEdgeId(other.LocalEdgeId)
            {}


            Eegeo::Streaming::MortonKey CellKey;
            int LocalEdgeId;
        };

        inline bool operator == (const TiledGraphEdgeId& lhs, const TiledGraphEdgeId& rhs)
        {
            return (lhs.LocalEdgeId == rhs.LocalEdgeId) &&
                (lhs.CellKey == rhs.CellKey);
        }

        inline std::string TiledGraphEdgeIdToString(const TiledGraphEdgeId& edgeId)
        {
            std::stringstream ss;
            ss << edgeId.CellKey.ToString() << ":" << edgeId.LocalEdgeId;
            return ss.str();
        }

        struct TiledGraphEdgeIdHash
        {
            std::size_t operator()(const TiledGraphEdgeId& edgeId) const
            {
                std::size_t h1 = Eegeo::Streaming::MortonKeyHash{}(edgeId.CellKey);
                std::size_t h2 = std::hash<int>{}(edgeId.LocalEdgeId);
                return h1 ^ (h2 << 1);
            }
        };

        struct TiledGraphEdge
        {
            TiledGraphEdge()
                : Weight(0.f)
                , AttributesDirectionReversed(false)
            {}

            TiledGraphEdge(
                const TiledGraphNodeId& nodeIdA,
                const TiledGraphNodeId& nodeIdB,
                const TiledGraphEdgeAttributesId& attributesId,
                float weight,
                bool attributesDirectionReversed
            )
                : NodeIdA(nodeIdA)
                , NodeIdB(nodeIdB)
                , AttributesId(attributesId)
                , Weight(weight)
                , AttributesDirectionReversed(attributesDirectionReversed)
            {}

            TiledGraphNodeId NodeIdA;
            TiledGraphNodeId NodeIdB; 
            TiledGraphEdgeAttributesId AttributesId;
            float Weight;
            bool AttributesDirectionReversed;
        };
        
        inline bool operator == (const TiledGraphEdge& lhs, const TiledGraphEdge& rhs)
        {
            return (lhs.NodeIdA == rhs.NodeIdA) &&
            (lhs.NodeIdB == rhs.NodeIdB) &&
            (lhs.AttributesId == rhs.AttributesId) &&
            (lhs.Weight == rhs.Weight) &&
            (lhs.AttributesDirectionReversed == rhs.AttributesDirectionReversed);
        }
    }
}