← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to COLLADABaseUtils/src/COLLADABUStringUtils.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
COLLADABaseUtils/src/COLLADABUStringUtils.cpp
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
        This file is part of COLLADABaseUtils.
 
5
        
 
6
    Licensed under the MIT Open Source License, 
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
 
 
11
#include "COLLADABUStableHeaders.h"
 
12
#include "COLLADABUStringUtils.h"
 
13
#include "COLLADABUException.h"
 
14
#include "ConvertUTF.h"
 
15
 
 
16
#include <cassert>
 
17
 
 
18
 
 
19
/* Maximum number of bytes a unicode character can have in UTF8 encoding*/
 
20
#define MAX_UTF8_CHAR_LENGTH 4
 
21
 
 
22
 
 
23
namespace COLLADABU
 
24
{
 
25
 
 
26
 
 
27
    //---------------------------------
 
28
    WideString StringUtils::checkNCName ( const WideString &ncName )
 
29
    {
 
30
        WideString result;
 
31
        result.reserve ( ncName.length() );
 
32
 
 
33
        // check if first character is an alpha character
 
34
        const wchar_t& firstCharacter = ncName[0];
 
35
 
 
36
        if ( isNameStartChar(( firstCharacter ) ) )
 
37
            result.append ( 1, firstCharacter );
 
38
        else
 
39
            result.append ( 1, '_' );
 
40
 
 
41
        //replace all spaces and colons by underlines
 
42
        for ( size_t i = 1; i<ncName.length(); ++i )
 
43
        {
 
44
            const wchar_t& character = ncName[i];
 
45
 
 
46
            if ( isNameChar ( character ) )
 
47
                result.append ( 1, character );
 
48
            else
 
49
                result.append ( 1, '_' );
 
50
        }
 
51
 
 
52
        return result;
 
53
    }
 
54
 
 
55
    //---------------------------------
 
56
    WideString StringUtils::checkID ( const WideString &id )
 
57
    {
 
58
        return checkNCName ( id );
 
59
    }
 
60
 
 
61
    //---------------------------------
 
62
    String StringUtils::translateToXML ( const String &srcString )
 
63
    {
 
64
        String returnString; 
 
65
 
 
66
        for ( unsigned int i=0; i<srcString.length(); ++i )
 
67
        {
 
68
            switch ( srcString[i])
 
69
            {
 
70
//             case '\r':  
 
71
//                 returnString += String("&#13");
 
72
//                 break;
 
73
            case '<':  
 
74
                returnString += String("&lt;");
 
75
                break;
 
76
            case '>': 
 
77
                returnString += String("&gt;");
 
78
                break;
 
79
            case '&':  
 
80
                returnString += String("&amp;");
 
81
                break;
 
82
            case '"':  
 
83
                returnString += String("&quot;");
 
84
                break;
 
85
            case '\'':  
 
86
                returnString += String("&apos;");
 
87
                break;
 
88
            default :   
 
89
                returnString += srcString[i];
 
90
            }
 
91
        }
 
92
 
 
93
        return returnString;
 
94
    }
 
95
 
 
96
 
 
97
        //---------------------------------
 
98
        WideString StringUtils::translateToXML ( const WideString &srcString )
 
99
        {
 
100
                WideString returnString; 
 
101
 
 
102
                for ( unsigned int i=0; i<srcString.length(); ++i )
 
103
                {
 
104
                        switch ( srcString[i])
 
105
                        {
 
106
//                      case '\r':  
 
107
//                              returnString += L"&#13";
 
108
//                              break;
 
109
                        case '<':  
 
110
                                returnString += L"&lt;";
 
111
                                break;
 
112
                        case '>': 
 
113
                                returnString += L"&gt;";
 
114
                                break;
 
115
                        case '&':  
 
116
                                returnString += L"&amp;";
 
117
                                break;
 
118
                        case '"':  
 
119
                                returnString += L"&quot;";
 
120
                                break;
 
121
                        case '\'':  
 
122
                                returnString += L"&apos;";
 
123
                                break;
 
124
                        default :   
 
125
                                returnString += srcString[i];
 
126
                        }
 
127
                }
 
128
 
 
129
                return returnString;
 
130
        }
 
131
 
 
132
 
 
133
 
 
134
    //---------------------------------
 
135
    String StringUtils::uriEncode ( const String  & sSrc )
 
136
    {
 
137
        const char DEC2HEX[16 + 1] = "0123456789ABCDEF";
 
138
        const unsigned char * pSrc = ( const unsigned char * ) sSrc.c_str();
 
139
        const int SRC_LEN = ( const int ) sSrc.length();
 
140
        unsigned char * const pStart = new unsigned char[SRC_LEN * 3];
 
141
        unsigned char * pEnd = pStart;
 
142
        const unsigned char * const SRC_END = pSrc + SRC_LEN;
 
143
 
 
144
        for ( ; pSrc < SRC_END; ++pSrc )
 
145
        {
 
146
            if ( *pSrc > 32 )
 
147
                *pEnd++ = ( *pSrc == 0x5c ) ? 0x2f : *pSrc;
 
148
            else
 
149
            {
 
150
                // escape this char
 
151
                *pEnd++ = '%';
 
152
                *pEnd++ = DEC2HEX[*pSrc >> 4];
 
153
                *pEnd++ = DEC2HEX[*pSrc & 0x0F];
 
154
            }
 
155
        }
 
156
 
 
157
        String sResult ( ( char * ) pStart, ( char * ) pEnd );
 
158
 
 
159
        delete [] pStart;
 
160
        return sResult;
 
161
    }
 
162
 
 
163
    //---------------------------------
 
164
    String StringUtils::replaceDot ( const String& text )
 
165
    {
 
166
        std::stringstream stream;
 
167
 
 
168
        for ( size_t i = 0; i < text.length(); ++i )
 
169
        {
 
170
            if ( text[i] == '.' )
 
171
                stream << '_';
 
172
            else
 
173
                stream << text[i];
 
174
        }
 
175
 
 
176
        return String(stream.str());
 
177
    }
 
178
 
 
179
 
 
180
 
 
181
        //--------------------------------
 
182
        bool StringUtils::equalsIgnoreCase ( const WideString& s1, const WideString& s2 ) 
 
183
        {
 
184
                if ( s1.length() != s2.length() )
 
185
                        return false;
 
186
 
 
187
                WideString::const_iterator it1=s1.begin();
 
188
                WideString::const_iterator it2=s2.begin();
 
189
 
 
190
                // has the end of at least one of the strings been reached?
 
191
                while ( (it1!=s1.end()) && (it2!=s2.end()) ) 
 
192
                { 
 
193
                        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
 
194
                                return false; 
 
195
                        // proceed to the next character in each string
 
196
                        ++it1;
 
197
                        ++it2;
 
198
                }
 
199
                return true;
 
200
        }
 
201
 
 
202
        //--------------------------------
 
203
        bool StringUtils::isNameStartChar( wchar_t c )
 
204
        {
 
205
                return          ( c == ':' ) 
 
206
                                ||      ( c >= 'A' && c <= 'Z' )
 
207
                                ||  ( c == '_' )
 
208
                                ||  ( c >= 'a' && c <= 'z' )
 
209
                                ||  ( c >= 0xC0 && c <= 0xD6 ) 
 
210
                                ||      ( c >= 0xD8 && c <= 0xF6 )
 
211
                                ||      ( c >= 0xF8 && c <= 0x2FF )
 
212
                                ||      ( c >= 0x370 && c <= 0x37D )
 
213
                                ||      ( c >= 0x37F && c <= 0x1FFF )
 
214
                                ||      ( c >= 0x200C && c <= 0x200D )
 
215
                                ||      ( c >= 0x2070 && c <= 0x218F )
 
216
                                ||      ( c >= 0x2C00 && c <= 0x2FEF )
 
217
                                ||      ( c >= 0x3001 && c <= 0xD7FF )
 
218
                                ||      ( c >= 0xF900 && c <= 0xFDCF )
 
219
                                ||      ( c >= 0xFDF0 && c <= 0xFFFD )
 
220
                                ||      ( c >= 0x10000 && c <= 0xEFFFF);
 
221
        }
 
222
 
 
223
 
 
224
        //--------------------------------
 
225
        bool StringUtils::isNameChar( wchar_t c )
 
226
        {
 
227
                return  isNameStartChar( c )    
 
228
                        ||      ( c == '-' ) 
 
229
                        ||  ( c == '.' )
 
230
                        ||  ( c >= '0' && c <= '9' )
 
231
                        ||  ( c == 0xB7 )
 
232
                        ||  ( c >= 0x0300 && c <= 0x036F ) 
 
233
                        ||      ( c >= 0x203F && c <= 0x2040 );
 
234
        }
 
235
 
 
236
        //--------------------------------
 
237
        WideString StringUtils::utf8String2WideString( const String& utf8String )
 
238
        {
 
239
                size_t widesize = utf8String.length();
 
240
                WideString returnWideString;
 
241
 
 
242
                if ( sizeof( wchar_t ) == sizeof(UTF16) )
 
243
                {
 
244
                        returnWideString.resize( widesize + 1, L'\0' );
 
245
                        const UTF8* sourcestart = reinterpret_cast<const UTF8*>( utf8String.c_str() );
 
246
                        const UTF8* sourceend = sourcestart + widesize;
 
247
                        UTF16* targetstart = reinterpret_cast<UTF16*>( &((returnWideString)[ 0 ]) );
 
248
                        UTF16* thisFirstWChar = targetstart;
 
249
                        UTF16* targetend = targetstart + widesize;
 
250
                        ConversionResult res = ConvertUTF8toUTF16( &sourcestart, sourceend, &targetstart, targetend, strictConversion );
 
251
                        returnWideString.resize(targetstart - thisFirstWChar);
 
252
 
 
253
                        if ( res != conversionOK )
 
254
                        {
 
255
                                throw Exception(Exception::ERROR_UTF8_2_WIDE, String("Could not convert from UTF8 to wide string."));
 
256
                        }
 
257
 
 
258
                        *targetstart = 0;
 
259
                }
 
260
                else if ( sizeof( wchar_t ) == sizeof(UTF32) )
 
261
                {
 
262
                        returnWideString.resize( widesize + 1, L'\0' );
 
263
                        const UTF8* sourcestart = reinterpret_cast<const UTF8*>( utf8String.c_str() );
 
264
                        const UTF8* sourceend = sourcestart + widesize;
 
265
                        UTF32* targetstart = reinterpret_cast<UTF32*>( &((returnWideString)[ 0 ]) );
 
266
                        UTF32* thisFirstWChar = targetstart;
 
267
                        UTF32* targetend = targetstart + widesize;
 
268
                        ConversionResult res = ConvertUTF8toUTF32( &sourcestart, sourceend, &targetstart, targetend, strictConversion );
 
269
                        returnWideString.resize(targetstart - thisFirstWChar);
 
270
 
 
271
                        if ( res != conversionOK )
 
272
                        {
 
273
                                throw Exception(Exception::ERROR_UTF8_2_WIDE, String("Could not convert from UTF8 to wide string."));
 
274
                        }
 
275
 
 
276
                        *targetstart = 0;
 
277
                }
 
278
                else
 
279
                {
 
280
                        COLLADABU_ASSERT(false);
 
281
                }
 
282
                return returnWideString;
 
283
        }
 
284
 
 
285
        //--------------------------------
 
286
        String StringUtils::wideString2utf8String( const WideString& wideString )
 
287
        {
 
288
                size_t widesize = wideString.length();
 
289
                String returnString;
 
290
 
 
291
                if ( sizeof( wchar_t ) == sizeof(UTF16) )
 
292
                {
 
293
                        size_t utf8size = MAX_UTF8_CHAR_LENGTH * widesize + 1;
 
294
                        returnString.resize( utf8size, '\0' );
 
295
                        const UTF16* sourcestart = reinterpret_cast<const UTF16*>( wideString.c_str() );
 
296
                        const UTF16* sourceend = sourcestart + widesize;
 
297
                        UTF8* targetstart = reinterpret_cast<UTF8*>( &((returnString)[ 0 ]) );
 
298
                        UTF8* thisFirstWChar = targetstart;
 
299
                        UTF8* targetend = targetstart + utf8size;
 
300
                        ConversionResult res = ConvertUTF16toUTF8( &sourcestart, sourceend, &targetstart, targetend, strictConversion );
 
301
 
 
302
                        if ( res != conversionOK )
 
303
                        {
 
304
                                throw Exception(Exception::ERROR_WIDE_2_UTF8, String("Could not convert from wide string to UTF8."));
 
305
                        }
 
306
 
 
307
                        returnString.resize(targetstart - thisFirstWChar);
 
308
                }
 
309
                else if ( sizeof( wchar_t ) == sizeof(UTF32) )
 
310
                {
 
311
                        size_t utf8size = MAX_UTF8_CHAR_LENGTH * widesize + 1;
 
312
                        returnString.resize( utf8size, '\0' );
 
313
                        const UTF32* sourcestart = reinterpret_cast<const UTF32*>( wideString.c_str() );
 
314
                        const UTF32* sourceend = sourcestart + widesize;
 
315
                        UTF8* targetstart = reinterpret_cast<UTF8*>( &((returnString)[ 0 ]) );
 
316
                        UTF8* thisFirstWChar = targetstart;
 
317
                        UTF8* targetend = targetstart + utf8size;
 
318
                        ConversionResult res = ConvertUTF32toUTF8( &sourcestart, sourceend, &targetstart, targetend, strictConversion );
 
319
 
 
320
                        if ( res != conversionOK )
 
321
                        {
 
322
                                throw Exception(Exception::ERROR_WIDE_2_UTF8, String("Could not convert from wide string to UTF8."));
 
323
                        }
 
324
 
 
325
                        returnString.resize(targetstart - thisFirstWChar);
 
326
                }
 
327
                else
 
328
                {
 
329
                        COLLADABU_ASSERT(false);
 
330
                }
 
331
                return returnString;
 
332
        }
 
333
 
 
334
        //------------------------------
 
335
        char StringUtils::toUpperASCIIChar( char c )
 
336
        {
 
337
                if ( isLowerAsciiChar(c) )
 
338
                {
 
339
                        return c + 'A' - 'a';
 
340
                }
 
341
                return c;
 
342
        }
 
343
 
 
344
 
 
345
 
 
346
 
 
347
}