libcore/include/sirikata/core/xdp/Defs.hpp

Go to the documentation of this file.

// Copyright (c) 2011 Sirikata Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can
// be found in the LICENSE file.

#ifndef _SIRIKATA_LIBCORE_XDP_DEFS_HPP_
#define _SIRIKATA_LIBCORE_XDP_DEFS_HPP_

#include <sirikata/core/util/Platform.hpp>
#include <sirikata/core/util/SpaceID.hpp>

namespace Sirikata {
namespace XDP {

class PortID;
template<typename IdentifierType>
class Endpoint;

class SIRIKATA_EXPORT PortID {
public:
    PortID();
    PortID(uint32 rhs);
    PortID(const PortID& rhs);

    static const PortID& null();
    static const PortID& any();

    PortID& operator=(const PortID& rhs);
    PortID& operator=(uint32 rhs);

    operator uint32() const;

    bool operator==(const PortID& rhs) const;
    bool operator!=(const PortID& rhs) const;
    bool operator>(const PortID& rhs) const;
    bool operator>=(const PortID& rhs) const;
    bool operator<(const PortID& rhs) const;
    bool operator<=(const PortID& rhs) const;

    PortID& operator++ ();
    PortID operator++ (int);

    bool matches(const PortID& rhs) const;

    class Hasher {
    public:
        size_t operator()(const PortID& p) const {
            return std::tr1::hash<uint32>()(p.mValue);
        }
    };

private:
    uint32 mValue;
};

// We can't actually define this here since it depends on the IdentifierType
//typedef std::tr1::function<void(const Endpoint& src, const Endpoint& dst, MemoryReference)> MessageHandler;

template<typename IdentifierType>
class Endpoint {
public:
    typedef IdentifierType Identifier;

    Endpoint(const SpaceID& space, const Identifier& id, const PortID& port)
     : mSpace(space),
       mID(id),
       mPort(port)
    {
    }

    bool operator==(const Endpoint& rhs) const {
        return (
            mSpace == rhs.mSpace &&
            mID == rhs.mID &&
            mPort == rhs.mPort
        );
    }
    bool operator!=(const Endpoint& rhs) const {
        return !(*this == rhs);
    }
    bool operator>(const Endpoint& rhs) const {
        return (
            mSpace > rhs.mSpace || (
                mSpace == rhs.mSpace && (
                    mID > rhs.mID || (
                        mID == rhs.mID && (
                            mPort > rhs.mPort
                        )
                    )
                )
            )
        );
    }
    bool operator>=(const Endpoint& rhs) const {
        return !(*this < rhs);
    }
    bool operator<(const Endpoint& rhs) const {
        return (
            mSpace < rhs.mSpace || (
                mSpace == rhs.mSpace && (
                    mID < rhs.mID || (
                        mID == rhs.mID && (
                            mPort < rhs.mPort
                        )
                    )
                )
            )
        );
    }
    bool operator<=(const Endpoint& rhs) const {
        return !(*this > rhs);
    }


    bool matches(const Endpoint& rhs) const {
        return (
            mSpace.matches(rhs.mSpace) &&
            mID.matches(rhs.mID) &&
            mPort.matches(rhs.mPort)
        );
    }

    const SpaceID& space() const { return mSpace; }
    const Identifier& id() const { return mID; }
    const PortID& port() const { return mPort; }

    String toString() const {
        std::ostringstream ss;
        ss << (*this);
        return ss.str();
    }

    class Hasher {
    public:
        size_t operator()(const Endpoint& p) const {
            return (
                SpaceID::Hasher()(p.mSpace) ^
                typename Identifier::Hasher()(p.mID) ^
                PortID::Hasher()(p.mPort)
            );
        }
    };
private:
    Endpoint();

    SpaceID mSpace;
    Identifier mID;
    PortID mPort;
}; // class Endpoint

template<typename IdentifierType>
std::ostream& operator<<(std::ostream& os, const Sirikata::XDP::Endpoint<IdentifierType>& ep) {
    os << ep.space() << ":" << ep.id() << ":" << ep.port();
    return os;
}

} // namespace ODP
} // namespace Sirikata

#endif //_SIRIKATA_ODP_DEFS_HPP_