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

// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.


#include <Standard_GUID.hxx>
#include <Standard_IStream.hxx>
#include <Standard_RangeError.hxx>

#include <stdio.h>

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

//=======================================================================
//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++;}

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

  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);
  }
  else return NULL;
  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);
  }
  else return NULL;
//  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;

  if(!CheckGUIDFormat(tmpBuffer)) Standard_RangeError::Raise("Invalid format of GUID");

  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");
  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';

  if(!CheckGUIDFormat(tmpBuffer)) Standard_RangeError::Raise("Invalid format of GUID");

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