Sirikata
|
00001 /* Sirikata Utilities -- Sirikata Synchronization Utilities 00002 * UUID.hpp 00003 * 00004 * Copyright (c) 2009, Daniel Reiter Horn 00005 * All rights reserved. 00006 * 00007 * Redistribution and use in source and binary forms, with or without 00008 * modification, are permitted provided that the following conditions are 00009 * met: 00010 * * Redistributions of source code must retain the above copyright 00011 * notice, this list of conditions and the following disclaimer. 00012 * * Redistributions in binary form must reproduce the above copyright 00013 * notice, this list of conditions and the following disclaimer in 00014 * the documentation and/or other materials provided with the 00015 * distribution. 00016 * * Neither the name of Sirikata nor the names of its contributors may 00017 * be used to endorse or promote products derived from this software 00018 * without specific prior written permission. 00019 * 00020 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 00021 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 00022 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 00023 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 00024 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 00025 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 00026 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 00027 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 00028 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 00029 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 00030 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00031 */ 00032 00033 #ifndef _SIRIKATA_UUID_HPP_ 00034 #define _SIRIKATA_UUID_HPP_ 00035 00036 #include <sirikata/core/util/Platform.hpp> 00037 00038 namespace boost { 00039 namespace uuids { 00040 struct uuid; 00041 } 00042 } 00043 00044 namespace Sirikata { 00045 class SIRIKATA_EXPORT UUID : public TotallyOrdered<UUID> 00046 { 00047 public: 00048 enum {static_size=16}; 00049 typedef unsigned char byte; 00050 typedef Array<byte,static_size,true> Data; 00051 typedef Data::iterator iterator; 00052 typedef Data::const_iterator const_iterator; 00053 private: 00054 Data mData; 00055 public: 00056 UUID(const boost::uuids::uuid&); 00057 UUID() {} 00058 UUID (const byte *data, 00059 unsigned int length){ 00060 mData.memcpy(data,length); 00061 } 00062 UUID(const Data data):mData(data) { 00063 } 00064 static const UUID& null() { 00065 static unsigned char data[static_size]={0}; 00066 static UUID retval(data,static_size); 00067 return retval; 00068 } 00069 static const UUID& max() { 00070 static unsigned char data[static_size]= 00071 {255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}; 00072 static UUID retval(data,static_size); 00073 return retval; 00074 } 00078 class HumanReadable{}; 00079 class HexString{}; 00080 class BinaryString{}; 00081 UUID(const std::string&,HumanReadable); 00082 UUID(const std::string&,HexString); 00083 UUID(const std::string&s,BinaryString ){ 00084 mData.memcpy(s.data(),s.length()); 00085 } 00086 class GenerateRandom{}; 00087 UUID(GenerateRandom); 00088 00090 explicit UUID(const uint32 v); 00091 00092 static UUID random(); 00093 const Data& getArray()const{return mData;} 00094 UUID & operator=(const UUID & other) { mData = other.mData; return *this; } 00095 UUID & operator=(const Data & other) { mData = other; return *this; } 00096 bool operator<(const UUID &other)const {return mData < other.mData;} 00097 bool operator==(const UUID &other)const {return mData == other.mData;} 00098 bool isNull()const{return mData==Data::null();} 00099 size_t hash() const; 00100 class Hasher{public: 00101 size_t operator() (const UUID&uuid) const { 00102 return uuid.hash(); 00103 } 00104 }; 00105 class Null { 00106 public: 00107 const UUID& operator()() const { 00108 return UUID::null(); 00109 } 00110 }; 00111 class Random { 00112 public: 00113 UUID operator()() const { 00114 return UUID::random(); 00115 } 00116 }; 00117 std::string rawData()const; 00118 std::string rawHexData()const; 00119 std::string readableHexData()const; 00120 inline std::string toString()const { 00121 return readableHexData(); 00122 } 00123 00124 // These are accessor methods instead of cast because we can't currently 00125 // make casts explicit 00126 uint32 asUInt32() const; 00127 }; 00128 00129 template <> class OptionValueType<UUID> {public: 00130 static Any lexical_cast(const std::string &value){ 00131 return UUID(value,UUID::HumanReadable()); 00132 } 00133 }; 00134 00135 SIRIKATA_FUNCTION_EXPORT std::istream & operator>>(std::istream & is, Sirikata::UUID & uuid); 00136 SIRIKATA_FUNCTION_EXPORT std::ostream & operator<<(std::ostream & os, const Sirikata::UUID & uuid); 00137 } 00138 00139 #endif //_SIRIKATA_UUID_HPP_