include/opencascade/Standard_GUID.hxx

0001 // Created on: 1997-06-19
0002 // Created by: Christophe LEYNADIER
0003 // Copyright (c) 1997-1999 Matra Datavision
0004 // Copyright (c) 1999-2014 OPEN CASCADE SAS
0005 //
0006 // This file is part of Open CASCADE Technology software library.
0007 //
0008 // This library is free software; you can redistribute it and/or modify it under
0009 // the terms of the GNU Lesser General Public License version 2.1 as published
0010 // by the Free Software Foundation, with special exception defined in the file
0011 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
0012 // distribution for complete text of the license and disclaimer of any warranty.
0013 //
0014 // Alternatively, this file may be used under the terms of Open CASCADE
0015 // commercial license or contractual agreement.
0016
0017 #ifndef _Standard_GUID_HeaderFile
0018 #define _Standard_GUID_HeaderFile
0019
0020 #include <Standard_Handle.hxx>
0021
0022 #include <Standard_Integer.hxx>
0023 #include <Standard_CString.hxx>
0024 #include <Standard_UUID.hxx>
0025 #include <Standard_PCharacter.hxx>
0026 #include <Standard_PExtCharacter.hxx>
0027 #include <Standard_OStream.hxx>
0028
0029 #define Standard_GUID_SIZE 36
0030 #define Standard_GUID_SIZE_ALLOC Standard_GUID_SIZE + 1
0031
0032 class Standard_GUID
0033 {
0034 public:
0035   DEFINE_STANDARD_ALLOC
0036
0037   //! Creates a GUID with all zeros.
0038   constexpr Standard_GUID() noexcept
0039       : my32b(0),
0040         my16b1(0),
0041         my16b2(0),
0042         my16b3(0),
0043         my8b1(0),
0044         my8b2(0),
0045         my8b3(0),
0046         my8b4(0),
0047         my8b5(0),
0048         my8b6(0)
0049   {
0050   }
0051
0052   //! build a GUID from an ascii string with the
0053   //! following format:
0054   //! Length : 36 char
0055   //! "00000000-0000-0000-0000-000000000000"
0056   Standard_EXPORT Standard_GUID(const char* const aGuid);
0057
0058   //! build a GUID from an unicode string with the
0059   //! following format:
0060   //!
0061   //! "00000000-0000-0000-0000-000000000000"
0062   Standard_EXPORT Standard_GUID(const char16_t* const aGuid);
0063
0064   //! Creates a GUID from the given components.
0065   constexpr Standard_GUID(const int      a32b,
0066                           const char16_t a16b1,
0067                           const char16_t a16b2,
0068                           const char16_t a16b3,
0069                           const uint8_t  a8b1,
0070                           const uint8_t  a8b2,
0071                           const uint8_t  a8b3,
0072                           const uint8_t  a8b4,
0073                           const uint8_t  a8b5,
0074                           const uint8_t  a8b6) noexcept
0075       : my32b(a32b),
0076         my16b1(a16b1),
0077         my16b2(a16b2),
0078         my16b3(a16b3),
0079         my8b1(a8b1),
0080         my8b2(a8b2),
0081         my8b3(a8b3),
0082         my8b4(a8b4),
0083         my8b5(a8b5),
0084         my8b6(a8b6)
0085   {
0086   }
0087
0088   //! Creates a GUID from a Standard_UUID.
0089   constexpr Standard_GUID(const Standard_UUID& theUUID) noexcept
0090       : my32b(theUUID.Data1),
0091         my16b1(theUUID.Data2),
0092         my16b2(theUUID.Data3),
0093         my16b3(static_cast<char16_t>((theUUID.Data4[0] << 8) | theUUID.Data4[1])),
0094         my8b1(theUUID.Data4[2]),
0095         my8b2(theUUID.Data4[3]),
0096         my8b3(theUUID.Data4[4]),
0097         my8b4(theUUID.Data4[5]),
0098         my8b5(theUUID.Data4[6]),
0099         my8b6(theUUID.Data4[7])
0100   {
0101   }
0102
0103   //! Copy constructor.
0104   constexpr Standard_GUID(const Standard_GUID& theGuid) noexcept = default;
0105
0106   //! translate the GUID into ascii string
0107   //! the aStrGuid is allocated by user.
0108   //! the guid have the following format:
0109   //!
0110   //! "00000000-0000-0000-0000-000000000000"
0111   Standard_EXPORT void ToCString(const Standard_PCharacter aStrGuid) const;
0112
0113   //! translate the GUID into unicode string
0114   //! the aStrGuid is allocated by user.
0115   //! the guid have the following format:
0116   //!
0117   //! "00000000-0000-0000-0000-000000000000"
0118   Standard_EXPORT void ToExtString(const Standard_PExtCharacter aStrGuid) const;
0119
0120   //! Converts to Standard_UUID.
0121   constexpr Standard_UUID ToUUID() const noexcept
0122   {
0123     return Standard_UUID{static_cast<uint32_t>(my32b),
0124                          static_cast<uint16_t>(my16b1),
0125                          static_cast<uint16_t>(my16b2),
0126                          {static_cast<uint8_t>((my16b3 >> 8) & 0xFF),
0127                           static_cast<uint8_t>(my16b3 & 0xFF),
0128                           my8b1,
0129                           my8b2,
0130                           my8b3,
0131                           my8b4,
0132                           my8b5,
0133                           my8b6}};
0134   }
0135
0136   //! Returns true if this GUID is equal to uid.
0137   constexpr bool IsSame(const Standard_GUID& uid) const noexcept
0138   {
0139     return my32b == uid.my32b && my16b1 == uid.my16b1 && my16b2 == uid.my16b2
0140            && my16b3 == uid.my16b3 && my8b1 == uid.my8b1 && my8b2 == uid.my8b2 && my8b3 == uid.my8b3
0141            && my8b4 == uid.my8b4 && my8b5 == uid.my8b5 && my8b6 == uid.my8b6;
0142   }
0143
0144   constexpr bool operator==(const Standard_GUID& uid) const noexcept { return IsSame(uid); }
0145
0146   //! Returns true if this GUID is not equal to uid.
0147   constexpr bool IsNotSame(const Standard_GUID& uid) const noexcept { return !IsSame(uid); }
0148
0149   constexpr bool operator!=(const Standard_GUID& uid) const noexcept { return IsNotSame(uid); }
0150
0151   //! Assigns uid to this GUID.
0152   constexpr void Assign(const Standard_GUID& uid) noexcept
0153   {
0154     my32b  = uid.my32b;
0155     my16b1 = uid.my16b1;
0156     my16b2 = uid.my16b2;
0157     my16b3 = uid.my16b3;
0158     my8b1  = uid.my8b1;
0159     my8b2  = uid.my8b2;
0160     my8b3  = uid.my8b3;
0161     my8b4  = uid.my8b4;
0162     my8b5  = uid.my8b5;
0163     my8b6  = uid.my8b6;
0164   }
0165
0166   constexpr Standard_GUID& operator=(const Standard_GUID& uid) noexcept
0167   {
0168     Assign(uid);
0169     return *this;
0170   }
0171
0172   //! Assigns uid to this GUID.
0173   constexpr void Assign(const Standard_UUID& uid) noexcept
0174   {
0175     my32b  = uid.Data1;
0176     my16b1 = uid.Data2;
0177     my16b2 = uid.Data3;
0178     my16b3 = static_cast<char16_t>((uid.Data4[0] << 8) | uid.Data4[1]);
0179     my8b1  = uid.Data4[2];
0180     my8b2  = uid.Data4[3];
0181     my8b3  = uid.Data4[4];
0182     my8b4  = uid.Data4[5];
0183     my8b5  = uid.Data4[6];
0184     my8b6  = uid.Data4[7];
0185   }
0186
0187   constexpr Standard_GUID& operator=(const Standard_UUID& uid) noexcept
0188   {
0189     Assign(uid);
0190     return *this;
0191   }
0192
0193   //! Display the GUID with the following format:
0194   //!
0195   //! "00000000-0000-0000-0000-000000000000"
0196   Standard_EXPORT void ShallowDump(Standard_OStream& aStream) const;
0197
0198   //! Check the format of a GUID string.
0199   //! It checks the size, the position of the '-' and the correct size of fields.
0200   Standard_EXPORT static bool CheckGUIDFormat(const char* const aGuid);
0201
0202   template <class T>
0203   friend struct std::hash;
0204
0205 private:
0206   int      my32b;
0207   char16_t my16b1;
0208   char16_t my16b2;
0209   char16_t my16b3;
0210   uint8_t  my8b1;
0211   uint8_t  my8b2;
0212   uint8_t  my8b3;
0213   uint8_t  my8b4;
0214   uint8_t  my8b5;
0215   uint8_t  my8b6;
0216 };
0217
0218 namespace std
0219 {
0220 template <>
0221 struct hash<Standard_GUID>
0222 {
0223   size_t operator()(const Standard_GUID& theGUID) const noexcept
0224   {
0225     struct GUID
0226     {
0227       int      my32b;
0228       char16_t my16b1;
0229       char16_t my16b2;
0230       char16_t my16b3;
0231       uint8_t  my8b1;
0232       uint8_t  my8b2;
0233       uint8_t  my8b3;
0234       uint8_t  my8b4;
0235       uint8_t  my8b5;
0236       uint8_t  my8b6;
0237     };
0238
0239     GUID aGUID{theGUID.my32b,
0240                theGUID.my16b1,
0241                theGUID.my16b2,
0242                theGUID.my16b3,
0243                theGUID.my8b1,
0244                theGUID.my8b2,
0245                theGUID.my8b3,
0246                theGUID.my8b4,
0247                theGUID.my8b5,
0248                theGUID.my8b6};
0249     return opencascade::hashBytes(&aGUID, sizeof(GUID));
0250   }
0251 };
0252 } // namespace std
0253
0254 #endif // _Standard_GUID_HeaderFile