sal/rtl/source/byteseq.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: byteseq.c,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <osl/diagnose.h>
  32 #include <osl/interlck.h>
  33
  34 #include <rtl/byteseq.h>
  35 #include <rtl/alloc.h>
  36 #include <rtl/memory.h>
  37
  38 /* static data to be referenced by all empty strings
  39  * the refCount is predefined to 1 and must never become 0 !
  40  */
  41 static sal_Sequence aEmpty_rtl_ByteSeq =
  42 {
  43     1,      /* sal_Int32    refCount;   */
  44     0,      /* sal_Int32    length;     */
  45     { 0 }   /* sal_Unicode  buffer[1];  */
  46 };
  47
  48 //==================================================================================================
  49 void SAL_CALL rtl_byte_sequence_reference2One(
  50     sal_Sequence ** ppSequence )
  51 {
  52     sal_Sequence * pSequence, * pNew;
  53     sal_Int32 nElements;
  54
  55     OSL_ENSURE( ppSequence, "### null ptr!" );
  56     pSequence = *ppSequence;
  57
  58     if (pSequence->nRefCount > 1)
  59     {
  60         nElements = pSequence->nElements;
  61         if (nElements)
  62         {
  63             pNew = (sal_Sequence *)rtl_allocateMemory( SAL_SEQUENCE_HEADER_SIZE + nElements );
  64
  65             if ( pNew != 0 )
  66                 rtl_copyMemory( pNew->elements, pSequence->elements, nElements );
  67
  68             if (! osl_decrementInterlockedCount( &pSequence->nRefCount ))
  69                 rtl_freeMemory( pSequence );
  70         }
  71         else
  72         {
  73             pNew = (sal_Sequence *)rtl_allocateMemory( SAL_SEQUENCE_HEADER_SIZE );
  74         }
  75
  76         if ( pNew != 0 )
  77         {
  78             pNew->nRefCount = 1;
  79             pNew->nElements = nElements;
  80         }
  81
  82         *ppSequence = pNew;
  83     }
  84 }
  85
  86 //==================================================================================================
  87 void SAL_CALL rtl_byte_sequence_realloc(
  88     sal_Sequence ** ppSequence, sal_Int32 nSize )
  89 {
  90     sal_Sequence * pSequence, * pNew;
  91     sal_Int32 nElements;
  92
  93     OSL_ENSURE( ppSequence, "### null ptr!" );
  94     pSequence = *ppSequence;
  95     nElements = pSequence->nElements;
  96
  97     if (nElements == nSize)
  98         return;
  99
 100     if (pSequence->nRefCount > 1) // split
 101     {
 102         pNew = (sal_Sequence *)rtl_allocateMemory( SAL_SEQUENCE_HEADER_SIZE + nSize );
 103
 104         if ( pNew != 0 )
 105         {
 106             if (nSize > nElements)
 107             {
 108                 rtl_copyMemory( pNew->elements, pSequence->elements, nElements );
 109                 rtl_zeroMemory( pNew->elements + nElements, nSize - nElements );
 110             }
 111             else
 112             {
 113                 rtl_copyMemory( pNew->elements, pSequence->elements, nSize );
 114             }
 115         }
 116
 117         if (! osl_decrementInterlockedCount( &pSequence->nRefCount ))
 118             rtl_freeMemory( pSequence );
 119         pSequence = pNew;
 120     }
 121     else
 122     {
 123         pSequence = (sal_Sequence *)rtl_reallocateMemory(
 124             pSequence, SAL_SEQUENCE_HEADER_SIZE + nSize );
 125     }
 126
 127     if ( pSequence != 0 )
 128     {
 129         pSequence->nRefCount = 1;
 130         pSequence->nElements = nSize;
 131     }
 132
 133     *ppSequence = pSequence;
 134 }
 135
 136 //==================================================================================================
 137 void SAL_CALL rtl_byte_sequence_acquire( sal_Sequence *pSequence )
 138 {
 139     OSL_ASSERT( pSequence );
 140     osl_incrementInterlockedCount( &(pSequence->nRefCount) );
 141 }
 142
 143 //==================================================================================================
 144 void SAL_CALL rtl_byte_sequence_release( sal_Sequence *pSequence )
 145 {
 146     if ( pSequence != 0 )
 147     {
 148         if (! osl_decrementInterlockedCount( &(pSequence->nRefCount )) )
 149         {
 150             rtl_freeMemory( pSequence );
 151         }
 152     }
 153 }
 154
 155 //==================================================================================================
 156 void SAL_CALL rtl_byte_sequence_construct( sal_Sequence **ppSequence , sal_Int32 nLength )
 157 {
 158     OSL_ASSERT( ppSequence );
 159     if( *ppSequence )
 160     {
 161         rtl_byte_sequence_release( *ppSequence );
 162         *ppSequence = 0;
 163     }
 164
 165     if( nLength )
 166     {
 167         *ppSequence = (sal_Sequence *) rtl_allocateZeroMemory( SAL_SEQUENCE_HEADER_SIZE + nLength );
 168
 169         if ( *ppSequence != 0 )
 170         {
 171             (*ppSequence)->nRefCount = 1;
 172             (*ppSequence)->nElements = nLength;
 173         }
 174     }
 175     else
 176     {
 177         *ppSequence = &aEmpty_rtl_ByteSeq;
 178         rtl_byte_sequence_acquire( *ppSequence );
 179     }
 180 }
 181
 182 //==================================================================================================
 183 void SAL_CALL rtl_byte_sequence_constructNoDefault(     sal_Sequence **ppSequence , sal_Int32 nLength )
 184 {
 185     OSL_ASSERT( ppSequence );
 186     if( *ppSequence )
 187     {
 188         rtl_byte_sequence_release( *ppSequence );
 189         *ppSequence = 0;
 190     }
 191
 192     *ppSequence = (sal_Sequence *) rtl_allocateMemory( SAL_SEQUENCE_HEADER_SIZE + nLength );
 193
 194     if ( *ppSequence != 0 )
 195     {
 196         (*ppSequence)->nRefCount = 1;
 197         (*ppSequence)->nElements = nLength;
 198     }
 199 }
 200
 201 //==================================================================================================
 202 void SAL_CALL rtl_byte_sequence_constructFromArray(
 203     sal_Sequence **ppSequence, const sal_Int8 *pData , sal_Int32 nLength )
 204 {
 205     rtl_byte_sequence_constructNoDefault( ppSequence , nLength );
 206     if ( *ppSequence != 0 )
 207         rtl_copyMemory( (*ppSequence)->elements, pData, nLength );
 208 }
 209
 210 //==================================================================================================
 211 void SAL_CALL rtl_byte_sequence_assign( sal_Sequence **ppSequence , sal_Sequence *pSequence )
 212 {
 213     if ( *ppSequence != pSequence)
 214     {
 215         if( *ppSequence )
 216         {
 217             rtl_byte_sequence_release( *ppSequence );
 218         }
 219         *ppSequence = pSequence;
 220         rtl_byte_sequence_acquire( *ppSequence );
 221     }
 222 //      else
 223 //      nothing to do
 224
 225 }
 226
 227 //==================================================================================================
 228 sal_Bool SAL_CALL rtl_byte_sequence_equals( sal_Sequence *pSequence1 , sal_Sequence *pSequence2 )
 229 {
 230     OSL_ASSERT( pSequence1 );
 231     OSL_ASSERT( pSequence2 );
 232     if (pSequence1 == pSequence2)
 233     {
 234         return sal_True;
 235     }
 236     if (pSequence1->nElements != pSequence2->nElements)
 237     {
 238         return sal_False;
 239     }
 240     return (sal_Bool)
 241         (rtl_compareMemory(
 242             pSequence1->elements, pSequence2->elements, pSequence1->nElements )
 243          == 0);
 244 }
 245
 246
 247 //==================================================================================================
 248 const sal_Int8 *SAL_CALL rtl_byte_sequence_getConstArray( sal_Sequence *pSequence )
 249 {
 250     return ((const sal_Int8*)(pSequence->elements));
 251 }
 252
 253 //==================================================================================================
 254 sal_Int32 SAL_CALL rtl_byte_sequence_getLength( sal_Sequence *pSequence )
 255 {
 256     return pSequence->nElements;
 257 }