buffered_string.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "buffered_string.h"
#include "buffered_string_buffer.h"

// CL_BufferedString Construction:

CL_BufferedString::CL_BufferedString()
: string_buffer(0), index(0), str(0), str_len(0)
{
}

CL_BufferedString::CL_BufferedString(CL_BufferedStringBuffer *string_buffer, int index)
: string_buffer(string_buffer), index(index), str(0), str_len(0)
{
}

CL_BufferedString::CL_BufferedString(const char *str, int str_len)
: string_buffer(0), index(0), str(str), str_len(str_len)
{
}

CL_BufferedString::CL_BufferedString(const CL_BufferedString &copy)
: string_buffer(copy.string_buffer), index(copy.index), str(copy.str), str_len(copy.str_len)
{
}

CL_BufferedString::~CL_BufferedString()
{
}

// CL_BufferedString Attributes:

int CL_BufferedString::length() const
{
        if (string_buffer)
                return string_buffer->get_length(index);
        else
                return str_len;
}

const char *CL_BufferedString::data() const
{
        if (string_buffer)
                return string_buffer->get_data(index);
        else
                return str;
}

const char *CL_BufferedString::c_str() const
{
        if (string_buffer)
                return string_buffer->get_data(index);
        else
                return str;
}

std::string CL_BufferedString::to_string() const
{
        if (string_buffer)
                return std::string(
                        string_buffer->get_data(index),
                        string_buffer->get_length(index));
        else
                return std::string(str, str_len);
}

CL_BufferedString::operator const char *() const
{
        return c_str();
}

CL_BufferedString::operator CL_StringA() const
{
        return to_string();
}

// CL_BufferedString Operations:

CL_BufferedString &CL_BufferedString::operator =(const CL_BufferedString &copy)
{
        string_buffer = copy.string_buffer;
        index = copy.index;
        str = copy.str;
        str_len = copy.str_len;
        return *this;
}
        
bool CL_BufferedString::operator <(const CL_BufferedString &str) const
{
        int len_a = length();
        int len_b = str.length();
        int len_min = (len_a < len_b) ? len_a : len_b;
        const unsigned char *data_a = (const unsigned char *) data();
        const unsigned char *data_b = (const unsigned char *) str.data();
        
        for (int i=0; i<len_min; i++)
        {
                if (data_a[i] != data_b[i])
                        return data_a[i] < data_b[i];
        }
        return len_a < len_b;
}
        
bool CL_BufferedString::operator <(const char *str) const
{
        CL_BufferedString s(str, (int) strlen(str));
        return *this < s;
}

bool CL_BufferedString::operator <(const CL_StringA &str) const
{
        CL_BufferedString s(str.data(), (int) str.length());
        return *this < s;
}

bool CL_BufferedString::operator >(const CL_BufferedString &str) const
{
        int len_a = length();
        int len_b = str.length();
        int len_min = (len_a < len_b) ? len_a : len_b;
        const unsigned char *data_a = (const unsigned char *) data();
        const unsigned char *data_b = (const unsigned char *) str.data();
        
        for (int i=0; i<len_min; i++)
        {
                if (data_a[i] != data_b[i])
                        return data_a[i] > data_b[i];
        }
        return len_a > len_b;
}

bool CL_BufferedString::operator >(const char *str) const
{
        CL_BufferedString s(str, (int) strlen(str));
        return *this > s;
}

bool CL_BufferedString::operator >(const CL_StringA &str) const
{
        CL_BufferedString s(str.data(), (int) str.length());
        return *this > s;
}

bool CL_BufferedString::operator ==(const CL_BufferedString &str) const
{
        int len_a = length();
        int len_b = str.length();
        const unsigned char *data_a = (const unsigned char *) data();
        const unsigned char *data_b = (const unsigned char *) str.data();
        
        if (len_a != len_b)
                return false;
        
        for (int i=0; i<len_a; i++)
        {
                if (data_a[i] != data_b[i])
                        return false;
        }
        return true;
}
        
bool CL_BufferedString::operator ==(const char *str) const
{
        CL_BufferedString s(str, (int) strlen(str));
        return *this == s;
}

bool CL_BufferedString::operator ==(const CL_StringA &str) const
{
        CL_BufferedString s(str.data(), (int) str.length());
        return *this == s;
}

bool CL_BufferedString::operator !=(const CL_BufferedString &str) const
{
        return !(*this == str);
}
        
bool CL_BufferedString::operator !=(const char *str) const
{
        CL_BufferedString s(str, (int) strlen(str));
        return !(*this == s);
}
        
bool CL_BufferedString::operator !=(const CL_StringA &str) const
{
        CL_BufferedString s(str.data(), (int) str.length());
        return !(*this == s);
}

// CL_BufferedString Implementation:

---