xref: /aoo41x/main/tools/source/ref/globname.cxx (revision 79aad27f)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_tools.hxx"
26 
27 #include <ctype.h>
28 #include <stdio.h>
29 #include <string.h>
30 
31 #include <tools/stream.hxx>
32 #include <tools/globname.hxx>
33 
34 /************** class ImpSvGlobalName ************************************/
ImpSvGlobalName(const ImpSvGlobalName & rObj)35 ImpSvGlobalName::ImpSvGlobalName( const ImpSvGlobalName & rObj )
36 {
37 	nRefCount = 0;
38 	memcpy( szData, rObj.szData, sizeof( szData ) );
39 }
40 
41 /************** class ImpSvGlobalName ************************************/
ImpSvGlobalName(int)42 ImpSvGlobalName::ImpSvGlobalName( int )
43 {
44 	nRefCount = 1;
45 	memset( szData, 0, sizeof( szData ) );
46 }
47 
48 /*************************************************************************
49 |*	  ImpSvGlobalName::operator ==()
50 *************************************************************************/
operator ==(const ImpSvGlobalName & rObj) const51 sal_Bool ImpSvGlobalName::operator == ( const ImpSvGlobalName & rObj ) const
52 {
53 	return !memcmp( szData, rObj.szData, sizeof( szData ) );
54 }
55 
56 /*************************************************************************
57 |*	  SvGlobalName::SvGlobalName()
58 *************************************************************************/
SvGlobalName()59 SvGlobalName::SvGlobalName()
60 {
61 	static ImpSvGlobalName aNoName( 0 );
62 
63 	pImp = &aNoName;
64 	pImp->nRefCount++;
65 }
66 
67 // locker die Struktur von Windows kopiert
68 #ifdef WNT
69 struct _GUID
70 #else
71 struct GUID
72 #endif
73 {
74 	sal_uInt32 Data1;
75 	sal_uInt16 Data2;
76 	sal_uInt16 Data3;
77 	sal_uInt8  Data4[8];
78 };
SvGlobalName(const CLSID & rId)79 SvGlobalName::SvGlobalName( const CLSID & rId )
80 {
81 	pImp = new ImpSvGlobalName();
82 	pImp->nRefCount++;
83 	memcpy( pImp->szData, &rId, sizeof( pImp->szData ) );
84 }
85 
SvGlobalName(sal_uInt32 n1,sal_uInt16 n2,sal_uInt16 n3,sal_uInt8 b8,sal_uInt8 b9,sal_uInt8 b10,sal_uInt8 b11,sal_uInt8 b12,sal_uInt8 b13,sal_uInt8 b14,sal_uInt8 b15)86 SvGlobalName::SvGlobalName( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3,
87 							sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11,
88 							sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 )
89 {
90 	pImp = new ImpSvGlobalName();
91 	pImp->nRefCount++;
92 
93 	*(sal_uInt32 *)pImp->szData 	  = n1;
94 	*(sal_uInt16 *)&pImp->szData[ 4 ] = n2;
95 	*(sal_uInt16 *)&pImp->szData[ 6 ] = n3;
96 	pImp->szData[ 8  ] = b8;
97 	pImp->szData[ 9  ] = b9;
98 	pImp->szData[ 10 ] = b10;
99 	pImp->szData[ 11 ] = b11;
100 	pImp->szData[ 12 ] = b12;
101 	pImp->szData[ 13 ] = b13;
102 	pImp->szData[ 14 ] = b14;
103 	pImp->szData[ 15 ] = b15;
104 }
105 
106 /*************************************************************************
107 |*	  SvGlobalName::~SvGlobalName()
108 *************************************************************************/
~SvGlobalName()109 SvGlobalName::~SvGlobalName()
110 {
111 	pImp->nRefCount--;
112 	if( !pImp->nRefCount )
113 		delete pImp;
114 }
115 
116 /*************************************************************************
117 |*	  SvGlobalName::operator = ()
118 *************************************************************************/
operator =(const SvGlobalName & rObj)119 SvGlobalName & SvGlobalName::operator = ( const SvGlobalName & rObj )
120 {
121 	rObj.pImp->nRefCount++;
122 	pImp->nRefCount--;
123 	if( !pImp->nRefCount )
124 		delete pImp;
125 	pImp = rObj.pImp;
126 	return *this;
127 }
128 
129 /*************************************************************************
130 |*	  SvGlobalName::NewImp()
131 *************************************************************************/
NewImp()132 void SvGlobalName::NewImp()
133 {
134 	if( pImp->nRefCount > 1 )
135 	{
136 		pImp->nRefCount--;
137 		pImp = new ImpSvGlobalName( *pImp );
138 		pImp->nRefCount++;
139 	}
140 }
141 
142 /*************************************************************************
143 |*	  SvGlobalName::operator << ()
144 |*	  SvGlobalName::operator >> ()
145 *************************************************************************/
operator <<(SvStream & rOStr,const SvGlobalName & rObj)146 SvStream& operator << ( SvStream& rOStr, const SvGlobalName & rObj )
147 {
148 	rOStr << *(sal_uInt32 *)rObj.pImp->szData;
149 	rOStr << *(sal_uInt16 *)&rObj.pImp->szData[ 4 ];
150 	rOStr << *(sal_uInt16 *)&rObj.pImp->szData[ 6 ];
151 	rOStr.Write( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 );
152 	return rOStr;
153 }
154 
operator >>(SvStream & rStr,SvGlobalName & rObj)155 SvStream& operator >> ( SvStream& rStr, SvGlobalName & rObj )
156 {
157 	rObj.NewImp(); // kopieren, falls noetig
158 	rStr >> *(sal_uInt32 *)rObj.pImp->szData;
159 	rStr >> *(sal_uInt16 *)&rObj.pImp->szData[ 4 ];
160 	rStr >> *(sal_uInt16 *)&rObj.pImp->szData[ 6 ];
161 	rStr.Read( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 );
162 	return rStr;
163 }
164 
165 
166 /*************************************************************************
167 |*	  SvGlobalName::operator < ()
168 *************************************************************************/
operator <(const SvGlobalName & rObj) const169 sal_Bool SvGlobalName::operator < ( const SvGlobalName & rObj ) const
170 {
171 	int n = memcmp( pImp->szData +6, rObj.pImp->szData +6,
172 					sizeof( pImp->szData ) -6);
173 	if( n < 0 )
174 		return sal_True;
175 	else if( n > 0 )
176 		return sal_False;
177 	else if( *(sal_uInt16 *)&pImp->szData[ 4 ] < *(sal_uInt16 *)&rObj.pImp->szData[ 4 ] )
178 		return sal_True;
179 	else if( *(sal_uInt16 *)&pImp->szData[ 4 ] == *(sal_uInt16 *)&rObj.pImp->szData[ 4 ] )
180 		return *(sal_uInt32 *)pImp->szData	< *(sal_uInt32 *)rObj.pImp->szData;
181 	else
182 		return sal_False;
183 
184 }
185 
186 /*************************************************************************
187 |*	  SvGlobalName::operator +=()
188 *************************************************************************/
operator +=(sal_uInt32 n)189 SvGlobalName & SvGlobalName::operator += ( sal_uInt32 n )
190 {
191 	NewImp();
192 	sal_uInt32 nOld = (*(sal_uInt32 *)pImp->szData);
193 	(*(sal_uInt32 *)pImp->szData) += n;
194 	if( nOld > *(sal_uInt32 *)pImp->szData )
195 		// ueberlauf
196 		(*(sal_uInt16 *)&pImp->szData[ 4 ])++;
197 	return *this;
198 }
199 
200 /*************************************************************************
201 |*	  SvGlobalName::operator ==()
202 *************************************************************************/
operator ==(const SvGlobalName & rObj) const203 sal_Bool SvGlobalName::operator == ( const SvGlobalName & rObj ) const
204 {
205 	return *pImp == *rObj.pImp;
206 }
207 
MakeFromMemory(void * pData)208 void SvGlobalName::MakeFromMemory( void * pData )
209 {
210 	NewImp();
211 	memcpy( pImp->szData, pData, sizeof( pImp->szData ) );
212 }
213 
214 /*************************************************************************
215 |*	  SvGlobalName::MakeId()
216 *************************************************************************/
MakeId(const String & rIdStr)217 sal_Bool SvGlobalName::MakeId( const String & rIdStr )
218 {
219 	ByteString	aStr( rIdStr, RTL_TEXTENCODING_ASCII_US );
220 	sal_Char * pStr = (sal_Char *)aStr.GetBuffer();
221 	if( rIdStr.Len() == 36
222 	  && '-' == pStr[ 8 ]  && '-' == pStr[ 13 ]
223 	  && '-' == pStr[ 18 ] && '-' == pStr[ 23 ] )
224 	{
225 		sal_uInt32 nFirst = 0;
226 		int i = 0;
227 		for( i = 0; i < 8; i++ )
228 		{
229 			if( isxdigit( *pStr ) )
230 				if( isdigit( *pStr ) )
231 					nFirst = nFirst * 16 + (*pStr - '0');
232 				else
233 					nFirst = nFirst * 16 + (toupper( *pStr ) - 'A' + 10 );
234 			else
235 				return sal_False;
236 			pStr++;
237 		}
238 
239 		sal_uInt16 nSec = 0;
240 		pStr++;
241 		for( i = 0; i < 4; i++ )
242 		{
243 			if( isxdigit( *pStr ) )
244 				if( isdigit( *pStr ) )
245 					nSec = nSec * 16 + (*pStr - '0');
246 				else
247 					nSec = nSec * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 );
248 			else
249 				return sal_False;
250 			pStr++;
251 		}
252 
253 		sal_uInt16 nThird = 0;
254 		pStr++;
255 		for( i = 0; i < 4; i++ )
256 		{
257 			if( isxdigit( *pStr ) )
258 				if( isdigit( *pStr ) )
259 					nThird = nThird * 16 + (*pStr - '0');
260 				else
261 					nThird = nThird * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 );
262 			else
263 				return sal_False;
264 			pStr++;
265 		}
266 
267 		sal_Int8 szRemain[ 8 ];
268 		memset( szRemain, 0, sizeof( szRemain ) );
269 		pStr++;
270 		for( i = 0; i < 16; i++ )
271 		{
272 			if( isxdigit( *pStr ) )
273 				if( isdigit( *pStr ) )
274 					szRemain[i/2] = szRemain[i/2] * 16 + (*pStr - '0');
275 				else
276 					szRemain[i/2] = szRemain[i/2] * 16 + (sal_Int8)(toupper( *pStr ) - 'A' + 10 );
277 			else
278 				return sal_False;
279 			pStr++;
280 			if( i == 3 )
281 				pStr++;
282 		}
283 
284 		NewImp();
285 		*(sal_uInt32 *)pImp->szData 	  = nFirst;
286 		*(sal_uInt16 *)&pImp->szData[ 4 ] = nSec;
287 		*(sal_uInt16 *)&pImp->szData[ 6 ] = nThird;
288 		memcpy( &pImp->szData[ 8 ], szRemain, 8 );
289 		return sal_True;
290 	}
291 	return sal_False;
292 }
293 
294 /*************************************************************************
295 |*	  SvGlobalName::GetctorName()
296 *************************************************************************/
GetctorName() const297 String SvGlobalName::GetctorName() const
298 {
299 	ByteString aRet;
300 
301 	sal_Char buf[ 20 ];
302 	sprintf( buf, "0x%8.8lX", (sal_uIntPtr)*(sal_uInt32 *)pImp->szData );
303 	aRet += buf;
304 	sal_uInt16 i;
305 	for( i = 4; i < 8; i += 2 )
306 	{
307 		aRet += ',';
308 		sprintf( buf, "0x%4.4X", *(sal_uInt16 *)&pImp->szData[ i ] );
309 		aRet += buf;
310 	}
311 	for( i = 8; i < 16; i++ )
312 	{
313 		aRet += ',';
314 		sprintf( buf, "0x%2.2x", pImp->szData[ i ] );
315 		aRet += buf;
316 	}
317 	return String( aRet, RTL_TEXTENCODING_ASCII_US );
318 }
319 
320 /*************************************************************************
321 |*	  SvGlobalName::GetHexName()
322 *************************************************************************/
GetHexName() const323 String SvGlobalName::GetHexName() const
324 {
325 	ByteString aRet;
326 
327 	sal_Char buf[ 10 ];
328 	sprintf( buf, "%8.8lX", (sal_uIntPtr)*(sal_uInt32 *)pImp->szData );
329 	aRet += buf;
330 	aRet += '-';
331 	sal_uInt16 i ;
332 	for( i = 4; i < 8; i += 2 )
333 	{
334 		sprintf( buf, "%4.4X", *(sal_uInt16 *)&pImp->szData[ i ] );
335 		aRet += buf;
336 		aRet += '-';
337 	}
338 	for( i = 8; i < 10; i++ )
339 	{
340 		sprintf( buf, "%2.2x", pImp->szData[ i ] );
341 		aRet += buf;
342 	}
343 	aRet += '-';
344 	for( i = 10; i < 16; i++ )
345 	{
346 		sprintf( buf, "%2.2x", pImp->szData[ i ] );
347 		aRet += buf;
348 	}
349 	return String( aRet, RTL_TEXTENCODING_ASCII_US );
350 }
351 
352 /************** SvGlobalNameList ****************************************/
353 /************************************************************************/
354 /*************************************************************************
355 |*	  SvGlobalNameList::SvGlobalNameList()
356 *************************************************************************/
SvGlobalNameList()357 SvGlobalNameList::SvGlobalNameList()
358 	: aList( 1, 1 )
359 {
360 }
361 
362 /*************************************************************************
363 |*	  SvGlobalNameList::~SvGlobalNameList()
364 *************************************************************************/
~SvGlobalNameList()365 SvGlobalNameList::~SvGlobalNameList()
366 {
367 	for( sal_uIntPtr i = Count(); i > 0; i-- )
368 	{
369 		ImpSvGlobalName * pImp = (ImpSvGlobalName *)aList.GetObject( i -1 );
370 		pImp->nRefCount--;
371 		if( !pImp->nRefCount )
372 			delete pImp;
373 	}
374 }
375 
376 /*************************************************************************
377 |*	  SvGlobalNameList::Append()
378 *************************************************************************/
Append(const SvGlobalName & rName)379 void SvGlobalNameList::Append( const SvGlobalName & rName )
380 {
381 	rName.pImp->nRefCount++;
382 	aList.Insert( rName.pImp, LIST_APPEND );
383 }
384 
385 /*************************************************************************
386 |*	  SvGlobalNameList::GetObject()
387 *************************************************************************/
GetObject(sal_uLong nPos)388 SvGlobalName SvGlobalNameList::GetObject( sal_uLong nPos )
389 {
390 	return SvGlobalName( (ImpSvGlobalName *)aList.GetObject( nPos ) );
391 }
392 
393 /*************************************************************************
394 |*	  SvGlobalNameList::IsEntry()
395 *************************************************************************/
IsEntry(const SvGlobalName & rName)396 sal_Bool SvGlobalNameList::IsEntry( const SvGlobalName & rName )
397 {
398 	for( sal_uIntPtr i = Count(); i > 0; i-- )
399 	{
400 		if( *rName.pImp == *(ImpSvGlobalName *)aList.GetObject( i -1 ) )
401 			return sal_True;
402 	}
403 	return sal_False;
404 }
405 
GetByteSequence() const406 com::sun::star::uno::Sequence < sal_Int8 > SvGlobalName::GetByteSequence() const
407 {
408     // platform independent representation of a "GlobalName"
409     // maybe transported remotely
410     com::sun::star::uno::Sequence< sal_Int8 > aResult( 16 );
411 
412     aResult[0] = (sal_Int8) (*(sal_uInt32 *)pImp->szData >> 24);
413     aResult[1] = (sal_Int8) ((*(sal_uInt32 *)pImp->szData << 8 ) >> 24);
414     aResult[2] = (sal_Int8) ((*(sal_uInt32 *)pImp->szData << 16 ) >> 24);
415     aResult[3] = (sal_Int8) ((*(sal_uInt32 *)pImp->szData << 24 ) >> 24);
416     aResult[4] = (sal_Int8) (*(sal_uInt16 *)&pImp->szData[ 4 ] >> 8);
417     aResult[5] = (sal_Int8) ((*(sal_uInt16 *)&pImp->szData[ 4 ] << 8 ) >> 8);
418     aResult[6] = (sal_Int8) (*(sal_uInt16 *)&pImp->szData[ 6 ] >> 8);
419     aResult[7] = (sal_Int8) ((*(sal_uInt16 *)&pImp->szData[ 6 ] << 8 ) >> 8);
420     aResult[8] = pImp->szData[ 8 ];
421     aResult[9] = pImp->szData[ 9 ];
422     aResult[10] = pImp->szData[ 10 ];
423     aResult[11] = pImp->szData[ 11 ];
424     aResult[12] = pImp->szData[ 12 ];
425     aResult[13] = pImp->szData[ 13 ];
426     aResult[14] = pImp->szData[ 14 ];
427     aResult[15] = pImp->szData[ 15 ];
428 
429     return aResult;
430 }
431 
SvGlobalName(const com::sun::star::uno::Sequence<sal_Int8> & aSeq)432 SvGlobalName::SvGlobalName( const com::sun::star::uno::Sequence < sal_Int8 >& aSeq )
433 {
434     // create SvGlobalName from a platform independent representation
435     GUID aResult;
436     memset( &aResult, 0, sizeof( aResult ) );
437 	if ( aSeq.getLength() == 16 )
438 	{
439 		aResult.Data1 = ( ( ( ( ( ( sal_uInt8 )aSeq[0] << 8 ) + ( sal_uInt8 )aSeq[1] ) << 8 ) + ( sal_uInt8 )aSeq[2] ) << 8 ) + ( sal_uInt8 )aSeq[3];
440 		aResult.Data2 = ( ( sal_uInt8 )aSeq[4] << 8 ) + ( sal_uInt8 )aSeq[5];
441 		aResult.Data3 = ( ( sal_uInt8 )aSeq[6] << 8 ) + ( sal_uInt8 )aSeq[7];
442 		for( int nInd = 0; nInd < 8; nInd++ )
443 			aResult.Data4[nInd] = ( sal_uInt8 )aSeq[nInd+8];
444     }
445 
446 	pImp = new ImpSvGlobalName();
447 	pImp->nRefCount++;
448     memcpy( pImp->szData, &aResult, sizeof( pImp->szData ) );
449 }
450