lluuid.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:9k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lluuid.h
  3.  *
  4.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2000-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  31. #ifndef LL_LLUUID_H
  32. #define LL_LLUUID_H
  33. #include <iostream>
  34. #include <set>
  35. #include "stdtypes.h"
  36. #include "llpreprocessor.h"
  37. const S32 UUID_BYTES = 16;
  38. const S32 UUID_WORDS = 4;
  39. const S32 UUID_STR_LENGTH = 37; // actually wrong, should be 36 and use size below
  40. const S32 UUID_STR_SIZE = 37;
  41. const S32 UUID_BASE85_LENGTH = 21; // including the trailing NULL.
  42. struct uuid_time_t {
  43. U32 high;
  44. U32 low;
  45. };
  46. class LL_COMMON_API LLUUID
  47. {
  48. public:
  49. //
  50. // CREATORS
  51. //
  52. LLUUID();
  53. explicit LLUUID(const char *in_string); // Convert from string.
  54. explicit LLUUID(const std::string& in_string); // Convert from string.
  55. LLUUID(const LLUUID &in);
  56. LLUUID &operator=(const LLUUID &rhs);
  57. ~LLUUID();
  58. //
  59. // MANIPULATORS
  60. //
  61. void generate(); // Generate a new UUID
  62. void generate(const std::string& stream); //Generate a new UUID based on hash of input stream
  63. static LLUUID generateNewID(std::string stream = ""); //static version of above for use in initializer expressions such as constructor params, etc. 
  64. BOOL set(const char *in_string, BOOL emit = TRUE); // Convert from string, if emit is FALSE, do not emit warnings
  65. BOOL set(const std::string& in_string, BOOL emit = TRUE); // Convert from string, if emit is FALSE, do not emit warnings
  66. void setNull(); // Faster than setting to LLUUID::null.
  67.     S32     cmpTime(uuid_time_t *t1, uuid_time_t *t2);
  68. static void    getSystemTime(uuid_time_t *timestamp);
  69. void    getCurrentTime(uuid_time_t *timestamp);
  70. //
  71. // ACCESSORS
  72. //
  73. BOOL isNull() const; // Faster than comparing to LLUUID::null.
  74. BOOL notNull() const; // Faster than comparing to LLUUID::null.
  75. // JC: This is dangerous.  It allows UUIDs to be cast automatically
  76. // to integers, among other things.  Use isNull() or notNull().
  77. // operator bool() const;
  78. // JC: These must return real bool's (not BOOLs) or else use of the STL
  79. // will generate bool-to-int performance warnings.
  80. bool operator==(const LLUUID &rhs) const;
  81. bool operator!=(const LLUUID &rhs) const;
  82. bool operator<(const LLUUID &rhs) const;
  83. bool operator>(const LLUUID &rhs) const;
  84. // xor functions. Useful since any two random uuids xored together
  85. // will yield a determinate third random unique id that can be
  86. // used as a key in a single uuid that represents 2.
  87. const LLUUID& operator^=(const LLUUID& rhs);
  88. LLUUID operator^(const LLUUID& rhs) const;
  89. // similar to functions above, but not invertible
  90. // yields a third random UUID that can be reproduced from the two inputs
  91. // but which, given the result and one of the inputs can't be used to
  92. // deduce the other input
  93. LLUUID combine(const LLUUID& other) const;
  94. void combine(const LLUUID& other, LLUUID& result) const;  
  95. friend LL_COMMON_API std::ostream&  operator<<(std::ostream& s, const LLUUID &uuid);
  96. friend LL_COMMON_API std::istream&  operator>>(std::istream& s, LLUUID &uuid);
  97. void toString(char *out) const; // Does not allocate memory, needs 36 characters (including )
  98. void toString(std::string& out) const;
  99. void toCompressedString(char *out) const; // Does not allocate memory, needs 17 characters (including )
  100. void toCompressedString(std::string& out) const;
  101. std::string asString() const;
  102. std::string getString() const;
  103. U16 getCRC16() const;
  104. U32 getCRC32() const;
  105. static BOOL validate(const std::string& in_string); // Validate that the UUID string is legal.
  106. static const LLUUID null;
  107. static U32 getRandomSeed();
  108. static S32 getNodeID(unsigned char * node_id);
  109. static BOOL parseUUID(const std::string& buf, LLUUID* value);
  110. U8 mData[UUID_BYTES];
  111. };
  112. // Construct
  113. inline LLUUID::LLUUID()
  114. {
  115. setNull();
  116. }
  117. // Faster than copying from memory
  118. inline void LLUUID::setNull()
  119. {
  120. U32 *word = (U32 *)mData;
  121. word[0] = 0;
  122. word[1] = 0;
  123. word[2] = 0;
  124. word[3] = 0;
  125. }
  126. // Compare
  127. inline bool LLUUID::operator==(const LLUUID& rhs) const
  128. {
  129. U32 *tmp = (U32 *)mData;
  130. U32 *rhstmp = (U32 *)rhs.mData;
  131. // Note: binary & to avoid branching
  132. return 
  133. (tmp[0] == rhstmp[0]) &  
  134. (tmp[1] == rhstmp[1]) &
  135. (tmp[2] == rhstmp[2]) &
  136. (tmp[3] == rhstmp[3]);
  137. }
  138. inline bool LLUUID::operator!=(const LLUUID& rhs) const
  139. {
  140. U32 *tmp = (U32 *)mData;
  141. U32 *rhstmp = (U32 *)rhs.mData;
  142. // Note: binary | to avoid branching
  143. return 
  144. (tmp[0] != rhstmp[0]) |
  145. (tmp[1] != rhstmp[1]) |
  146. (tmp[2] != rhstmp[2]) |
  147. (tmp[3] != rhstmp[3]);
  148. }
  149. /*
  150. // JC: This is dangerous.  It allows UUIDs to be cast automatically
  151. // to integers, among other things.  Use isNull() or notNull().
  152. inline LLUUID::operator bool() const
  153. {
  154. U32 *word = (U32 *)mData;
  155. return (word[0] | word[1] | word[2] | word[3]) > 0;
  156. }
  157. */
  158. inline BOOL LLUUID::notNull() const
  159. {
  160. U32 *word = (U32 *)mData;
  161. return (word[0] | word[1] | word[2] | word[3]) > 0;
  162. }
  163. // Faster than == LLUUID::null because doesn't require
  164. // as much memory access.
  165. inline BOOL LLUUID::isNull() const
  166. {
  167. U32 *word = (U32 *)mData;
  168. // If all bits are zero, return !0 == TRUE
  169. return !(word[0] | word[1] | word[2] | word[3]);
  170. }
  171. // Copy constructor
  172. inline LLUUID::LLUUID(const LLUUID& rhs)
  173. {
  174. U32 *tmp = (U32 *)mData;
  175. U32 *rhstmp = (U32 *)rhs.mData;
  176. tmp[0] = rhstmp[0];
  177. tmp[1] = rhstmp[1];
  178. tmp[2] = rhstmp[2];
  179. tmp[3] = rhstmp[3];
  180. }
  181. inline LLUUID::~LLUUID()
  182. {
  183. }
  184. // Assignment
  185. inline LLUUID& LLUUID::operator=(const LLUUID& rhs)
  186. {
  187. // No need to check the case where this==&rhs.  The branch is slower than the write.
  188. U32 *tmp = (U32 *)mData;
  189. U32 *rhstmp = (U32 *)rhs.mData;
  190. tmp[0] = rhstmp[0];
  191. tmp[1] = rhstmp[1];
  192. tmp[2] = rhstmp[2];
  193. tmp[3] = rhstmp[3];
  194. return *this;
  195. }
  196. inline LLUUID::LLUUID(const char *in_string)
  197. {
  198. if (!in_string || in_string[0] == 0)
  199. {
  200. setNull();
  201. return;
  202. }
  203.  
  204. set(in_string);
  205. }
  206. inline LLUUID::LLUUID(const std::string& in_string)
  207. {
  208. if (in_string.empty())
  209. {
  210. setNull();
  211. return;
  212. }
  213. set(in_string);
  214. }
  215. // IW: DON'T "optimize" these w/ U32s or you'll scoogie the sort order
  216. // IW: this will make me very sad
  217. inline bool LLUUID::operator<(const LLUUID &rhs) const
  218. {
  219. U32 i;
  220. for( i = 0; i < (UUID_BYTES - 1); i++ )
  221. {
  222. if( mData[i] != rhs.mData[i] )
  223. {
  224. return (mData[i] < rhs.mData[i]);
  225. }
  226. }
  227. return (mData[UUID_BYTES - 1] < rhs.mData[UUID_BYTES - 1]);
  228. }
  229. inline bool LLUUID::operator>(const LLUUID &rhs) const
  230. {
  231. U32 i;
  232. for( i = 0; i < (UUID_BYTES - 1); i++ )
  233. {
  234. if( mData[i] != rhs.mData[i] )
  235. {
  236. return (mData[i] > rhs.mData[i]);
  237. }
  238. }
  239. return (mData[UUID_BYTES - 1] > rhs.mData[UUID_BYTES - 1]);
  240. }
  241. inline U16 LLUUID::getCRC16() const
  242. {
  243. // A UUID is 16 bytes, or 8 shorts.
  244. U16 *short_data = (U16*)mData;
  245. U16 out = 0;
  246. out += short_data[0];
  247. out += short_data[1];
  248. out += short_data[2];
  249. out += short_data[3];
  250. out += short_data[4];
  251. out += short_data[5];
  252. out += short_data[6];
  253. out += short_data[7];
  254. return out;
  255. }
  256. inline U32 LLUUID::getCRC32() const
  257. {
  258. U32 *tmp = (U32*)mData;
  259. return tmp[0] + tmp[1] + tmp[2] + tmp[3];
  260. }
  261. // Helper structure for ordering lluuids in stl containers.
  262. // eg:  std::map<LLUUID, LLWidget*, lluuid_less> widget_map;
  263. struct lluuid_less
  264. {
  265. bool operator()(const LLUUID& lhs, const LLUUID& rhs) const
  266. {
  267. return (lhs < rhs) ? true : false;
  268. }
  269. };
  270. typedef std::set<LLUUID, lluuid_less> uuid_list_t;
  271. /*
  272.  * Sub-classes for keeping transaction IDs and asset IDs
  273.  * straight.
  274.  */
  275. typedef LLUUID LLAssetID;
  276. class LL_COMMON_API LLTransactionID : public LLUUID
  277. {
  278. public:
  279. LLTransactionID() : LLUUID() { }
  280. static const LLTransactionID tnull;
  281. LLAssetID makeAssetID(const LLUUID& session) const;
  282. };
  283. #endif