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 <string.h>
      21             : 
      22             : #include <osl/interlck.h>
      23             : #include <rtl/strbuf.hxx>
      24             : 
      25             : /*************************************************************************
      26             :  *  rtl_stringbuffer_newFromStr_WithLength
      27             :  */
      28           0 : void SAL_CALL rtl_stringbuffer_newFromStr_WithLength( rtl_String ** newStr,
      29             :                                                       const sal_Char * value,
      30             :                                                       sal_Int32 count )
      31             : {
      32           0 :     if (!value)
      33             :     {
      34           0 :         rtl_string_new_WithLength( newStr, 16 );
      35           0 :         return;
      36             :     }
      37             : 
      38           0 :     rtl_string_new_WithLength( newStr, count + 16 );
      39           0 :     (*newStr)->length = count;
      40           0 :     memcpy( (*newStr)->buffer, value, count );
      41           0 :     return;
      42             : }
      43             : 
      44             : /*************************************************************************
      45             :  *  rtl_stringbuffer_newFromStringBuffer
      46             :  */
      47           0 : sal_Int32 SAL_CALL rtl_stringbuffer_newFromStringBuffer( rtl_String ** newStr,
      48             :                                                          sal_Int32 capacity,
      49             :                                                          rtl_String * oldStr )
      50             : {
      51           0 :     sal_Int32 newCapacity = capacity;
      52             : 
      53           0 :     if (newCapacity < oldStr->length)
      54           0 :         newCapacity = oldStr->length;
      55             : 
      56           0 :     rtl_string_new_WithLength( newStr, newCapacity );
      57           0 :     if (oldStr->length > 0) {
      58           0 :         (*newStr)->length = oldStr->length;
      59           0 :         memcpy( (*newStr)->buffer, oldStr->buffer, oldStr->length );
      60             :     }
      61           0 :     return newCapacity;
      62             : }
      63             : 
      64             : /*************************************************************************
      65             :  *  rtl_stringbuffer_ensureCapacity
      66             :  */
      67         354 : void SAL_CALL rtl_stringbuffer_ensureCapacity
      68             :     (rtl_String ** This, sal_Int32* capacity, sal_Int32 minimumCapacity)
      69             : {
      70         354 :     if (minimumCapacity > *capacity)
      71             :     {
      72         354 :         rtl_String * pTmp = *This;
      73         354 :         rtl_String * pNew = NULL;
      74         354 :         *capacity = ((*This)->length + 1) * 2;
      75         354 :         if (minimumCapacity > *capacity)
      76             :             /* still lower, set to the minimum capacity */
      77         274 :             *capacity = minimumCapacity;
      78             : 
      79         354 :         rtl_string_new_WithLength(&pNew, *capacity);
      80         354 :         pNew->length = (*This)->length;
      81         354 :         *This = pNew;
      82             : 
      83         354 :         memcpy( (*This)->buffer, pTmp->buffer, pTmp->length );
      84         354 :         rtl_string_release( pTmp );
      85             :     }
      86         354 : }
      87             : 
      88             : /*************************************************************************
      89             :  *  rtl_stringbuffer_insert
      90             :  */
      91        1269 : void SAL_CALL rtl_stringbuffer_insert( rtl_String ** This,
      92             :                                        sal_Int32 * capacity,
      93             :                                        sal_Int32 offset,
      94             :                                        const sal_Char * str,
      95             :                                        sal_Int32 len )
      96             : {
      97             :     sal_Int32 nOldLen;
      98             :     sal_Char * pBuf;
      99             :     sal_Int32 n;
     100        1269 :     if( len != 0 )
     101             :     {
     102        1269 :         if (*capacity < (*This)->length + len)
     103         354 :             rtl_stringbuffer_ensureCapacity( This, capacity, (*This)->length + len );
     104             : 
     105             :         /*
     106             :         if( len == 1 )
     107             :             This->buffer
     108             :         */
     109        1269 :         nOldLen = (*This)->length;
     110        1269 :         pBuf = (*This)->buffer;
     111             : 
     112             :         /* copy the tail */
     113        1269 :         n = (nOldLen - offset);
     114        1269 :         if( n == 1 )
     115             :             /* optimized for 1 character */
     116          47 :             pBuf[offset + len] = pBuf[offset];
     117        1222 :         else if( n > 1 )
     118         202 :             memmove( pBuf + offset + len, pBuf + offset, n * sizeof(sal_Char) );
     119             : 
     120             :         /* insert the new characters */
     121        1269 :         n = len;
     122        1269 :         if( len == 1 )
     123             :                             /* optimized for 1 character */
     124         566 :             pBuf[offset] = *str;
     125         703 :         else if( n > 1 )
     126         703 :             memcpy( pBuf + offset, str, len * sizeof(sal_Char) );
     127        1269 :         (*This)->length = nOldLen + len;
     128        1269 :         pBuf[ nOldLen + len ] = 0;
     129             :     }
     130        1269 : }
     131             : 
     132             : /*************************************************************************
     133             :  *  rtl_stringbuffer_remove
     134             :  */
     135           0 : void SAL_CALL rtl_stringbuffer_remove( rtl_String ** This,
     136             :                                        sal_Int32 start,
     137             :                                        sal_Int32 len )
     138             : {
     139             :     sal_Int32 nTailLen;
     140             :     sal_Char * pBuf;
     141             : 
     142           0 :     if (len > (*This)->length - start)
     143           0 :         len = (*This)->length - start;
     144             : 
     145             :     //remove nothing
     146           0 :     if (!len)
     147           0 :         return;
     148             : 
     149           0 :     pBuf = (*This)->buffer;
     150           0 :     nTailLen = (*This)->length - ( start + len );
     151             : 
     152           0 :     if (nTailLen)
     153             :     {
     154             :         /* move the tail */
     155           0 :         memmove(pBuf + start, pBuf + start + len, nTailLen * sizeof(sal_Char));
     156             :     }
     157             : 
     158           0 :     (*This)->length-=len;
     159           0 :     pBuf[ (*This)->length ] = 0;
     160             : }
     161             : 
     162             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */