LTP GCOV extension - code coverage report
Current view: directory - src/cpp/prod/tool - WString.cpp
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 82
Code covered: 36.6 % Executed lines: 30

       1                 : //=============================================================================
       2                 : // File <$/src/cpp/prod/tool/WString.cpp>
       3                 : // This file is part of YaOrb : Yet Another Object Request Broker,
       4                 : // Copyright (c) 2000-2003, Marc Alff.
       5                 : //
       6                 : // This program is free software; you can redistribute it and/or
       7                 : // modify it under the terms of the GNU General Public License
       8                 : // as published by the Free Software Foundation; either version 2
       9                 : // of the License, or (at your option) any later version.
      10                 : //
      11                 : // This program is distributed in the hope that it will be useful,
      12                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 : // GNU General Public License for more details.
      15                 : //
      16                 : // You should have received a copy of the GNU General Public License
      17                 : // along with this program; if not, write to the Free Software
      18                 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
      19                 : //
      20                 : //=============================================================================
      21                 : 
      22                 : // Portability
      23                 : #include "yaorb/config.h"
      24                 : #include "src/cpp/prod/port/port_unistd.h"
      25                 : #include "src/cpp/prod/port/port_wchar.h"
      26                 : 
      27                 : #include <stdio.h>
      28                 : 
      29                 : #include "src/cpp/prod/tool/WString.h"
      30                 : #include "src/cpp/prod/tool/Assert.h"
      31                 : 
      32                 : static const wchar_t * const emptyWCharString = L"" ;
      33                 : static const wchar_t endOfWString = L'\0' ;
      34                 : 
      35                 : /* Notes
      36                 : ** char -> wchar
      37                 : ** strcmp -> wcscmp
      38                 : ** strncmp -> wmemcmp
      39                 : ** strlen -> wcslen
      40                 : ** strcpy -> wcscpy
      41                 : ** strncpy -> wcsncpy
      42                 : ** strcat -> wcscat
      43                 : */
      44                 : 
      45               0 : WString::WString()
      46               0 : : _len(0), _str(NULL)
      47                 : {
      48               0 :    _len = 1 ;
      49               0 :    _str = new wchar_t[_len] ;
      50               0 :    _str[0] = endOfWString ;
      51                 : }
      52                 : 
      53             112 : WString::WString(wchar_t wc)
      54             112 : : _len(0), _str(NULL)
      55                 : {
      56             112 :    _len = 2 ;
      57             112 :    _str = new wchar_t[_len] ;
      58             112 :    _str[0] = wc ;
      59             112 :    _str[1] = endOfWString ;
      60                 : }
      61                 : 
      62              63 : WString::WString(const int aSize)
      63              63 : : _len(0), _str(NULL)
      64                 : {
      65                 :    ASSERT(aSize >= 0) ;
      66                 : 
      67              63 :    _len = aSize + 1 ;
      68              63 :    _str = new wchar_t[_len] ;
      69              63 :    _str[0] = endOfWString ;
      70                 : }
      71                 : 
      72               0 : WString::WString(const wchar_t* aWCharString)
      73               0 : : _len(0), _str(NULL)
      74                 : {
      75               0 :    if (aWCharString == NULL)
      76                 :    {
      77               0 :       aWCharString = emptyWCharString ;
      78                 :    }
      79                 : 
      80               0 :    _len = wcslen(aWCharString) + 1 ;
      81               0 :    _str = new wchar_t[_len] ;
      82               0 :    wcscpy(_str, aWCharString) ;
      83                 : }
      84                 : 
      85              12 : WString::WString(const WString& aWString)
      86              12 : : _len(0), _str(NULL)
      87                 : {
      88              12 :    _len = aWString._len ;
      89              12 :    _str = new wchar_t[_len] ;
      90                 : 
      91              12 :    wcscpy(_str, aWString._str) ;
      92                 : }
      93                 : 
      94             114 : WString::~WString()
      95                 : {
      96             114 :    delete [] _str ;
      97               0 : }
      98                 : 
      99              10 : int WString::length() const
     100                 : {
     101              10 :    return wcslen(_str) ;
     102                 : }
     103                 : 
     104              10 : WString & WString::operator =(const wchar_t* aWCharString)
     105                 : {
     106              10 :    if (aWCharString == NULL)
     107                 :    {
     108               0 :       aWCharString = emptyWCharString ;
     109                 :    }
     110                 : 
     111              10 :    int newLen = wcslen(aWCharString) + 1 ;   
     112              10 :    if (_len < newLen)
     113                 :    {
     114               0 :       delete [] _str ;
     115                 :       
     116               0 :       _len = newLen ;
     117               0 :       _str = new wchar_t[_len] ;
     118                 :    }
     119                 :    
     120              10 :    wcscpy(_str, aWCharString) ;
     121                 : 
     122                 :    return *this ;
     123                 : }
     124                 : 
     125               0 : WString & WString::operator =(const WString& aWString)
     126                 : {
     127               0 :    int newLen = wcslen(aWString._str) + 1 ;
     128               0 :    if (_len < newLen)
     129                 :    {
     130               0 :       delete [] _str ;
     131                 :       
     132               0 :       _len = newLen ;
     133               0 :       _str = new wchar_t[_len] ;
     134                 :    }
     135                 :    
     136               0 :    wcscpy(_str, aWString._str) ;
     137                 : 
     138                 :    return *this ;
     139                 : }
     140                 : 
     141               0 : void WString::operator +=(const wchar_t* aWCharString)
     142                 : {   
     143               0 :    if (aWCharString == NULL)
     144                 :    {
     145               0 :       aWCharString = emptyWCharString ;
     146                 :    }
     147                 :    
     148               0 :    int newLen = wcslen(_str) + wcslen(aWCharString) + 1 ;
     149               0 :    if (_len < newLen)
     150                 :    {
     151               0 :       wchar_t* newStr = new wchar_t[newLen] ;
     152               0 :       wcscpy(newStr, _str) ;
     153               0 :       delete [] _str ;
     154               0 :       _str = newStr ;
     155               0 :       _len = newLen ;
     156                 :    }
     157                 : 
     158               0 :    wcscat(_str, aWCharString) ;
     159                 : }
     160                 : 
     161             112 : void WString::operator +=(const WString& aWString)
     162                 : {
     163             112 :    int newLen = wcslen(_str) + wcslen(aWString._str) + 1 ;
     164                 : 
     165             112 :    if (_len < newLen)
     166                 :    {
     167               0 :       wchar_t* newStr = new wchar_t[newLen] ;
     168               0 :       wcscpy(newStr, _str) ;
     169               0 :       delete [] _str ;
     170               0 :       _str = newStr ;
     171               0 :       _len =newLen ;
     172                 :    }
     173                 : 
     174             112 :    wcscat(_str, aWString._str) ;
     175                 : }
     176                 : 
     177               0 : int WString::operator ==(const wchar_t* aWCharString) const
     178                 : {
     179               0 :    if (aWCharString == NULL)
     180                 :    {
     181               0 :       aWCharString = emptyWCharString ;
     182                 :    }
     183                 : 
     184               0 :    return ((wcscmp(_str, aWCharString)==0) ? true : false) ;
     185                 : }
     186                 : 
     187               0 : int WString::operator ==(const WString& aWString) const
     188                 : {
     189               0 :    return ((wcscmp(_str, aWString._str)==0) ? true : false) ;
     190                 : }
     191                 : 
     192              10 : WString::operator const wchar_t* () const
     193                 : {
     194                 :    return _str ;
     195                 : }
     196                 : 
     197               0 : int WString::compare(const wchar_t* aWCharString) const
     198                 : {
     199               0 :    if (aWCharString == NULL)
     200                 :    {
     201               0 :       aWCharString = emptyWCharString ;
     202                 :    }
     203                 : 
     204               0 :    return (wcscmp(_str, aWCharString)) ;
     205                 : }
     206                 : 
     207               0 : int WString::compare(const WString& aWString) const
     208                 : {
     209               0 :    return (wcscmp(_str, aWString._str)) ;
     210                 : }

Generated by: LTP GCOV extension version 1.4