Uuid.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include <boost/uuid/uuid.hpp>
#include <iostream>

namespace Arp { namespace System { namespace Commons { namespace Configuration
{

class Uuid
{
public: // typedefs/usings
    using BasicUuid = boost::uuids::uuid;

public: // construction/destruction
    Uuid(void);
    Uuid(const Uuid& arg) = default;
    Uuid(Uuid&& arg) = default;
    Uuid& operator=(const Uuid& arg) = default;
    ~Uuid(void) = default;

public: // global compare operators
    friend bool operator==(const Uuid& lhs, const Uuid& rhs)noexcept;
    friend bool operator!=(const Uuid& lhs, const Uuid& rhs)noexcept;
    friend bool operator<(const Uuid& lhs, const Uuid& rhs)noexcept;
    friend bool operator>(const Uuid& lhs, const Uuid& rhs)noexcept;
    friend bool operator<=(const Uuid& lhs, const Uuid& rhs)noexcept;
    friend bool operator>=(const Uuid& lhs, const Uuid& rhs)noexcept;

public: // global stream operators
    friend std::ostream& operator<<(std::ostream& os, const Uuid& id);
    friend std::istream& operator>>(std::istream& is, Uuid& id);

public: // static properties
    static Uuid Empty(void);

public: // static operations
    static Uuid     CreateNew(void);

    static Uuid     Create(const byte* pBuffer);

    static Uuid     CreateFromLittleEndian(const byte* pBuffer);

    static Uuid     Parse(const String& input);

    static bool     TryParse(const String& input, Uuid& result);

public: // properties
    bool    IsEmpty(void)const;

public: // operations
    String  ToString(void)const;

    size_t  GetHashValue(void)const;

    void    Clear(void);

    void    CopyTo(byte* pBuffer)const;

    void    CopyLittleEndianTo(byte* pBuffer)const;

private: // fields
    BasicUuid   basicId;
};

// inline methods of class Uuid
inline bool Uuid::IsEmpty()const
{
    return basicId.is_nil();
}

// global operators
inline bool operator==(const Uuid& lhs, const Uuid& rhs) noexcept
{
    return lhs.basicId == rhs.basicId;
}

inline bool operator!=(const Uuid& lhs, const Uuid& rhs) noexcept
{
    return lhs.basicId != rhs.basicId;
}

inline bool operator<(const Uuid& lhs, const Uuid& rhs) noexcept
{
    return lhs.basicId < rhs.basicId;
}

inline bool operator>(const Uuid& lhs, const Uuid& rhs) noexcept
{
    return lhs.basicId > rhs.basicId;
}

inline bool operator<=(const Uuid& lhs, const Uuid& rhs) noexcept
{
    return lhs.basicId <= rhs.basicId;
}

inline bool operator>=(const Uuid& lhs, const Uuid& rhs) noexcept
{
    return lhs.basicId >= rhs.basicId;
}

}}}} // end of namespace Arp::System::Commons::Configuration

// standard template specializations of class Uuid
namespace std
{

// std hash functor of class Uuid
template<>
struct hash<Arp::System::Commons::Configuration::Uuid>
{
public:
    typedef Arp::System::Commons::Configuration::Uuid   argument_type;
    typedef size_t                                      result_type;

public:
    result_type operator()(const argument_type& key) const
    {
        return key.GetHashValue();
    }
};
}