/****************************************************************************
|
*
|
* Copyright (C) 2000-2001 RealNetworks, Inc. All rights reserved.
|
*
|
* This program is free software. It may be distributed under the terms
|
* in the file LICENSE, found in the top level of the source distribution.
|
*
|
*/
|
|
#include <ctype.h>
|
#include <string.h>
|
|
#include "types.h"
|
#include "str.h"
|
|
/**************************************
|
*
|
* CBuffer
|
*
|
**************************************/
|
|
CBuffer::CBuffer( void ) :
|
m_nAlloc(0),
|
m_nLen(0),
|
m_buf(NULL)
|
{
|
// Empty
|
}
|
|
CBuffer::CBuffer( const CBuffer& other ) :
|
m_nAlloc(0),
|
m_nLen(0),
|
m_buf(NULL)
|
{
|
assert( other.m_buf || (!other.m_nAlloc && !other.m_nLen) );
|
|
if( other.m_nLen )
|
{
|
m_nAlloc = m_nLen = other.m_nLen;
|
m_buf = new Byte[ other.m_nLen ];
|
memcpy( m_buf, other.m_buf, m_nAlloc );
|
}
|
}
|
|
CBuffer::CBuffer( size_t len )
|
{
|
m_buf = new Byte[ len ];
|
m_nAlloc = m_nLen = len;
|
}
|
|
CBuffer::CBuffer( CPByte pbuf, size_t len )
|
{
|
assert( pbuf );
|
|
m_buf = new Byte[ len ];
|
m_nAlloc = m_nLen = len;
|
memcpy( m_buf, pbuf, len );
|
}
|
|
CBuffer::~CBuffer( void )
|
{
|
if( m_buf ) memset( m_buf, 0xDD, m_nAlloc );
|
delete[] m_buf;
|
}
|
|
CBuffer& CBuffer::operator=( const CBuffer& other )
|
{
|
assert( other.m_buf || (!other.m_nAlloc && !other.m_nLen) );
|
|
m_nAlloc = m_nLen = 0;
|
delete[] m_buf; m_buf = NULL;
|
if( other.m_nLen )
|
{
|
m_nAlloc = m_nLen = other.m_nLen;
|
m_buf = new Byte[ other.m_nLen ];
|
memcpy( m_buf, other.m_buf, m_nAlloc );
|
}
|
|
return *this;
|
}
|
|
Byte CBuffer::operator[]( size_t n ) const
|
{
|
assert( m_buf );
|
assert( n < m_nLen );
|
|
return m_buf[n];
|
}
|
|
Byte& CBuffer::operator[]( size_t n )
|
{
|
assert( m_buf );
|
assert( n < m_nLen );
|
|
return m_buf[n];
|
}
|
|
void CBuffer::Clear( void )
|
{
|
m_nLen = m_nAlloc = 0;
|
delete[] m_buf; m_buf = NULL;
|
}
|
|
void CBuffer::Set( CPByte pbuf, size_t len )
|
{
|
assert( pbuf || !len );
|
assert( m_buf || (!m_nAlloc && !m_nLen) );
|
|
if( len )
|
{
|
if( len > m_nAlloc )
|
{
|
delete[] m_buf;
|
m_buf = new Byte[ len ];
|
m_nAlloc = len;
|
}
|
memcpy( m_buf, pbuf, len );
|
m_nLen = len;
|
}
|
else
|
{
|
m_nAlloc = m_nLen = 0;
|
delete[] m_buf; m_buf = NULL;
|
}
|
}
|
|
size_t CBuffer::GetSize( void ) const
|
{
|
return m_nLen;
|
}
|
|
void CBuffer::SetSize( size_t len )
|
{
|
assert( m_buf || (!m_nAlloc && !m_nLen) );
|
|
if( len )
|
{
|
if( len > m_nAlloc )
|
{
|
Byte* pbuf = new Byte[ len ];
|
memcpy( pbuf, m_buf, m_nAlloc );
|
delete[] m_buf;
|
m_nAlloc = len;
|
m_buf = pbuf;
|
}
|
m_nLen = len;
|
}
|
else
|
{
|
m_nAlloc = m_nLen = 0;
|
delete[] m_buf; m_buf = NULL;
|
}
|
}
|
|
PByte CBuffer::GetBuffer( void )
|
{
|
return m_buf;
|
}
|
|
CPByte CBuffer::GetBuffer( void ) const
|
{
|
return m_buf;
|
}
|
|
void CBuffer::SetBuffer( CPByte pbuf )
|
{
|
assert( pbuf );
|
assert( m_buf && m_nAlloc && m_nLen );
|
|
memcpy( m_buf, pbuf, m_nLen );
|
}
|
|
/**************************************
|
*
|
* CString
|
*
|
**************************************/
|
|
CString::CString( void )
|
{
|
m_sz = new char[1];
|
m_sz[0] = '\0';
|
}
|
|
CString::CString( const CString& other )
|
{
|
assert( other.m_sz );
|
m_sz = new char[ strlen(other.m_sz) + 1 ];
|
strcpy( m_sz, other.m_sz );
|
}
|
|
CString::CString( CPCHAR sz )
|
{
|
m_sz = new char[ strlen(sz) + 1 ];
|
strcpy( m_sz, sz );
|
}
|
|
CString::CString( CPCHAR buf, size_t len )
|
{
|
m_sz = new char[ len + 1 ];
|
memcpy( m_sz, buf, len );
|
m_sz[len] = '\0';
|
}
|
|
CString::CString( char c, UINT32 nrep /* = 1 */ )
|
{
|
m_sz = new char[ nrep + 1 ];
|
memset( m_sz, c, nrep );
|
m_sz[nrep] = '\0';
|
}
|
|
CString::~CString( void )
|
{
|
if( m_sz ) memset( m_sz, 0xDD, strlen(m_sz)+1 );
|
delete[] m_sz;
|
}
|
|
CString& CString::operator=( const CString& other )
|
{
|
assert( other.m_sz );
|
delete[] m_sz;
|
m_sz = new char[ strlen(other.m_sz) + 1 ];
|
strcpy( m_sz, other.m_sz );
|
|
return *this;
|
}
|
|
CString& CString::operator=( CPCHAR sz )
|
{
|
assert( sz );
|
|
delete[] m_sz;
|
m_sz = new char[ strlen(sz) + 1 ];
|
strcpy( m_sz, sz );
|
|
return *this;
|
}
|
|
void CString::Set( CPCHAR buf, size_t len )
|
{
|
assert( buf );
|
|
delete[] m_sz;
|
m_sz = new char[ len + 1 ];
|
memcpy( m_sz, buf, len );
|
m_sz[len] = '\0';
|
}
|
|
UINT32 CString::GetLength( void ) const
|
{
|
assert( m_sz );
|
|
return strlen( m_sz );
|
}
|
|
bool CString::IsEmpty( void ) const
|
{
|
assert( m_sz );
|
|
return ( m_sz[0] == '\0' );
|
}
|
|
int CString::Compare( const CString& other ) const
|
{
|
assert( m_sz && other.m_sz );
|
|
return strcmp( m_sz, other.m_sz );
|
}
|
|
int CString::CompareNum( const CString& other, UINT32 len) const
|
{
|
assert( m_sz && other.m_sz );
|
|
return strncmp( m_sz, other.m_sz, len);
|
}
|
|
int CString::CompareNoCase( const CString& other ) const
|
{
|
assert( m_sz && other.m_sz );
|
|
return strcasecmp( m_sz, other.m_sz );
|
}
|
|
int CString::CompareNumNoCase( const CString& other ,UINT32 len) const
|
{
|
assert( m_sz && other.m_sz );
|
|
return strncasecmp( m_sz, other.m_sz, len);
|
}
|
|
char CString::GetAt( UINT32 pos ) const
|
{
|
assert( m_sz );
|
assert( pos < strlen(m_sz) );
|
|
return m_sz[pos];
|
}
|
|
char& CString::GetAt( UINT32 pos )
|
{
|
assert( m_sz );
|
assert( pos < strlen(m_sz) );
|
|
return m_sz[pos];
|
}
|
|
void CString::SetAt( UINT32 pos, char c )
|
{
|
assert( m_sz );
|
assert( pos < strlen(m_sz) );
|
|
m_sz[pos] = c;
|
}
|
|
void CString::Append( CPCHAR sz )
|
{
|
assert( sz && m_sz );
|
|
if( *sz )
|
{
|
PCHAR sznew = new char[ strlen(m_sz) + strlen(sz) + 1 ];
|
strcpy( sznew, m_sz );
|
strcat( sznew, sz );
|
delete[] m_sz;
|
m_sz = sznew;
|
}
|
}
|
|
void CString::ToLower( void )
|
{
|
assert( m_sz );
|
char* p = m_sz;
|
while( *p )
|
{
|
*p = tolower( *p );
|
p++;
|
}
|
}
|
|
void CString::ToUpper( void )
|
{
|
assert( m_sz );
|
char* p = m_sz;
|
while( *p )
|
{
|
*p = toupper( *p );
|
p++;
|
}
|
}
|
|
void CString::DeQuote( void )
|
{
|
assert( m_sz );
|
|
PCHAR p = m_sz;
|
PCHAR q = m_sz;
|
while( *p )
|
{
|
if( *p == '\\' && *(p+1) )
|
{
|
switch( *(p+1) )
|
{
|
case 'n': p++; *p = '\n'; break;
|
case 'r': p++; *p = '\r'; break;
|
case 't': p++; *p = '\t'; break;
|
case '"': p++; *p = '"'; break;
|
case '\\': p++; break;
|
default:
|
break;
|
}
|
}
|
*q++ = *p++;
|
}
|
*q = '\0';
|
}
|
|
CPCHAR CString::Find( char c, UINT32 pos /* = 0 */ ) const
|
{
|
assert( m_sz );
|
assert( pos < strlen(m_sz) );
|
|
return strchr( m_sz+pos, c );
|
}
|
