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 99750 : void SAL_CALL rtl_stringbuffer_newFromStr_WithLength( rtl_String ** newStr,
29 : const sal_Char * value,
30 : sal_Int32 count )
31 : {
32 99750 : if (!value)
33 : {
34 0 : rtl_string_new_WithLength( newStr, 16 );
35 0 : return;
36 : }
37 :
38 99750 : rtl_string_new_WithLength( newStr, count + 16 );
39 99750 : (*newStr)->length = count;
40 99750 : memcpy( (*newStr)->buffer, value, count );
41 99750 : return;
42 : }
43 :
44 : /*************************************************************************
45 : * rtl_stringbuffer_newFromStringBuffer
46 : */
47 9010 : sal_Int32 SAL_CALL rtl_stringbuffer_newFromStringBuffer( rtl_String ** newStr,
48 : sal_Int32 capacity,
49 : rtl_String * oldStr )
50 : {
51 9010 : sal_Int32 newCapacity = capacity;
52 :
53 9010 : if (newCapacity < oldStr->length)
54 0 : newCapacity = oldStr->length;
55 :
56 9010 : rtl_string_new_WithLength( newStr, newCapacity );
57 9010 : if (oldStr->length > 0) {
58 8829 : (*newStr)->length = oldStr->length;
59 8829 : memcpy( (*newStr)->buffer, oldStr->buffer, oldStr->length );
60 : }
61 9010 : return newCapacity;
62 : }
63 :
64 : /*************************************************************************
65 : * rtl_stringbuffer_ensureCapacity
66 : */
67 805217 : void SAL_CALL rtl_stringbuffer_ensureCapacity
68 : (rtl_String ** This, sal_Int32* capacity, sal_Int32 minimumCapacity)
69 : {
70 805217 : if (minimumCapacity > *capacity)
71 : {
72 439549 : rtl_String * pTmp = *This;
73 439549 : rtl_String * pNew = NULL;
74 439549 : *capacity = ((*This)->length + 1) * 2;
75 439549 : if (minimumCapacity > *capacity)
76 : /* still lower, set to the minimum capacity */
77 186962 : *capacity = minimumCapacity;
78 :
79 439549 : rtl_string_new_WithLength(&pNew, *capacity);
80 439549 : pNew->length = (*This)->length;
81 439549 : *This = pNew;
82 :
83 439549 : memcpy( (*This)->buffer, pTmp->buffer, pTmp->length );
84 439549 : rtl_string_release( pTmp );
85 : }
86 805217 : }
87 :
88 : /*************************************************************************
89 : * rtl_stringbuffer_insert
90 : */
91 18577135 : 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 18577135 : if( len != 0 )
101 : {
102 18532538 : if (*capacity < (*This)->length + len)
103 423811 : rtl_stringbuffer_ensureCapacity( This, capacity, (*This)->length + len );
104 :
105 : /*
106 : if( len == 1 )
107 : This->buffer
108 : */
109 18532538 : nOldLen = (*This)->length;
110 18532538 : pBuf = (*This)->buffer;
111 :
112 : /* copy the tail */
113 18532538 : n = (nOldLen - offset);
114 18532538 : if( n == 1 )
115 : /* optimized for 1 character */
116 7449 : pBuf[offset + len] = pBuf[offset];
117 18525089 : else if( n > 1 )
118 33356 : memmove( pBuf + offset + len, pBuf + offset, n * sizeof(sal_Char) );
119 :
120 : /* insert the new characters */
121 18532538 : n = len;
122 18532538 : if( len == 1 )
123 : /* optimized for 1 character */
124 13355639 : pBuf[offset] = *str;
125 5176899 : else if( n > 1 )
126 5176899 : memcpy( pBuf + offset, str, len * sizeof(sal_Char) );
127 18532538 : (*This)->length = nOldLen + len;
128 18532538 : pBuf[ nOldLen + len ] = 0;
129 : }
130 18577135 : }
131 :
132 : /*************************************************************************
133 : * rtl_stringbuffer_remove
134 : */
135 5 : 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 5 : if (len > (*This)->length - start)
143 2 : len = (*This)->length - start;
144 :
145 : //remove nothing
146 5 : if (!len)
147 5 : return;
148 :
149 5 : pBuf = (*This)->buffer;
150 5 : nTailLen = (*This)->length - ( start + len );
151 :
152 5 : if (nTailLen)
153 : {
154 : /* move the tail */
155 1 : memmove(pBuf + start, pBuf + start + len, nTailLen * sizeof(sal_Char));
156 : }
157 :
158 5 : (*This)->length-=len;
159 5 : pBuf[ (*This)->length ] = 0;
160 : }
161 :
162 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
