sal/rtl/byteseq.cxx

   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 <assert.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23
  24 #include <osl/diagnose.h>
  25 #include <osl/interlck.h>
  26
  27 #include <rtl/byteseq.h>
  28
  29 /* static data to be referenced by all empty strings
  30  * the refCount is predefined to 1 and must never become 0 !
  31  */
  32 static sal_Sequence aEmpty_rtl_ByteSeq =
  33 {
  34     1,      /* sal_Int32    refCount;   */
  35     0,      /* sal_Int32    length;     */
  36     { 0 }   /* sal_Unicode  buffer[1];  */
  37 };
  38
  39 void SAL_CALL rtl_byte_sequence_reference2One(
  40     sal_Sequence ** ppSequence ) SAL_THROW_EXTERN_C()
  41 {
  42     sal_Sequence * pSequence;
  43
  44     OSL_ENSURE( ppSequence, "### null ptr!" );
  45     pSequence = *ppSequence;
  46
  47     if (pSequence->nRefCount > 1)
  48     {
  49         sal_Sequence *pNew;
  50         sal_Int32 nElements = pSequence->nElements;
  51         if (nElements)
  52         {
  53             pNew = static_cast<sal_Sequence *>(malloc( SAL_SEQUENCE_HEADER_SIZE + nElements ));
  54
  55             if ( pNew != nullptr )
  56                 memcpy( pNew->elements, pSequence->elements, nElements );
  57
  58             if (! osl_atomic_decrement( &pSequence->nRefCount ))
  59                 free( pSequence );
  60         }
  61         else
  62         {
  63             pNew = static_cast<sal_Sequence *>(malloc( SAL_SEQUENCE_HEADER_SIZE ));
  64         }
  65
  66         if ( pNew != nullptr )
  67         {
  68             pNew->nRefCount = 1;
  69             pNew->nElements = nElements;
  70         }
  71
  72         *ppSequence = pNew;
  73     }
  74 }
  75
  76 void SAL_CALL rtl_byte_sequence_realloc(
  77     sal_Sequence ** ppSequence, sal_Int32 nSize ) SAL_THROW_EXTERN_C()
  78 {
  79     sal_Sequence * pSequence;
  80     sal_Int32 nElements;
  81
  82     assert(ppSequence && "### null ptr!");
  83     pSequence = *ppSequence;
  84     nElements = pSequence->nElements;
  85
  86     if (nElements == nSize)
  87         return;
  88
  89     if (pSequence->nRefCount > 1) // split
  90     {
  91         sal_Sequence *pNew = static_cast<sal_Sequence *>(malloc( SAL_SEQUENCE_HEADER_SIZE + nSize ));
  92
  93         if ( pNew != nullptr )
  94         {
  95             if (nSize > nElements)
  96             {
  97                 memcpy( pNew->elements, pSequence->elements, nElements );
  98                 memset( pNew->elements + nElements, 0, nSize - nElements );
  99             }
 100             else
 101             {
 102                 memcpy( pNew->elements, pSequence->elements, nSize );
 103             }
 104         }
 105
 106         if (! osl_atomic_decrement( &pSequence->nRefCount ))
 107             free( pSequence );
 108         pSequence = pNew;
 109     }
 110     else
 111     {
 112         pSequence = static_cast<sal_Sequence *>(realloc(
 113             pSequence, SAL_SEQUENCE_HEADER_SIZE + nSize ));
 114     }
 115
 116     if ( pSequence != nullptr )
 117     {
 118         pSequence->nRefCount = 1;
 119         pSequence->nElements = nSize;
 120     }
 121
 122     *ppSequence = pSequence;
 123 }
 124
 125 void SAL_CALL rtl_byte_sequence_acquire( sal_Sequence *pSequence )
 126     SAL_THROW_EXTERN_C()
 127 {
 128     OSL_ASSERT( pSequence );
 129     osl_atomic_increment( &(pSequence->nRefCount) );
 130 }
 131
 132 void SAL_CALL rtl_byte_sequence_release( sal_Sequence *pSequence )
 133     SAL_THROW_EXTERN_C()
 134 {
 135     if ( pSequence != nullptr )
 136     {
 137         if (! osl_atomic_decrement( &(pSequence->nRefCount )) )
 138         {
 139             free( pSequence );
 140         }
 141     }
 142 }
 143
 144 void SAL_CALL rtl_byte_sequence_construct( sal_Sequence **ppSequence , sal_Int32 nLength )
 145     SAL_THROW_EXTERN_C()
 146 {
 147     OSL_ASSERT( ppSequence );
 148     if( *ppSequence )
 149     {
 150         rtl_byte_sequence_release( *ppSequence );
 151         *ppSequence = nullptr;
 152     }
 153
 154     if( nLength )
 155     {
 156         *ppSequence = static_cast<sal_Sequence *>(rtl_allocateZeroMemory( SAL_SEQUENCE_HEADER_SIZE + nLength ));
 157
 158         if ( *ppSequence != nullptr )
 159         {
 160             (*ppSequence)->nRefCount = 1;
 161             (*ppSequence)->nElements = nLength;
 162         }
 163     }
 164     else
 165     {
 166         *ppSequence = &aEmpty_rtl_ByteSeq;
 167         rtl_byte_sequence_acquire( *ppSequence );
 168     }
 169 }
 170
 171 void SAL_CALL rtl_byte_sequence_constructNoDefault( sal_Sequence **ppSequence , sal_Int32 nLength )
 172     SAL_THROW_EXTERN_C()
 173 {
 174     OSL_ASSERT( ppSequence );
 175     if( *ppSequence )
 176     {
 177         rtl_byte_sequence_release( *ppSequence );
 178         *ppSequence = nullptr;
 179     }
 180
 181     *ppSequence = static_cast<sal_Sequence *>(malloc( SAL_SEQUENCE_HEADER_SIZE + nLength ));
 182
 183     if ( *ppSequence != nullptr )
 184     {
 185         (*ppSequence)->nRefCount = 1;
 186         (*ppSequence)->nElements = nLength;
 187     }
 188 }
 189
 190 void SAL_CALL rtl_byte_sequence_constructFromArray(
 191     sal_Sequence **ppSequence, const sal_Int8 *pData , sal_Int32 nLength )
 192     SAL_THROW_EXTERN_C()
 193 {
 194     rtl_byte_sequence_constructNoDefault( ppSequence , nLength );
 195     if ( *ppSequence != nullptr && nLength != 0 )
 196         memcpy( (*ppSequence)->elements, pData, nLength );
 197 }
 198
 199 void SAL_CALL rtl_byte_sequence_assign( sal_Sequence **ppSequence , sal_Sequence *pSequence )
 200     SAL_THROW_EXTERN_C()
 201 {
 202     if ( *ppSequence != pSequence)
 203     {
 204         if( *ppSequence )
 205         {
 206             rtl_byte_sequence_release( *ppSequence );
 207         }
 208         *ppSequence = pSequence;
 209         rtl_byte_sequence_acquire( *ppSequence );
 210     }
 211 //  else
 212 //      nothing to do
 213
 214 }
 215
 216 sal_Bool SAL_CALL rtl_byte_sequence_equals( sal_Sequence *pSequence1 , sal_Sequence *pSequence2 )
 217     SAL_THROW_EXTERN_C()
 218 {
 219     assert(pSequence1 && pSequence2);
 220     if (pSequence1 == pSequence2)
 221     {
 222         return true;
 223     }
 224     if (pSequence1->nElements != pSequence2->nElements)
 225     {
 226         return false;
 227     }
 228     return
 229         memcmp(
 230             pSequence1->elements, pSequence2->elements, pSequence1->nElements )
 231         == 0;
 232 }
 233
 234 const sal_Int8 *SAL_CALL rtl_byte_sequence_getConstArray( sal_Sequence *pSequence )
 235     SAL_THROW_EXTERN_C()
 236 {
 237     return reinterpret_cast<sal_Int8*>(pSequence->elements);
 238 }
 239
 240 sal_Int32 SAL_CALL rtl_byte_sequence_getLength( sal_Sequence *pSequence )
 241     SAL_THROW_EXTERN_C()
 242 {
 243     return pSequence->nElements;
 244 }
 245
 246 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */