TransportDirectedEdgeId.h

#pragma once

#include "Transport.h"
#include "TiledGraphNode.h"
#include "TiledGraphEdge.h"
#include "TransportWay.h"
#include "TransportNode.h"

#include <vector>

namespace Eegeo
{
    namespace Transport
    {
        struct TransportDirectedEdgeId
        {
            TransportDirectedEdgeId()
                : CellKey(Streaming::MortonKey(0))
                , LocalDirectedEdgeId(-1)
                , TransportNetworkType(TransportNetwork::TransportRoad)
            {}

            TransportDirectedEdgeId(
                TransportNetwork::Type transportNetworkType,
                const Streaming::MortonKey& cellKey,
                TransportLocalDirectedEdgeId localDirectedEdgeId
            )
                : CellKey(cellKey)
                , LocalDirectedEdgeId(localDirectedEdgeId)
                , TransportNetworkType(transportNetworkType)
            {}

            TransportDirectedEdgeId(
                TransportNetwork::Type transportNetworkType,
                const Graphs::TiledGraphEdgeId& graphEdgeId
            )
                : CellKey(graphEdgeId.CellKey)
                , LocalDirectedEdgeId(graphEdgeId.LocalEdgeId)
                , TransportNetworkType(transportNetworkType)
            {}

            Streaming::MortonKey CellKey;
            TransportLocalDirectedEdgeId LocalDirectedEdgeId;
            TransportNetwork::Type TransportNetworkType;
        };

        inline bool operator == (const TransportDirectedEdgeId& lhs, const TransportDirectedEdgeId& rhs)
        {
            return (lhs.LocalDirectedEdgeId == rhs.LocalDirectedEdgeId) &&
                (lhs.CellKey == rhs.CellKey) &&
                (lhs.TransportNetworkType == rhs.TransportNetworkType);
        }


        struct TransportDirectedEdgeIdHash
        {
            std::size_t operator()(const TransportDirectedEdgeId& edgeId) const
            {
                std::size_t h1 = Eegeo::Streaming::MortonKeyHash{}(edgeId.CellKey);
                std::size_t h2 = std::hash<int>{}(edgeId.LocalDirectedEdgeId);
                std::size_t h3 = std::hash<int>{}(edgeId.TransportNetworkType);
                return (h1 ^ (h2 << 1)) ^ (h3 << 1);
            }
        };
   }
}