LCOV - code coverage report
Current view: top level - libreoffice/sal/rtl/source - strbuf.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 57 60 95.0 %
Date: 2012-12-27 Functions: 5 5 100.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 <string.h>
      21             : 
      22             : #include <osl/interlck.h>
      23             : #include <rtl/strbuf.hxx>
      24             : 
      25             : /*************************************************************************
      26             :  *  rtl_stringbuffer_newFromStr_WithLength
      27             :  */
      28       73867 : void SAL_CALL rtl_stringbuffer_newFromStr_WithLength( rtl_String ** newStr,
      29             :                                                       const sal_Char * value,
      30             :                                                       sal_Int32 count )
      31             : {
      32       73867 :     if (!value)
      33             :     {
      34           0 :         rtl_string_new_WithLength( newStr, 16 );
      35           0 :         return;
      36             :     }
      37             : 
      38       73867 :     rtl_string_new_WithLength( newStr, count + 16 );
      39       73867 :     (*newStr)->length = count;
      40       73867 :     memcpy( (*newStr)->buffer, value, count );
      41       73867 :     return;
      42             : }
      43             : 
      44             : /*************************************************************************
      45             :  *  rtl_stringbuffer_newFromStringBuffer
      46             :  */
      47        8139 : sal_Int32 SAL_CALL rtl_stringbuffer_newFromStringBuffer( rtl_String ** newStr,
      48             :                                                          sal_Int32 capacity,
      49             :                                                          rtl_String * oldStr )
      50             : {
      51        8139 :     sal_Int32 newCapacity = capacity;
      52             : 
      53        8139 :     if (newCapacity < oldStr->length)
      54           0 :         newCapacity = oldStr->length;
      55             : 
      56        8139 :     rtl_string_new_WithLength( newStr, newCapacity );
      57        8139 :     if (oldStr->length > 0) {
      58        8138 :         (*newStr)->length = oldStr->length;
      59        8138 :         memcpy( (*newStr)->buffer, oldStr->buffer, oldStr->length );
      60             :     }
      61        8139 :     return newCapacity;
      62             : }
      63             : 
      64             : /*************************************************************************
      65             :  *  rtl_stringbuffer_ensureCapacity
      66             :  */
      67      462648 : void SAL_CALL rtl_stringbuffer_ensureCapacity
      68             :     (rtl_String ** This, sal_Int32* capacity, sal_Int32 minimumCapacity)
      69             : {
      70      462648 :     if (minimumCapacity > *capacity)
      71             :     {
      72      462640 :         rtl_String * pTmp = *This;
      73      462640 :         rtl_String * pNew = NULL;
      74      462640 :         *capacity = ((*This)->length + 1) * 2;
      75      462640 :         if (minimumCapacity > *capacity)
      76             :             /* still lower, set to the minimum capacity */
      77      198182 :             *capacity = minimumCapacity;
      78             : 
      79      462640 :         rtl_string_new_WithLength(&pNew, *capacity);
      80      462640 :         pNew->length = (*This)->length;
      81      462640 :         *This = pNew;
      82             : 
      83      462640 :         memcpy( (*This)->buffer, pTmp->buffer, pTmp->length );
      84      462640 :         rtl_string_release( pTmp );
      85             :     }
      86      462648 : }
      87             : 
      88             : /*************************************************************************
      89             :  *  rtl_stringbuffer_insert
      90             :  */
      91    21533623 : 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    21533623 :     if( len != 0 )
     101             :     {
     102    21465156 :         if (*capacity < (*This)->length + len)
     103      458825 :             rtl_stringbuffer_ensureCapacity( This, capacity, (*This)->length + len );
     104             : 
     105             :         /*
     106             :         if( len == 1 )
     107             :             This->buffer
     108             :         */
     109    21465156 :         nOldLen = (*This)->length;
     110    21465156 :         pBuf = (*This)->buffer;
     111             : 
     112             :         /* copy the tail */
     113    21465156 :         n = (nOldLen - offset);
     114    21465156 :         if( n == 1 )
     115             :             /* optimized for 1 character */
     116         864 :             pBuf[offset + len] = pBuf[offset];
     117    21464292 :         else if( n > 1 )
     118        6247 :             memmove( pBuf + offset + len, pBuf + offset, n * sizeof(sal_Char) );
     119             : 
     120             :         /* insert the new characters */
     121    21465156 :         n = len;
     122    21465156 :         if( len == 1 )
     123             :                             /* optimized for 1 character */
     124    15679692 :             pBuf[offset] = *str;
     125     5785464 :         else if( n > 1 )
     126     5785464 :             memcpy( pBuf + offset, str, len * sizeof(sal_Char) );
     127    21465156 :         (*This)->length = nOldLen + len;
     128    21465156 :         pBuf[ nOldLen + len ] = 0;
     129             :     }
     130    21533623 : }
     131             : 
     132             : /*************************************************************************
     133             :  *  rtl_stringbuffer_remove
     134             :  */
     135         978 : 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         978 :     if (len > (*This)->length - start)
     143           2 :         len = (*This)->length - start;
     144             : 
     145             :     //remove nothing
     146         978 :     if (!len)
     147         978 :         return;
     148             : 
     149         978 :     pBuf = (*This)->buffer;
     150         978 :     nTailLen = (*This)->length - ( start + len );
     151             : 
     152         978 :     if (nTailLen)
     153             :     {
     154             :         /* move the tail */
     155           1 :         memmove(pBuf + start, pBuf + start + len, nTailLen * sizeof(sal_Char));
     156             :     }
     157             : 
     158         978 :     (*This)->length-=len;
     159         978 :     pBuf[ (*This)->length ] = 0;
     160             : }
     161             : 
     162             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10