LCOV - code coverage report
Current view: top level - tools/source/ref - globname.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 208 0.0 %
Date: 2014-04-14 Functions: 0 19 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <ctype.h>
      21             : #include <stdio.h>
      22             : #include <string.h>
      23             : 
      24             : #include <rtl/strbuf.hxx>
      25             : 
      26             : #include <tools/stream.hxx>
      27             : #include <tools/globname.hxx>
      28             : 
      29             : // ImpSvGlobalName ------------------------------------------------------------
      30             : 
      31           0 : ImpSvGlobalName::ImpSvGlobalName( const ImpSvGlobalName & rObj )
      32             : {
      33           0 :     nRefCount = 0;
      34           0 :     memcpy( szData, rObj.szData, sizeof( szData ) );
      35           0 : }
      36             : 
      37           0 : ImpSvGlobalName::ImpSvGlobalName( Empty )
      38             : {
      39           0 :     nRefCount = 1;
      40           0 :     memset( szData, 0, sizeof( szData ) );
      41           0 : }
      42             : 
      43           0 : bool ImpSvGlobalName::operator == ( const ImpSvGlobalName & rObj ) const
      44             : {
      45           0 :     return !memcmp( szData, rObj.szData, sizeof( szData ) );
      46             : }
      47             : 
      48             : // SvGlobalName ----------------------------------------------------------------
      49             : 
      50           0 : SvGlobalName::SvGlobalName()
      51             : {
      52           0 :     static ImpSvGlobalName aNoName( ImpSvGlobalName::EMPTY );
      53             : 
      54           0 :     pImp = &aNoName;
      55           0 :     pImp->nRefCount++;
      56           0 : }
      57             : 
      58             : #ifdef WNT
      59             : struct _GUID
      60             : #else
      61             : struct GUID
      62             : #endif
      63             : {
      64             :     sal_uInt32 Data1;
      65             :     sal_uInt16 Data2;
      66             :     sal_uInt16 Data3;
      67             :     sal_uInt8  Data4[8];
      68             : };
      69           0 : SvGlobalName::SvGlobalName( const CLSID & rId )
      70             : {
      71           0 :     pImp = new ImpSvGlobalName();
      72           0 :     pImp->nRefCount++;
      73           0 :     memcpy( pImp->szData, &rId, sizeof( pImp->szData ) );
      74           0 : }
      75             : 
      76           0 : SvGlobalName::SvGlobalName( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3,
      77             :                             sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11,
      78             :                             sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 )
      79             : {
      80           0 :     pImp = new ImpSvGlobalName();
      81           0 :     pImp->nRefCount++;
      82             : 
      83           0 :     memcpy(pImp->szData, &n1, sizeof(n1));
      84           0 :     memcpy(pImp->szData+4, &n2, sizeof(n2));
      85           0 :     memcpy(pImp->szData+6, &n3, sizeof(n3));
      86           0 :     pImp->szData[ 8  ] = b8;
      87           0 :     pImp->szData[ 9  ] = b9;
      88           0 :     pImp->szData[ 10 ] = b10;
      89           0 :     pImp->szData[ 11 ] = b11;
      90           0 :     pImp->szData[ 12 ] = b12;
      91           0 :     pImp->szData[ 13 ] = b13;
      92           0 :     pImp->szData[ 14 ] = b14;
      93           0 :     pImp->szData[ 15 ] = b15;
      94           0 : }
      95             : 
      96           0 : SvGlobalName::~SvGlobalName()
      97             : {
      98           0 :     pImp->nRefCount--;
      99           0 :     if( !pImp->nRefCount )
     100           0 :         delete pImp;
     101           0 : }
     102             : 
     103           0 : SvGlobalName & SvGlobalName::operator = ( const SvGlobalName & rObj )
     104             : {
     105           0 :     rObj.pImp->nRefCount++;
     106           0 :     pImp->nRefCount--;
     107           0 :     if( !pImp->nRefCount )
     108           0 :         delete pImp;
     109           0 :     pImp = rObj.pImp;
     110           0 :     return *this;
     111             : }
     112             : 
     113           0 : void SvGlobalName::NewImp()
     114             : {
     115           0 :     if( pImp->nRefCount > 1 )
     116             :     {
     117           0 :         pImp->nRefCount--;
     118           0 :         pImp = new ImpSvGlobalName( *pImp );
     119           0 :         pImp->nRefCount++;
     120             :     }
     121           0 : }
     122             : 
     123           0 : SvStream& WriteSvGlobalName( SvStream& rOStr, const SvGlobalName & rObj )
     124             : {
     125             :     sal_uInt32 a;
     126           0 :     memcpy(&a, rObj.pImp->szData, sizeof(sal_uInt32));
     127           0 :     rOStr.WriteUInt32( a );
     128             : 
     129             :     sal_uInt16 b;
     130           0 :     memcpy(&b, rObj.pImp->szData+4, sizeof(sal_uInt16));
     131           0 :     rOStr.WriteUInt16( b );
     132             : 
     133           0 :     memcpy(&b, rObj.pImp->szData+6, sizeof(sal_uInt16));
     134           0 :     rOStr.WriteUInt16( b );
     135             : 
     136           0 :     rOStr.Write( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 );
     137           0 :     return rOStr;
     138             : }
     139             : 
     140           0 : SvStream& operator >> ( SvStream& rStr, SvGlobalName & rObj )
     141             : {
     142           0 :     rObj.NewImp(); // copy if necessary
     143             : 
     144             :     sal_uInt32 a;
     145           0 :     rStr.ReadUInt32( a );
     146           0 :     memcpy(rObj.pImp->szData, &a, sizeof(sal_uInt32));
     147             : 
     148             :     sal_uInt16 b;
     149           0 :     rStr.ReadUInt16( b );
     150           0 :     memcpy(rObj.pImp->szData+4, &b, sizeof(sal_uInt16));
     151             : 
     152           0 :     rStr.ReadUInt16( b );
     153           0 :     memcpy(rObj.pImp->szData+6, &b, sizeof(sal_uInt16));
     154             : 
     155           0 :     rStr.Read( (sal_Char *)&rObj.pImp->szData[ 8 ], 8 );
     156           0 :     return rStr;
     157             : }
     158             : 
     159             : 
     160           0 : bool SvGlobalName::operator < ( const SvGlobalName & rObj ) const
     161             : {
     162           0 :     int n = memcmp( pImp->szData +6, rObj.pImp->szData +6,
     163           0 :                     sizeof( pImp->szData ) -6);
     164           0 :     if( n < 0 )
     165           0 :         return true;
     166           0 :     else if( n > 0 )
     167           0 :         return false;
     168             : 
     169             :     sal_uInt16 Data2_a;
     170           0 :     memcpy(&Data2_a, pImp->szData+4, sizeof(sal_uInt16));
     171             : 
     172             :     sal_uInt16 Data2_b;
     173           0 :     memcpy(&Data2_b, rObj.pImp->szData+4, sizeof(sal_uInt16));
     174             : 
     175           0 :     if( Data2_a < Data2_b )
     176           0 :         return true;
     177           0 :     else if( Data2_a == Data2_b )
     178             :     {
     179             :         sal_uInt32 Data1_a;
     180           0 :         memcpy(&Data1_a, pImp->szData, sizeof(sal_uInt32));
     181             : 
     182             :         sal_uInt32 Data1_b;
     183           0 :         memcpy(&Data1_b, rObj.pImp->szData, sizeof(sal_uInt32));
     184             : 
     185           0 :         return Data1_a  < Data1_b;
     186             :     }
     187             :     else
     188           0 :         return false;
     189             : 
     190             : }
     191             : 
     192           0 : SvGlobalName & SvGlobalName::operator += ( sal_uInt32 n )
     193             : {
     194           0 :     NewImp();
     195             : 
     196             :     sal_uInt32 nOld;
     197           0 :     memcpy(&nOld, pImp->szData, sizeof(sal_uInt32));
     198           0 :     sal_uInt32 nNew = nOld + n;
     199           0 :     memcpy(pImp->szData, &nNew, sizeof(sal_uInt32));
     200             : 
     201           0 :     if( nOld > nNew )
     202             :     {
     203             :         // overflow
     204             :         sal_uInt16 Data2;
     205           0 :         memcpy(&Data2, pImp->szData + 4, sizeof(sal_uInt16));
     206           0 :         ++Data2;
     207           0 :         memcpy(pImp->szData + 4, &Data2, sizeof(sal_uInt16));
     208             :     }
     209           0 :     return *this;
     210             : }
     211             : 
     212           0 : bool SvGlobalName::operator == ( const SvGlobalName & rObj ) const
     213             : {
     214           0 :     return *pImp == *rObj.pImp;
     215             : }
     216             : 
     217           0 : void SvGlobalName::MakeFromMemory( void * pData )
     218             : {
     219           0 :     NewImp();
     220           0 :     memcpy( pImp->szData, pData, sizeof( pImp->szData ) );
     221           0 : }
     222             : 
     223           0 : bool SvGlobalName::MakeId( const OUString & rIdStr )
     224             : {
     225             :     OString aStr(OUStringToOString(rIdStr,
     226           0 :         RTL_TEXTENCODING_ASCII_US));
     227           0 :     const sal_Char *pStr = aStr.getStr();
     228           0 :     if( rIdStr.getLength() == 36
     229           0 :       && '-' == pStr[ 8 ]  && '-' == pStr[ 13 ]
     230           0 :       && '-' == pStr[ 18 ] && '-' == pStr[ 23 ] )
     231             :     {
     232           0 :         sal_uInt32 nFirst = 0;
     233           0 :         int i = 0;
     234           0 :         for( i = 0; i < 8; i++ )
     235             :         {
     236           0 :             if( isxdigit( *pStr ) )
     237           0 :                 if( isdigit( *pStr ) )
     238           0 :                     nFirst = nFirst * 16 + (*pStr - '0');
     239             :                 else
     240           0 :                     nFirst = nFirst * 16 + (toupper( *pStr ) - 'A' + 10 );
     241             :             else
     242           0 :                 return false;
     243           0 :             pStr++;
     244             :         }
     245             : 
     246           0 :         sal_uInt16 nSec = 0;
     247           0 :         pStr++;
     248           0 :         for( i = 0; i < 4; i++ )
     249             :         {
     250           0 :             if( isxdigit( *pStr ) )
     251           0 :                 if( isdigit( *pStr ) )
     252           0 :                     nSec = nSec * 16 + (*pStr - '0');
     253             :                 else
     254           0 :                     nSec = nSec * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 );
     255             :             else
     256           0 :                 return false;
     257           0 :             pStr++;
     258             :         }
     259             : 
     260           0 :         sal_uInt16 nThird = 0;
     261           0 :         pStr++;
     262           0 :         for( i = 0; i < 4; i++ )
     263             :         {
     264           0 :             if( isxdigit( *pStr ) )
     265           0 :                 if( isdigit( *pStr ) )
     266           0 :                     nThird = nThird * 16 + (*pStr - '0');
     267             :                 else
     268           0 :                     nThird = nThird * 16 + (sal_uInt16)(toupper( *pStr ) - 'A' + 10 );
     269             :             else
     270           0 :                 return false;
     271           0 :             pStr++;
     272             :         }
     273             : 
     274             :         sal_Int8 szRemain[ 8 ];
     275           0 :         memset( szRemain, 0, sizeof( szRemain ) );
     276           0 :         pStr++;
     277           0 :         for( i = 0; i < 16; i++ )
     278             :         {
     279           0 :             if( isxdigit( *pStr ) )
     280           0 :                 if( isdigit( *pStr ) )
     281           0 :                     szRemain[i/2] = szRemain[i/2] * 16 + (*pStr - '0');
     282             :                 else
     283           0 :                     szRemain[i/2] = szRemain[i/2] * 16 + (sal_Int8)(toupper( *pStr ) - 'A' + 10 );
     284             :             else
     285           0 :                 return false;
     286           0 :             pStr++;
     287           0 :             if( i == 3 )
     288           0 :                 pStr++;
     289             :         }
     290             : 
     291           0 :         NewImp();
     292           0 :         memcpy(&pImp->szData[0], &nFirst, sizeof(nFirst));
     293           0 :         memcpy(&pImp->szData[4], &nSec, sizeof(nSec));
     294           0 :         memcpy(&pImp->szData[6], &nThird, sizeof(nThird));
     295           0 :         memcpy(&pImp->szData[ 8 ], szRemain, 8);
     296           0 :         return true;
     297             :     }
     298           0 :     return false;
     299             : }
     300             : 
     301           0 : OUString SvGlobalName::GetHexName() const
     302             : {
     303           0 :     OStringBuffer aHexBuffer;
     304             : 
     305             :     sal_Char buf[ 10 ];
     306             :     sal_uInt32 Data1;
     307           0 :     memcpy(&Data1, pImp->szData, sizeof(sal_uInt32));
     308           0 :     sprintf( buf, "%8.8" SAL_PRIXUINT32, Data1 );
     309           0 :     aHexBuffer.append(buf);
     310           0 :     aHexBuffer.append('-');
     311             :     sal_uInt16 i ;
     312           0 :     for( i = 4; i < 8; i += 2 )
     313             :     {
     314             :         sal_uInt16 Data2;
     315           0 :         memcpy(&Data2, pImp->szData+i, sizeof(sal_uInt16));
     316           0 :         sprintf( buf, "%4.4X", Data2 );
     317           0 :         aHexBuffer.append(buf);
     318           0 :         aHexBuffer.append('-');
     319             :     }
     320           0 :     for( i = 8; i < 10; i++ )
     321             :     {
     322           0 :         sprintf( buf, "%2.2x", pImp->szData[ i ] );
     323           0 :         aHexBuffer.append(buf);
     324             :     }
     325           0 :     aHexBuffer.append('-');
     326           0 :     for( i = 10; i < 16; i++ )
     327             :     {
     328           0 :         sprintf( buf, "%2.2x", pImp->szData[ i ] );
     329           0 :         aHexBuffer.append(buf);
     330             :     }
     331           0 :     return OStringToOUString(aHexBuffer.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US);
     332             : }
     333             : 
     334           0 : com::sun::star::uno::Sequence < sal_Int8 > SvGlobalName::GetByteSequence() const
     335             : {
     336             :     // platform independent representation of a "GlobalName"
     337             :     // maybe transported remotely
     338           0 :     com::sun::star::uno::Sequence< sal_Int8 > aResult( 16 );
     339             : 
     340             :     sal_uInt32 Data1;
     341           0 :     memcpy(&Data1, pImp->szData, sizeof(sal_uInt32));
     342           0 :     aResult[0] = (sal_Int8) (Data1 >> 24);
     343           0 :     aResult[1] = (sal_Int8) ((Data1 << 8 ) >> 24);
     344           0 :     aResult[2] = (sal_Int8) ((Data1 << 16 ) >> 24);
     345           0 :     aResult[3] = (sal_Int8) ((Data1 << 24 ) >> 24);
     346             :     sal_uInt16 Data2;
     347           0 :     memcpy(&Data2, pImp->szData+4, sizeof(sal_uInt16));
     348           0 :     aResult[4] = (sal_Int8) (Data2 >> 8);
     349           0 :     aResult[5] = (sal_Int8) ((Data2 << 8 ) >> 8);
     350             :     sal_uInt16 Data3;
     351           0 :     memcpy(&Data3, pImp->szData+6, sizeof(sal_uInt16));
     352           0 :     aResult[6] = (sal_Int8) (Data3 >> 8);
     353           0 :     aResult[7] = (sal_Int8) ((Data3 << 8 ) >> 8);
     354           0 :     aResult[8] = pImp->szData[ 8 ];
     355           0 :     aResult[9] = pImp->szData[ 9 ];
     356           0 :     aResult[10] = pImp->szData[ 10 ];
     357           0 :     aResult[11] = pImp->szData[ 11 ];
     358           0 :     aResult[12] = pImp->szData[ 12 ];
     359           0 :     aResult[13] = pImp->szData[ 13 ];
     360           0 :     aResult[14] = pImp->szData[ 14 ];
     361           0 :     aResult[15] = pImp->szData[ 15 ];
     362             : 
     363           0 :     return aResult;
     364             : }
     365             : 
     366           0 : SvGlobalName::SvGlobalName( const com::sun::star::uno::Sequence < sal_Int8 >& aSeq )
     367             : {
     368             :     // create SvGlobalName from a platform independent representation
     369             :     GUID aResult;
     370           0 :     memset( &aResult, 0, sizeof( aResult ) );
     371           0 :     if ( aSeq.getLength() == 16 )
     372             :     {
     373           0 :         aResult.Data1 = ( ( ( ( ( ( sal_uInt8 )aSeq[0] << 8 ) + ( sal_uInt8 )aSeq[1] ) << 8 ) + ( sal_uInt8 )aSeq[2] ) << 8 ) + ( sal_uInt8 )aSeq[3];
     374           0 :         aResult.Data2 = ( ( sal_uInt8 )aSeq[4] << 8 ) + ( sal_uInt8 )aSeq[5];
     375           0 :         aResult.Data3 = ( ( sal_uInt8 )aSeq[6] << 8 ) + ( sal_uInt8 )aSeq[7];
     376           0 :         for( int nInd = 0; nInd < 8; nInd++ )
     377           0 :             aResult.Data4[nInd] = ( sal_uInt8 )aSeq[nInd+8];
     378             :     }
     379             : 
     380           0 :     pImp = new ImpSvGlobalName();
     381           0 :     pImp->nRefCount++;
     382           0 :     memcpy( pImp->szData, &aResult, sizeof( pImp->szData ) );
     383           0 : }
     384             : 
     385             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10