[occt.git] / src / Standard / Standard_GUID.cxx

#include <Standard_GUID.ixx>
#include <Standard_RangeError.hxx>
#include <Standard_IStream.hxx>
#include <stdio.h>

#define Standard_GUID_SIZE 36
#define Standard_GUID_SIZE_ALLOC Standard_GUID_SIZE+1

//Fixes incorrect treatment of GUID given as a string with invalid format
#define OCC669 

//=======================================================================
//function : Standard_GUID_MatchChar
//purpose  : 
//=======================================================================
Standard_Integer Standard_GUID_MatchChar(const Standard_CString buffer, 
					 const Standard_Character aChar)
{
  Standard_CString tmpbuffer = buffer;
  Standard_Integer result    = -1;

  while(*tmpbuffer != '\0' && *tmpbuffer != aChar) {tmpbuffer++; result++;}

#ifdef OCC669
  if(*tmpbuffer == '\0') return -1; //The searched symbol wasn't found
#endif 

  if (result >= 0) result++;

  return result;
}
//=======================================================================
//function : Standard_GUID_GetValue32
//purpose  : 
//=======================================================================
Standard_PCharacter Standard_GUID_GetValue32(Standard_PCharacter tmpBuffer, 
					     Standard_Integer& my32b) 
{
  Standard_Character strtmp[Standard_GUID_SIZE_ALLOC];
  Standard_Integer   pos = 0;

  pos = Standard_GUID_MatchChar(tmpBuffer,'-');
  if (pos >= 0) {
    strncpy(strtmp,tmpBuffer,pos);
    strtmp[pos] = '\0';
    my32b = (Standard_Integer) strtoul(strtmp, (char **)NULL, 16);
  }
#ifdef OCC669
  else return NULL;
#endif 
  return &tmpBuffer[pos+1];
}
//=======================================================================
//function : Standard_GUID_GetValue16
//purpose  : 
//=======================================================================
Standard_PCharacter Standard_GUID_GetValue16(Standard_PCharacter tmpBuffer, 
					     Standard_ExtCharacter& my32b) 
{
  Standard_Character strtmp[Standard_GUID_SIZE_ALLOC];
  Standard_Integer   pos = 0;

  pos = Standard_GUID_MatchChar(tmpBuffer,'-');
  if (pos >= 0) {
    strncpy(strtmp,tmpBuffer,pos);
    strtmp[pos] = '\0';
    my32b = (Standard_ExtCharacter) strtoul(strtmp, (char **)NULL, 16);
  }
#ifdef OCC669
  else return NULL;
#endif 
//  cout << "V16 :" << hex(my32b) << endl;
  return &tmpBuffer[pos+1];
}
//=======================================================================
//function : Standard_GUID_GetValue8
//purpose  : 
//=======================================================================
Standard_PCharacter Standard_GUID_GetValue8(Standard_PCharacter tmpBuffer, 
					    Standard_Byte& my32b) 
{
  Standard_Character strtmp[Standard_GUID_SIZE_ALLOC];

  strncpy(strtmp,tmpBuffer,2);
  strtmp[2] = '\0';
  my32b = (Standard_Byte) strtoul(strtmp, (char **)NULL, 16);
//  cout << "V8 :" << hex(my32b) << endl;
  return &tmpBuffer[2];
}
//=======================================================================
//function : CheckGUIDFormat
//purpose  : 
//=======================================================================
Standard_Boolean Standard_GUID::CheckGUIDFormat(const Standard_CString aGuid)
{
  Standard_Boolean result = Standard_True;

  if (aGuid == NULL) return Standard_False;

  if (strlen(aGuid) == Standard_GUID_SIZE) {
    Standard_Integer i;

    for (i = 0; i < 8 && result; i++) {
      if (!IsXDigit(aGuid[i])) {
	return Standard_False;
      }
    }

    if (aGuid[8] != '-') return Standard_False;

    for (i = 9; i < 13 && result; i++) {
      if (!IsXDigit(aGuid[i])) {
	return Standard_False;
      }
    }

    if (aGuid[13] != '-') return Standard_False;
    
    for (i = 14; i < 18 && result; i++) {
      if (!IsXDigit(aGuid[i])) {
	return Standard_False;
      }
    }

    if (aGuid[18] != '-') return Standard_False;

    for (i = 19; i < 23; i++) {
      if (!IsXDigit(aGuid[i])) {
	return Standard_False;
      }
    }

    if (aGuid[23] != '-') return Standard_False;

    for (i = 24; i < 36; i++) {
      if (!IsXDigit(aGuid[i])) {
	return Standard_False;
      }
    }
  }
  else result = Standard_False;

  return result;
}

Standard_GUID::Standard_GUID() 
: my32b ( 0),
  my16b1 ( 0),
  my16b2 ( 0),
  my16b3 ( 0),
  my8b1 ( 0),
  my8b2 ( 0),
  my8b3 ( 0),
  my8b4 ( 0),
  my8b5 ( 0),
  my8b6 ( 0)
{
}

Standard_GUID::Standard_GUID(const Standard_CString aGuid) 
: my32b ( 0),
  my16b1 ( 0),
  my16b2 ( 0),
  my16b3 ( 0),
  my8b1 ( 0),
  my8b2 ( 0),
  my8b3 ( 0),
  my8b4 ( 0),
  my8b5 ( 0),
  my8b6 ( 0)
{
  char* tmpBuffer =(char*) aGuid;

#ifdef OCC669 
  if(!CheckGUIDFormat(tmpBuffer)) Standard_RangeError::Raise("Invalid format of GUID");
#endif 

#ifdef  OCC669
  if((tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
  if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
  if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
  if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
#else
  tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b);
  tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1);
  tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2);
  tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3);
#endif 
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b1);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b2);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b3);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b4);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b5);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b6);
}

Standard_GUID::Standard_GUID(const Standard_ExtString aGuid) 
: my32b ( 0),
  my16b1 ( 0),
  my16b2 ( 0),
  my16b3 ( 0),
  my8b1 ( 0),
  my8b2 ( 0),
  my8b3 ( 0),
  my8b4 ( 0),
  my8b5 ( 0),
  my8b6 ( 0)
{ 
  char tpb[Standard_GUID_SIZE_ALLOC];
  char *tmpBuffer = tpb;
  Standard_Integer   i = 0;
  while(i < Standard_GUID_SIZE) {
    tmpBuffer[i] = (char ) aGuid[i];
    i++;
  }

  tmpBuffer[i] = '\0';

#ifdef OCC669
  if(!CheckGUIDFormat(tmpBuffer)) Standard_RangeError::Raise("Invalid format of GUID");
#endif 

#ifdef  OCC669
  if((tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
  if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
  if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
  if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3)) == NULL) 
    Standard_RangeError::Raise("Invalid format of GUID");
#else
  tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b);
  tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1);
  tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2);
  tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3);
#endif 
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b1);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b2);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b3);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b4);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b5);
  tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b6);
}

Standard_GUID::Standard_GUID(const Standard_Integer a32b,
	const Standard_ExtCharacter a16b1,
	const Standard_ExtCharacter a16b2,
	const Standard_ExtCharacter a16b3,
	const Standard_Byte a8b1,
	const Standard_Byte a8b2,
	const Standard_Byte a8b3,
	const Standard_Byte a8b4,
	const Standard_Byte a8b5,
	const Standard_Byte a8b6)
{
	my32b = a32b;
	my16b1 = a16b1;
	 my16b2 = a16b2;
	 my16b3 = a16b3;
	 my8b1 = a8b1;
	 my8b2 = a8b2;
	 my8b3 = a8b3;
	 my8b4 = a8b4;
	 my8b5 = a8b5;
	 my8b6 = a8b6;
}

Standard_GUID::Standard_GUID(const Standard_GUID& aGuid)
{
	 my32b  = aGuid.my32b;
	 my16b1 = aGuid.my16b1;
	 my16b2 = aGuid.my16b2;
	 my16b3 = aGuid.my16b3;
	 my8b1  = aGuid.my8b1;
	 my8b2  = aGuid.my8b2;
	 my8b3  = aGuid.my8b3;
	 my8b4  = aGuid.my8b4;
	 my8b5  = aGuid.my8b5;
	 my8b6  = aGuid.my8b6;
}
Standard_GUID::Standard_GUID(const Standard_UUID& aWntGuid)
{
	 my32b  = aWntGuid.Data1;
	 my16b1 = aWntGuid.Data2;
	 my16b2 = aWntGuid.Data3;
	 my16b3 = (aWntGuid.Data4[0] << 8) | (aWntGuid.Data4[1]) ;
	 my8b1  = aWntGuid.Data4[2] ;
	 my8b2  = aWntGuid.Data4[3] ;
	 my8b3  = aWntGuid.Data4[4] ;
	 my8b4  = aWntGuid.Data4[5] ;
	 my8b5  = aWntGuid.Data4[6] ;
	 my8b6  = aWntGuid.Data4[7] ;
}

//=======================================================================
//function : ToCString
//purpose  : 
//=======================================================================
void Standard_GUID::ToCString(const Standard_PCharacter aStrGuid) const
{
  sprintf(aStrGuid,"%.8x-%.4x-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x",
	  my32b,
	  (unsigned short) my16b1,
	  (unsigned short) my16b2,
	  (unsigned short) my16b3,
	  (unsigned char)my8b1,
	  (unsigned char)my8b2,
	  (unsigned char)my8b3,
	  (unsigned char)my8b4,
	  (unsigned char)my8b5,
	  (unsigned char)my8b6);
}

//=======================================================================
//function : ToExtString
//purpose  : 
//=======================================================================
void Standard_GUID::ToExtString(const Standard_PExtCharacter aStrGuid) const
{
  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
  ToCString(sguid);

  for(Standard_Integer i = 0; i < Standard_GUID_SIZE; i++) {
    aStrGuid[i] = (Standard_ExtCharacter)sguid[i];
  }

  aStrGuid[Standard_GUID_SIZE] = (Standard_ExtCharacter)0;
}

Standard_UUID Standard_GUID::ToUUID() const
{
  Standard_UUID result ;

  result.Data1 = my32b ;
  result.Data2 = my16b1 ;
  result.Data3 = my16b2 ;
  result.Data4[0] = my16b3 >> 8 ;
  result.Data4[1] = (char ) my16b3 ;
  result.Data4[2] = my8b1 ;
  result.Data4[3] = my8b2 ;
  result.Data4[4] = my8b3 ;
  result.Data4[5] = my8b4 ;
  result.Data4[6] = my8b5 ;
  result.Data4[7] = my8b6 ;
  return result ;
}       

Standard_Boolean Standard_GUID::IsSame(const Standard_GUID& uid) const
{
  Standard_Boolean result = Standard_True;

  if (my32b  != uid.my32b) result = Standard_False;
  else if (my16b1 != uid.my16b1) result = Standard_False;
  else if (my16b2 != uid.my16b2) result = Standard_False;
  else if (my16b3 != uid.my16b3) result = Standard_False;
  else if (my8b1  != uid.my8b1) result = Standard_False;
  else if (my8b2  != uid.my8b2) result = Standard_False;
  else if (my8b3  != uid.my8b3) result = Standard_False;
  else if (my8b4  != uid.my8b4) result = Standard_False;
  else if (my8b5  != uid.my8b5) result = Standard_False;
  else if (my8b6  != uid.my8b6) result = Standard_False;

  return result;
}

Standard_Boolean Standard_GUID::IsNotSame(const Standard_GUID& uid) const
{
  return !IsSame(uid);
}

void Standard_GUID::Assign(const Standard_GUID& uid) 
{
  my32b  = uid.my32b;
  my16b1 = uid.my16b1;
  my16b2 = uid.my16b2;
  my16b3 = uid.my16b3;
  my8b1  = uid.my8b1;
  my8b2  = uid.my8b2;
  my8b3  = uid.my8b3;
  my8b4  = uid.my8b4;
  my8b5  = uid.my8b5;
  my8b6  = uid.my8b6;
}

void Standard_GUID::ShallowDump(Standard_OStream& aStream) const
{
  Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
  ToCString(sguid);
  aStream << sguid;
}

Standard_Integer Standard_GUID::HashCode(const Standard_GUID& aGuid,const Standard_Integer Upper)
{
  return aGuid.Hash(Upper);
}

Standard_Integer Standard_GUID::Hash(const Standard_Integer Upper) const
{
  if (Upper < 1){
    Standard_RangeError::
      Raise("Standard_GUID::Hash: Try to apply HashCode method with negative or null argument.");
  }

  char sguid[Standard_GUID_SIZE_ALLOC];
  ToCString(sguid);

  return ::HashCode(sguid,Upper);
}

Standard_Boolean Standard_GUID::IsEqual(const Standard_GUID& aGuid1,const Standard_GUID& aGuid2)
{
  return (aGuid1 == aGuid2);
}
Commit	Line	Data
7fd59977	1	#include <Standard_GUID.ixx>
	2	#include <Standard_RangeError.hxx>
	3	#include <Standard_IStream.hxx>
	4	#include <stdio.h>
	5
	6	#define Standard_GUID_SIZE 36
	7	#define Standard_GUID_SIZE_ALLOC Standard_GUID_SIZE+1
	8
	9	//Fixes incorrect treatment of GUID given as a string with invalid format
	10	#define OCC669
	11
	12	//=======================================================================
	13	//function : Standard_GUID_MatchChar
	14	//purpose :
	15	//=======================================================================
	16	Standard_Integer Standard_GUID_MatchChar(const Standard_CString buffer,
	17	const Standard_Character aChar)
	18	{
	19	Standard_CString tmpbuffer = buffer;
	20	Standard_Integer result = -1;
	21
	22	while(tmpbuffer != '\0' && tmpbuffer != aChar) {tmpbuffer++; result++;}
	23
	24	#ifdef OCC669
	25	if(*tmpbuffer == '\0') return -1; //The searched symbol wasn't found
	26	#endif
	27
	28	if (result >= 0) result++;
	29
	30	return result;
	31	}
	32	//=======================================================================
	33	//function : Standard_GUID_GetValue32
	34	//purpose :
	35	//=======================================================================
	36	Standard_PCharacter Standard_GUID_GetValue32(Standard_PCharacter tmpBuffer,
	37	Standard_Integer& my32b)
	38	{
	39	Standard_Character strtmp[Standard_GUID_SIZE_ALLOC];
	40	Standard_Integer pos = 0;
	41
	42	pos = Standard_GUID_MatchChar(tmpBuffer,'-');
	43	if (pos >= 0) {
	44	strncpy(strtmp,tmpBuffer,pos);
	45	strtmp[pos] = '\0';
	46	my32b = (Standard_Integer) strtoul(strtmp, (char **)NULL, 16);
	47	}
	48	#ifdef OCC669
	49	else return NULL;
	50	#endif
	51	return &tmpBuffer[pos+1];
	52	}
	53	//=======================================================================
	54	//function : Standard_GUID_GetValue16
	55	//purpose :
	56	//=======================================================================
	57	Standard_PCharacter Standard_GUID_GetValue16(Standard_PCharacter tmpBuffer,
	58	Standard_ExtCharacter& my32b)
	59	{
	60	Standard_Character strtmp[Standard_GUID_SIZE_ALLOC];
	61	Standard_Integer pos = 0;
	62
	63	pos = Standard_GUID_MatchChar(tmpBuffer,'-');
	64	if (pos >= 0) {
65	strncpy(strtmp,tmpBuffer,pos);
66	strtmp[pos] = '\0';
67	my32b = (Standard_ExtCharacter) strtoul(strtmp, (char **)NULL, 16);
68	}
69	#ifdef OCC669
70	else return NULL;
71	#endif
72	// cout << "V16 :" << hex(my32b) << endl;
73	return &tmpBuffer[pos+1];
74	}
75	//=======================================================================
76	//function : Standard_GUID_GetValue8
77	//purpose :
78	//=======================================================================
79	Standard_PCharacter Standard_GUID_GetValue8(Standard_PCharacter tmpBuffer,
80	Standard_Byte& my32b)
81	{
82	Standard_Character strtmp[Standard_GUID_SIZE_ALLOC];
83
84	strncpy(strtmp,tmpBuffer,2);
85	strtmp[2] = '\0';
86	my32b = (Standard_Byte) strtoul(strtmp, (char **)NULL, 16);
87	// cout << "V8 :" << hex(my32b) << endl;
88	return &tmpBuffer[2];
89	}
90	//=======================================================================
91	//function : CheckGUIDFormat
92	//purpose :
93	//=======================================================================
94	Standard_Boolean Standard_GUID::CheckGUIDFormat(const Standard_CString aGuid)
95	{
96	Standard_Boolean result = Standard_True;
97
98	if (aGuid == NULL) return Standard_False;
99
100	if (strlen(aGuid) == Standard_GUID_SIZE) {
101	Standard_Integer i;
102
103	for (i = 0; i < 8 && result; i++) {
104	if (!IsXDigit(aGuid[i])) {
105	return Standard_False;
106	}
107	}
108
109	if (aGuid[8] != '-') return Standard_False;
110
111	for (i = 9; i < 13 && result; i++) {
112	if (!IsXDigit(aGuid[i])) {
113	return Standard_False;
114	}
115	}
116
117	if (aGuid[13] != '-') return Standard_False;
118
119	for (i = 14; i < 18 && result; i++) {
120	if (!IsXDigit(aGuid[i])) {
121	return Standard_False;
122	}
123	}
124
125	if (aGuid[18] != '-') return Standard_False;
126
127	for (i = 19; i < 23; i++) {
128	if (!IsXDigit(aGuid[i])) {
129	return Standard_False;
130	}
131	}
132
133	if (aGuid[23] != '-') return Standard_False;
134
135	for (i = 24; i < 36; i++) {
136	if (!IsXDigit(aGuid[i])) {
137	return Standard_False;
138	}
139	}
140	}
141	else result = Standard_False;
142
143	return result;
144	}
145
146	Standard_GUID::Standard_GUID()
147	: my32b ( 0),
148	my16b1 ( 0),
149	my16b2 ( 0),
150	my16b3 ( 0),
151	my8b1 ( 0),
152	my8b2 ( 0),
153	my8b3 ( 0),
154	my8b4 ( 0),
155	my8b5 ( 0),
156	my8b6 ( 0)
157	{
158	}
159
160	Standard_GUID::Standard_GUID(const Standard_CString aGuid)
161	: my32b ( 0),
162	my16b1 ( 0),
163	my16b2 ( 0),
164	my16b3 ( 0),
165	my8b1 ( 0),
166	my8b2 ( 0),
167	my8b3 ( 0),
168	my8b4 ( 0),
169	my8b5 ( 0),
170	my8b6 ( 0)
171	{
172	char* tmpBuffer =(char*) aGuid;
173
174	#ifdef OCC669
175	if(!CheckGUIDFormat(tmpBuffer)) Standard_RangeError::Raise("Invalid format of GUID");
176	#endif
177
178	#ifdef OCC669
179	if((tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b)) == NULL)
180	Standard_RangeError::Raise("Invalid format of GUID");
181	if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1)) == NULL)
182	Standard_RangeError::Raise("Invalid format of GUID");
183	if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2)) == NULL)
184	Standard_RangeError::Raise("Invalid format of GUID");
185	if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3)) == NULL)
186	Standard_RangeError::Raise("Invalid format of GUID");
187	#else
188	tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b);
189	tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1);
190	tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2);
191	tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3);
192	#endif
193	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b1);
194	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b2);
195	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b3);
196	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b4);
197	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b5);
198	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b6);
199	}
200
201	Standard_GUID::Standard_GUID(const Standard_ExtString aGuid)
202	: my32b ( 0),
203	my16b1 ( 0),
204	my16b2 ( 0),
205	my16b3 ( 0),
206	my8b1 ( 0),
207	my8b2 ( 0),
208	my8b3 ( 0),
209	my8b4 ( 0),
210	my8b5 ( 0),
211	my8b6 ( 0)
212	{
6b09c923 R	213	char tpb[Standard_GUID_SIZE_ALLOC];
6b09c923 R	214	char *tmpBuffer = tpb;
7fd59977	215	Standard_Integer i = 0;
7fd59977	216	while(i < Standard_GUID_SIZE) {
	217	tmpBuffer[i] = (char ) aGuid[i];
	218	i++;
	219	}
	220
	221	tmpBuffer[i] = '\0';
	222
	223	#ifdef OCC669
	224	if(!CheckGUIDFormat(tmpBuffer)) Standard_RangeError::Raise("Invalid format of GUID");
	225	#endif
	226
	227	#ifdef OCC669
	228	if((tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b)) == NULL)
	229	Standard_RangeError::Raise("Invalid format of GUID");
	230	if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1)) == NULL)
	231	Standard_RangeError::Raise("Invalid format of GUID");
	232	if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2)) == NULL)
	233	Standard_RangeError::Raise("Invalid format of GUID");
	234	if((tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3)) == NULL)
	235	Standard_RangeError::Raise("Invalid format of GUID");
	236	#else
	237	tmpBuffer = Standard_GUID_GetValue32(tmpBuffer,my32b);
	238	tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b1);
	239	tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b2);
	240	tmpBuffer = Standard_GUID_GetValue16(tmpBuffer,my16b3);
	241	#endif
	242	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b1);
	243	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b2);
	244	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b3);
	245	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b4);
	246	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b5);
	247	tmpBuffer = Standard_GUID_GetValue8(tmpBuffer,my8b6);
	248	}
	249
	250	Standard_GUID::Standard_GUID(const Standard_Integer a32b,
	251	const Standard_ExtCharacter a16b1,
	252	const Standard_ExtCharacter a16b2,
	253	const Standard_ExtCharacter a16b3,
	254	const Standard_Byte a8b1,
	255	const Standard_Byte a8b2,
	256	const Standard_Byte a8b3,
	257	const Standard_Byte a8b4,
	258	const Standard_Byte a8b5,
	259	const Standard_Byte a8b6)
	260	{
	261	my32b = a32b;
	262	my16b1 = a16b1;
	263	my16b2 = a16b2;
	264	my16b3 = a16b3;
	265	my8b1 = a8b1;
	266	my8b2 = a8b2;
	267	my8b3 = a8b3;
	268	my8b4 = a8b4;
	269	my8b5 = a8b5;
	270	my8b6 = a8b6;
	271	}
	272
	273	Standard_GUID::Standard_GUID(const Standard_GUID& aGuid)
	274	{
	275	my32b = aGuid.my32b;
	276	my16b1 = aGuid.my16b1;
	277	my16b2 = aGuid.my16b2;
	278	my16b3 = aGuid.my16b3;
	279	my8b1 = aGuid.my8b1;
280	my8b2 = aGuid.my8b2;
281	my8b3 = aGuid.my8b3;
282	my8b4 = aGuid.my8b4;
283	my8b5 = aGuid.my8b5;
284	my8b6 = aGuid.my8b6;
285	}
286	Standard_GUID::Standard_GUID(const Standard_UUID& aWntGuid)
287	{
288	my32b = aWntGuid.Data1;
289	my16b1 = aWntGuid.Data2;
290	my16b2 = aWntGuid.Data3;
291	my16b3 = (aWntGuid.Data4[0] << 8) \| (aWntGuid.Data4[1]) ;
292	my8b1 = aWntGuid.Data4[2] ;
293	my8b2 = aWntGuid.Data4[3] ;
294	my8b3 = aWntGuid.Data4[4] ;
295	my8b4 = aWntGuid.Data4[5] ;
296	my8b5 = aWntGuid.Data4[6] ;
297	my8b6 = aWntGuid.Data4[7] ;
298	}
299
300	//=======================================================================
301	//function : ToCString
302	//purpose :
303	//=======================================================================
304	void Standard_GUID::ToCString(const Standard_PCharacter aStrGuid) const
305	{
306	sprintf(aStrGuid,"%.8x-%.4x-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x",
307	my32b,
308	(unsigned short) my16b1,
309	(unsigned short) my16b2,
310	(unsigned short) my16b3,
311	(unsigned char)my8b1,
312	(unsigned char)my8b2,
313	(unsigned char)my8b3,
314	(unsigned char)my8b4,
315	(unsigned char)my8b5,
316	(unsigned char)my8b6);
317	}
318
319	//=======================================================================
320	//function : ToExtString
321	//purpose :
322	//=======================================================================
323	void Standard_GUID::ToExtString(const Standard_PExtCharacter aStrGuid) const
324	{
325	Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
6b09c923	326	ToCString(sguid);
7fd59977	327
6b09c923	328	for(Standard_Integer i = 0; i < Standard_GUID_SIZE; i++) {
7fd59977	329	aStrGuid[i] = (Standard_ExtCharacter)sguid[i];
	330	}
	331
	332	aStrGuid[Standard_GUID_SIZE] = (Standard_ExtCharacter)0;
	333	}
	334
	335	Standard_UUID Standard_GUID::ToUUID() const
	336	{
	337	Standard_UUID result ;
	338
	339	result.Data1 = my32b ;
	340	result.Data2 = my16b1 ;
	341	result.Data3 = my16b2 ;
	342	result.Data4[0] = my16b3 >> 8 ;
	343	result.Data4[1] = (char ) my16b3 ;
	344	result.Data4[2] = my8b1 ;
	345	result.Data4[3] = my8b2 ;
	346	result.Data4[4] = my8b3 ;
	347	result.Data4[5] = my8b4 ;
	348	result.Data4[6] = my8b5 ;
	349	result.Data4[7] = my8b6 ;
	350	return result ;
	351	}
	352
	353	Standard_Boolean Standard_GUID::IsSame(const Standard_GUID& uid) const
	354	{
	355	Standard_Boolean result = Standard_True;
	356
	357	if (my32b != uid.my32b) result = Standard_False;
	358	else if (my16b1 != uid.my16b1) result = Standard_False;
	359	else if (my16b2 != uid.my16b2) result = Standard_False;
	360	else if (my16b3 != uid.my16b3) result = Standard_False;
	361	else if (my8b1 != uid.my8b1) result = Standard_False;
	362	else if (my8b2 != uid.my8b2) result = Standard_False;
	363	else if (my8b3 != uid.my8b3) result = Standard_False;
	364	else if (my8b4 != uid.my8b4) result = Standard_False;
	365	else if (my8b5 != uid.my8b5) result = Standard_False;
	366	else if (my8b6 != uid.my8b6) result = Standard_False;
	367
	368	return result;
	369	}
	370
	371	Standard_Boolean Standard_GUID::IsNotSame(const Standard_GUID& uid) const
	372	{
	373	return !IsSame(uid);
	374	}
	375
	376	void Standard_GUID::Assign(const Standard_GUID& uid)
	377	{
	378	my32b = uid.my32b;
	379	my16b1 = uid.my16b1;
	380	my16b2 = uid.my16b2;
	381	my16b3 = uid.my16b3;
	382	my8b1 = uid.my8b1;
	383	my8b2 = uid.my8b2;
	384	my8b3 = uid.my8b3;
	385	my8b4 = uid.my8b4;
	386	my8b5 = uid.my8b5;
	387	my8b6 = uid.my8b6;
	388	}
	389
	390	void Standard_GUID::ShallowDump(Standard_OStream& aStream) const
	391	{
	392	Standard_Character sguid[Standard_GUID_SIZE_ALLOC];
6b09c923	393	ToCString(sguid);
7fd59977	394	aStream << sguid;
	395	}
	396
	397	Standard_Integer Standard_GUID::HashCode(const Standard_GUID& aGuid,const Standard_Integer Upper)
	398	{
6b09c923	399	return aGuid.Hash(Upper);
7fd59977	400	}
	401
	402	Standard_Integer Standard_GUID::Hash(const Standard_Integer Upper) const
	403	{
	404	if (Upper < 1){
	405	Standard_RangeError::
	406	Raise("Standard_GUID::Hash: Try to apply HashCode method with negative or null argument.");
	407	}
	408
6b09c923 R	409	char sguid[Standard_GUID_SIZE_ALLOC];
6b09c923 R	410	ToCString(sguid);
7fd59977	411
6b09c923	412	return ::HashCode(sguid,Upper);
7fd59977	413	}
	414
	415	Standard_Boolean Standard_GUID::IsEqual(const Standard_GUID& aGuid1,const Standard_GUID& aGuid2)
	416	{
	417	return (aGuid1 == aGuid2);
	418	}
	419