Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbUtil/BdbTString.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: BdbTString.cc,v 1.4 2001/11/20 01:57:02 becla Exp $
//
// Description:
//      "BdbTString" extends the Objectivity "ooVString" by adding some
//      of the usual features of a string class, like the concatenation
//      operators and soon...
//
// Nature:
//      Transient class;
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Jean-Noel Albert    LAL/SLAC    Nov 1997        Original Author
//------------------------------------------------------------------------

//----------------
// Class Header --
//----------------
// Note: Must be the first header loaded by the class implementation

#include "BdbUtil/BdbTString.hh"

//-------------
// C Headers --
//-------------

extern "C" {
#include <stdlib.h>
#include <string.h>
}

//-----------------
// BaBar headers --
//-----------------
#include "BdbUtil/BdbUtilErrors.hh"

//----------------
// Constructors --
//----------------

// Default constructor - used for the BdbStringArray
BdbTString::BdbTString()
{
    _string = "";
}

// Copy constructor - build a new string from an existing one
BdbTString::BdbTString(const BdbTString& value)
{
    _string = value;
}

// Conversion constructors - build a string from an existing
// persistent string (d_String) or a C string.
BdbTString::BdbTString(const d_String& value)
{
    if (value.head() == 0)
        _string = "";
    else
        _string = value;
}

BdbTString::BdbTString(const char* value)
{
    if (value == NULL)
        _string = "";           // CAUTION: NULL is not 0 !!
    else
        _string = value;
}

// Conversion constructor - build a string from an integer
// CAUTION: *0* is not *NULL* !
//          affecting *0* to a string creates a string "O";
//          affecting *NULL* creates an empty string ("").
BdbTString::BdbTString(int value)
{
    if (value == 0)
        _string = "0";          // CAUTION: 0 is not NULL !!
    else {
        char svalue[32];
        sprintf(svalue, "%d", value);
        _string = svalue;
    }
}

// Concatenation constructor - allow to build a string
// from a lot of partial strings. Principally useful
// to supply the concatenation operator (+) for C strings
// and integers.
// Example: 
//          char* home = getenv("HOME")
//          BdbString test = BdbString(home, "/test.log");
//  (you can write: test = home + "/test.log" because
//   "+" can't be defined for 2 C strings.)
BdbTString::BdbTString(const BdbTString& s0, const BdbTString& s1,
                       const BdbTString& s2, const BdbTString& s3, 
                       const BdbTString& s4, const BdbTString& s5,
                       const BdbTString& s6, const BdbTString& s7,
                       const BdbTString& s8, const BdbTString& s9,
                       const BdbTString& s10, const BdbTString& s11)
{
    (*this) = s0;
    (*this) += s1;
    (*this) += s2;
    (*this) += s3;
    (*this) += s4;
    (*this) += s5;
    (*this) += s6;
    (*this) += s7;
    (*this) += s8;
    (*this) += s9;
    (*this) += s10;
    (*this) += s11;
}

// Destructor
BdbTString::~BdbTString()
{}

// Affectations
BdbTString& BdbTString::operator= (const BdbTString& value)
{
    _string = value._string;
    return *this;
}

BdbTString& BdbTString::operator= (const d_String& value)
{
    if (value.head() == 0)
        _string = "";
    else
        _string = value;
    return *this;
}

BdbTString& BdbTString::operator= (const char* value)
{
    if (value == NULL)
        _string = "";                   // CAUTION: NULL is not 0 !!
    else
        _string = value;
    return *this;
}

BdbTString& BdbTString::operator= (int value)
{
    _string = BdbTString(value);
    return *this;
}

// Auto-concatenations
BdbTString& BdbTString::operator+= (const BdbTString& value)
{
    _string += value._string;
    return *this;
}

BdbTString& BdbTString::operator+= (const d_String& value)
{
    if (value.head() != 0)
        _string += value;
    return *this;
}

BdbTString& BdbTString::operator+= (const char* value)
{
    if (value != NULL)
        _string += value;
    return *this;
}

// Modifiers: some developers prefer to avoid the "operator="
void BdbTString::set(const BdbTString& value)
{
    _string = value;
}

void BdbTString::set(const d_String& value)
{
    _string = value;
}

void BdbTString::set(const char* value)
{
    _string = value;
}

void BdbTString::set(int value)
{
    _string = BdbTString(value);
}

// Length of the string
int BdbTString::length() const
{
    return _string.length();
}

// Converters - automatically called to convert a string
//  to the specified type
BdbTString::operator const char*() const
{
    return _string.head();
}

BdbTString::operator int() const
{
    return atoi(data());
}

// Accessors: return the value of the string.
// Principally used to force the conversion of a string
// to a "const char*". Useful with some older C++ compilers.
// "chars" is GNU-compatible, "data" is STL-compatible.
const char* BdbTString::chars() const
{
    return _string.head();
}

const char* BdbTString::data() const
{
    return _string.head();
}

// Locators: returns the index of the first character
//          of the substring in the string.
//
// Note on the indexes: 
//  * 0 means the first character of the string (C convention;
//  * 1 is the second character;
//  * -1 means the *last* character of the string !
//  * -2 is the previous one...
int BdbTString::position(char c, int index) const
{
    if (abs(index) > length())
        return -1;

    int position;
    const char* str;

    if (index >= 0) {
        position = index;
        str = data() + position;
        int len = length();
        while ((position < len) && (*str != c)) {
            str++; position++;
        }
    }
    else {
        position = length() + index;
        str = data() + position;
        while ((position >= 0) && (*str != c)) {
            str--; position--;
        }
    }

    if (*str != c)
        return -1;

    return position;
}

int BdbTString::position(const BdbTString& s, int index) const
{
    if (abs(index) > length())
        return -1;

    const char* ps = s.data();
    int slen = s.length();
    int position;
    const char* str;

    if (index > 0) {
        position = index;
        str = data() + position;
        int len = length();

        for (; position < len; str++, position++)
            if ((*str == *ps) && (strncmp(str, ps, slen) == 0))
                return position;
    }
    else {
        position = length() + index;
        str = data() + position;

        for (; position >= 0; str--, position--)
            if ((*str == *ps) && (strncmp(str, ps, slen) == 0))
                return position;
    }

    return -1;
}

// Indexed accessors: 2 operators are defined,
// one for the `lhs' (affectation) and one for the `rhs'
// (const). Most of the compilers are now able to understand
// the differences...
char BdbTString::operator[] (int index) const
{
    if (abs(index) > length())
        return '\0';

    if (index < 0)
        index = length() + index;

    return *(data() + index);
}

char BdbTString::operator[] (int index)
{
    // The only way to recover an invalid access to a string
    // is to throw an exception...
    // (sorry)
    if (abs(index) > length())
        BdbSignal(BdbcFatalError, BdbUtilErrBadIndex, 0,
                  "BdbTString::operator[]", index, length());

    if (index < 0)
        index = length() + index;

    return *((char*)(data()) + index);
}

// Return the substring starting at the "index" position,
//  up to the specified length. By default, return all the
//  end of the string.
BdbTString BdbTString::at(int index, int len) const
{
    if (abs(index) > length())
        return "";

    if (index < 0)
        index = length() + index;

    if ((len < 0) || (len + index) > length())
        len = length() - index;

    char* str = new char[len];
    memcpy(str, (data() + index), len);
    str[len] = '\0';

    BdbTString bs = str;
    delete[] str;

    return bs;
}

// Return the substring starting at the position specified,
//  to the end of the string. If the position is specified
//  by a substring the copy starts after the last character
//  of this substring.
// If the substring does not exist, an empty string ("")
// is returned.
BdbTString BdbTString::after (int index) const
{
    if (index < 0)
        index = length() + index;
    return at(index + 1);
}

BdbTString BdbTString::after (char c, int index) const
{
    int pos = position(c, index);
    if (pos < 0)
        return "";
    else
        return after(pos);
}

BdbTString BdbTString::after (const BdbTString& s, int index) const
{
    int pos = position(s, index) + s.length();
    if (pos < 0)
        return "";
    else
        return after(pos);
}

// Return the substring starting of the beginning of the string
//  to the position specified by the index or the substring.
// If the substring does not exist, return an empty string ("").
BdbTString BdbTString::before (int index) const
{
    if (index < 0)
        index = length() + index;
    return at(0, index);
}

BdbTString BdbTString::before (char c, int index) const
{
    int pos = position(c, index);
    if (pos < 0)
        return "";
    else
        return before(pos);
}

BdbTString BdbTString::before (const BdbTString& s, int index) const
{
    int pos = position(s, index);
    if (pos < 0)
        return "";
    else
        return before(pos);
}

// Comparison between string and values
int BdbTString::strcmp(const BdbTString& s1, const BdbTString& s2)
{
    const char* h1 = s1._string.head();
    const char* h2 = s2._string.head();
    if (((h1 == 0) || (*h1 == '\0')) && ((h2 == 0) || (*h2 == '\0')))
        return 0;
    else if ((h1 == 0) || (*h1 == '\0'))
        return 1;
    else if ((h2 == 0) || (*h2 == '\0'))
        return -1;
    else
        return ::strcmp(h1, h2);
}

int BdbTString::strcmp(const BdbTString& str, const char* txt)
{
    const char* hd = str._string.head();
    if (((hd == 0) || (*hd == '\0')) && ((txt == 0) || (*txt == '\0')))
        return 0;
    else if ((hd == 0) || (*hd == '\0'))
        return 1;
    else if ((txt == 0) || (*txt == '\0'))
        return -1;
    else
        return ::strcmp(hd, txt);
}

int BdbTString::strcmp(const char* txt, const BdbTString& str)
{
    const char* hd = str._string.head();
    if (((txt == 0) || (*txt == '\0')) && ((hd == 0) || (*hd == '\0')))
        return 0;
    else if ((txt == 0) || (*txt == '\0'))
        return 1;
    else if ((hd == 0) || (*hd == '\0'))
        return -1;
    else
        return ::strcmp(txt, hd);
}

ostream& operator<< (ostream& s, const BdbTString& str)
{
    s << str._string.head();
    return s;
}

istream& operator>> (istream& s, const BdbTString& str)
{
    s >> str._string;
    return s;
}

//////////////////////////////////////////////////////////////

//-----------------
// Concatenation --
//-----------------

BdbTString operator + (const BdbTString& s1, const BdbTString& s2)
{
    BdbTString temp = s1;
    temp += s2;
    return temp;
}

BdbTString operator + (const BdbTString& str, const char* txt)
{
    BdbTString temp = str;
    temp += txt;
    return temp;
}

BdbTString operator + (const char* txt, const BdbTString& str)
{
    BdbTString temp = txt;
    temp += str;
    return temp;
}

//--------------
// Comparison --
//--------------

int operator == (const BdbTString& s1, const BdbTString& s2)
{
    return BdbTString::strcmp(s1, s2) == 0;
}

int operator != (const BdbTString& s1, const BdbTString& s2)
{
    return BdbTString::strcmp(s1, s2) != 0;
}

int operator >  (const BdbTString& s1, const BdbTString& s2)
{
    return BdbTString::strcmp(s1, s2) > 0;
}

int operator >= (const BdbTString& s1, const BdbTString& s2)
{
    return BdbTString::strcmp(s1, s2) >= 0;
}

int operator <  (const BdbTString& s1, const BdbTString& s2)
{
    return BdbTString::strcmp(s1, s2) < 0;
}

int operator <= (const BdbTString& s1, const BdbTString& s2)
{
    return BdbTString::strcmp(s1, s2) <= 0;
}

int operator == (const BdbTString& str, const char* txt)
{
    return BdbTString::strcmp(str, txt) == 0;
}

int operator != (const BdbTString& str, const char* txt)
{
    return BdbTString::strcmp(str, txt) != 0;
}

int operator >  (const BdbTString& str, const char* txt)
{
    return BdbTString::strcmp(str, txt) > 0;
}

int operator >= (const BdbTString& str, const char* txt)
{
    return BdbTString::strcmp(str, txt) >= 0;
}

int operator <  (const BdbTString& str, const char* txt)
{
    return BdbTString::strcmp(str, txt) < 0;
}

int operator <= (const BdbTString& str, const char* txt)
{
    return BdbTString::strcmp(str, txt) <= 0;
}

int operator == (const char* txt, const BdbTString& str)
{
    return BdbTString::strcmp(txt, str) == 0;
}

int operator != (const char* txt, const BdbTString& str)
{
    return BdbTString::strcmp(txt, str) != 0;
}

int operator >  (const char* txt, const BdbTString& str)
{
    return BdbTString::strcmp(txt, str) > 0;
}

int operator >= (const char* txt, const BdbTString& str)
{
    return BdbTString::strcmp(txt, str) >= 0;
}

int operator <  (const char* txt, const BdbTString& str)
{
    return BdbTString::strcmp(txt, str) < 0;
}

int operator <= (const char* txt, const BdbTString& str)
{
    return BdbTString::strcmp(txt, str) <= 0;
}

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002