ustring.cpp
上传用户:riyaled888
上传日期:2009-03-27
资源大小:7338k
文件大小:7k
源码类别:

多媒体

开发平台:

MultiPlatform

  1. /*****************************************************************************
  2.  * ustring.cpp
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 VideoLAN
  5.  * $Id: ustring.cpp 7258 2004-04-03 10:55:51Z asmax $
  6.  *
  7.  * Authors: Cyril Deguet     <asmax@via.ecp.fr>
  8.  *          Olivier Teuli鑢e <ipkiss@via.ecp.fr>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  24. #include <string.h>
  25. #include "ustring.hpp"
  26. const uint32_t UString::npos = 0xffffffff;
  27. UString::UString( const UString &rOther ): SkinObject( rOther.getIntf() )
  28. {
  29.     m_length = rOther.m_length;
  30.     m_pString = new uint32_t[m_length + 1];
  31.     memcpy( m_pString, rOther.m_pString, 4 * m_length + 4);
  32. }
  33. UString::UString( intf_thread_t *pIntf, const char *pString ):
  34.     SkinObject( pIntf )
  35. {
  36.     // First we compute the length of the string
  37.     const char *pCur = pString;
  38.     for( m_length = 0; pCur && *pCur; m_length++ )
  39.     {
  40.         if( (*pCur & 0xfc) == 0xfc )
  41.         {
  42.             pCur += 6;
  43.         }
  44.         else if ( (*pCur & 0xf8 ) == 0xf8 )
  45.         {
  46.             pCur += 5;
  47.         }
  48.         else if ( (*pCur & 0xf0 ) == 0xf0 )
  49.         {
  50.             pCur += 4;
  51.         }
  52.         else if ( (*pCur & 0xe0 ) == 0xe0 )
  53.         {
  54.             pCur += 3;
  55.         }
  56.         else if ( (*pCur & 0xc0 ) == 0xc0 )
  57.         {
  58.             pCur += 2;
  59.         }
  60.         else
  61.         {
  62.             pCur++;
  63.         }
  64.     }
  65.     if( !pCur || *pCur )
  66.     {
  67.         msg_Err( pIntf, "Invalid UTF8 string: %s", pString );
  68.         m_length = 0;
  69.         m_pString = NULL;
  70.         return;
  71.     }
  72.     m_pString = new uint32_t[m_length + 1];
  73.     // Convert the UTF8 string into UNICODE
  74.     pCur = pString;
  75.     uint32_t aChar = 0;  // current unicode character
  76.     int remaining = 0;   // remaining bytes
  77.     for( uint32_t i = 0; i <= m_length; i++ )
  78.     {
  79.         if( (*pCur & 0xfc) == 0xfc )
  80.         {
  81.             aChar = *pCur & 1;
  82.             remaining = 5;
  83.         }
  84.         else if ( (*pCur & 0xf8 ) == 0xf8 )
  85.         {
  86.             aChar = *pCur & 3;
  87.             remaining = 4;
  88.         }
  89.         else if ( (*pCur & 0xf0 ) == 0xf0 )
  90.         {
  91.             aChar = *pCur & 7;
  92.             remaining = 3;
  93.         }
  94.         else if ( (*pCur & 0xe0 ) == 0xe0 )
  95.         {
  96.             aChar = *pCur & 15;
  97.             remaining = 2;
  98.         }
  99.         else if ( (*pCur & 0xc0 ) == 0xc0 )
  100.         {
  101.             aChar = *pCur & 31;
  102.             remaining = 1;
  103.         }
  104.         else
  105.         {
  106.             aChar = *pCur;
  107.             remaining = 0;
  108.         }
  109.         while( remaining )
  110.         {
  111.             pCur++;
  112.             remaining--;
  113.             aChar = ( aChar << 6 ) | ( *pCur & 0x3f );
  114.         }
  115.         m_pString[i] = aChar;
  116.         pCur++;
  117.     }
  118.     m_pString[m_length] = 0;
  119. }
  120. UString::~UString()
  121. {
  122.     if( m_pString )
  123.     {
  124.         delete[] m_pString;
  125.     }
  126. }
  127. bool UString::operator ==( const UString &rOther ) const
  128. {
  129.     if( size() != rOther.size() )
  130.     {
  131.         return false;
  132.     }
  133.     for( uint32_t i = 0; i < size(); i++ )
  134.     {
  135.         if( m_pString[i] != rOther.m_pString[i] )
  136.         {
  137.             return false;
  138.         }
  139.     }
  140.     return true;
  141. }
  142. bool UString::operator !=( const UString &rOther ) const
  143. {
  144.     return !(*this == rOther);
  145. }
  146. bool UString::operator <( const UString &rOther ) const
  147. {
  148.     const uint32_t *pOther = rOther.u_str();
  149.     uint32_t i;
  150.     for( i = 0; i < __MIN(m_length, rOther.length()); i++ )
  151.     {
  152.         if( m_pString[i] < pOther[i] )
  153.         {
  154.             return true;
  155.         }
  156.         else if( m_pString[i] > pOther[i] )
  157.         {
  158.             return false;
  159.         }
  160.     }
  161.     return( m_pString[i] < pOther[i] );
  162. }
  163. bool UString::operator <=( const UString &rOther ) const
  164. {
  165.     return !( rOther < *this );
  166. }
  167. bool UString::operator >( const UString &rOther ) const
  168. {
  169.     return ( rOther < *this );
  170. }
  171. bool UString::operator >=( const UString &rOther ) const
  172. {
  173.     return !( *this < rOther );
  174. }
  175. void UString::operator =( const UString &rOther )
  176. {
  177.     m_length = rOther.m_length;
  178.     delete[] m_pString;
  179.     m_pString = new uint32_t[size() + 1];
  180.     for( uint32_t i = 0; i <= size(); i++ )
  181.     {
  182.         m_pString[i] = rOther.m_pString[i];
  183.     }
  184. }
  185. void UString::operator +=( const UString &rOther )
  186. {
  187.     int tempLength = this->length() + rOther.length();
  188.     uint32_t *pTempString = new uint32_t[tempLength + 1];
  189.     // Copy the first string
  190.     memcpy( pTempString, this->m_pString, 4 * this->size() );
  191.     // Append the second string
  192. //     memcpy( pTempString + 4 * size(), rOther.m_pString,
  193. //             4 * rOther.size() );
  194.     for( uint32_t i = 0; i < rOther.size(); i++ )
  195.     {
  196.         pTempString[this->size() + i] = rOther.m_pString[i];
  197.     }
  198.     pTempString[tempLength] = 0;
  199.     // Set the string internally
  200.     delete[] m_pString;
  201.     m_pString = pTempString;
  202.     m_length = tempLength;
  203. }
  204. const UString UString::operator +( const UString &rOther ) const
  205. {
  206.     UString result( *this );
  207.     result += rOther;
  208.     return result;
  209. }
  210. const UString UString::operator +( const char *pString ) const
  211. {
  212.     UString temp( getIntf(), pString );
  213.     return (*this + temp );
  214. }
  215. void UString::debug() const
  216. {
  217.     char *s = new char[size() + 1];
  218.     for( uint32_t i = 0; i < size(); i++ )
  219.     {
  220.         s[i] = (char)m_pString[i];
  221.     }
  222.     s[size()] = '';
  223.     msg_Err( getIntf(), "%s", s );
  224.     delete[] s;
  225. }
  226. uint32_t UString::find( const UString &str, uint32_t position ) const
  227. {
  228.     uint32_t pos;
  229.     for( pos = position; pos + str.size() <= size(); pos++ )
  230.     {
  231.         bool match = true;
  232.         for( uint32_t i = 0; i < str.size(); i++ )
  233.         {
  234.             if( m_pString[pos + i] != str.m_pString[i] )
  235.             {
  236.                 match = false;
  237.                 break;
  238.             }
  239.         }
  240.         // Found
  241.         if( match )
  242.         {
  243.             return pos;
  244.         }
  245.     }
  246.     // Not found
  247.     return npos;
  248. }
  249. uint32_t UString::find( const char *pString, uint32_t position ) const
  250. {
  251.     UString tmp( getIntf(), pString );
  252.     return find( tmp, position );
  253. }
  254. void UString::replace( uint32_t position, uint32_t n1, const UString &str )
  255. {
  256.     UString start( substr( 0, position ) );
  257.     UString end( substr( position + n1 ) );
  258.     *this = start + str + end;
  259. }
  260. void UString::replace( uint32_t position, uint32_t n1, const char *pString )
  261. {
  262.     replace( position, n1, UString( getIntf(), pString ) );
  263. }
  264. UString UString::substr( uint32_t position, uint32_t n) const
  265. {
  266.     UString tmp( getIntf(), "" );
  267.     if( position > size() )
  268.     {
  269.         msg_Err( getIntf(), "Invalid position in UString::substr()" );
  270.         return tmp;
  271.     }
  272.     tmp.m_length = (n < size() - position) ? n : size() - position;
  273.     delete[] tmp.m_pString;
  274.     tmp.m_pString = new uint32_t[tmp.size() + 1];
  275.     for( uint32_t i = 0; i < tmp.size(); i++ )
  276.     {
  277.         tmp.m_pString[i] = m_pString[position + i];
  278.     }
  279.     return tmp;
  280. }