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();
    }
};
}