ofstring.h

/*
 *
 *  Copyright (C) 1997-2005, OFFIS
 *
 *  This software and supporting documentation were developed by
 *
 *    Kuratorium OFFIS e.V.
 *    Healthcare Information and Communication Systems
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *  THIS SOFTWARE IS MADE AVAILABLE,  AS IS,  AND OFFIS MAKES NO  WARRANTY
 *  REGARDING  THE  SOFTWARE,  ITS  PERFORMANCE,  ITS  MERCHANTABILITY  OR
 *  FITNESS FOR ANY PARTICULAR USE, FREEDOM FROM ANY COMPUTER DISEASES  OR
 *  ITS CONFORMITY TO ANY SPECIFICATION. THE ENTIRE RISK AS TO QUALITY AND
 *  PERFORMANCE OF THE SOFTWARE IS WITH THE USER.
 *
 *  Module:  ofstd
 *
 *  Author:  Andrew Hewett
 *
 *  Purpose: A simple string class
 *
 *  Last Update:      $Author: meichel $
 *  Update Date:      $Date: 2005/12/08 16:06:07 $
 *  CVS/RCS Revision: $Revision: 1.20 $
 *  Status:           $State: Exp $
 *
 *  CVS/RCS Log at end of file
 *
 */

#ifndef OFSTRING_H
#define OFSTRING_H

#include "dcmtk/config/osconfig.h"     /* include OS specific configuration first */
#include "dcmtk/ofstd/oftypes.h"      /* for OFBool */
#include "dcmtk/ofstd/ofcast.h"

#ifdef HAVE_STD_STRING
/*
** Use the ANSI Standard string class
*/

#include <string>

#define OFString std::string
#define OFString_npos std::string::npos

#else /* not HAVE_STD_STRING */

/*
** Declare our own string class
*/

#define INCLUDE_CASSERT
#define INCLUDE_CSTRING
#define INCLUDE_CSTDLIB
#define INCLUDE_LIBC
#define INCLUDE_UNISTD
#include "dcmtk/ofstd/ofstdinc.h"

#include "dcmtk/ofstd/ofstream.h"
#include "dcmtk/ofstd/oftypes.h"

/*
** Error macros
*/
#define OFSTRING_OUTOFRANGE(cond) assert (!(cond))
#define OFSTRING_LENGTHERROR(cond) assert (!(cond))
#define OFSTRING_MEMORYALLOCERROR(cond) assert (!(cond))

static const size_t OFString_npos = (OFstatic_cast(size_t, -1));


class OFString
{
public:
    /*
     * The SunOS C++ 2.0.1 does not allow static const members.
     * We would like to define:
     *    static const size_t npos = ((size_t)-1);
     * but cannot so an alternative OFString_npos is defined outside
     * the class (see above).
     */

    OFString();

    OFString(const OFString& str, size_t pos = 0, size_t n = OFString_npos);

    OFString(const char* s, size_t n);

    OFString(const char* s);

    OFString(size_t rep, char c);

    ~OFString();

    OFString& operator=(const OFString& rhs);

    OFString& operator=(const char* s);

    OFString& operator=(char s);

    OFString& operator+=(const OFString& rhs);

    OFString& operator+=(const char* s);

    OFString& operator+=(char s);

    OFString& append(const OFString& str, size_t pos = 0, size_t n = OFString_npos);

    OFString& append(const char* s, size_t n);

    OFString& append(const char* s);

    OFString& append(size_t rep, char c);

    OFString& assign(const OFString& str, size_t pos = 0, size_t n = OFString_npos);

    OFString& assign(const char* s, size_t n);

    OFString& assign(const char* s);

    OFString& assign(size_t rep, char c);

    OFString& insert(size_t pos1, const OFString& str,
              size_t pos2 = 0, size_t n = OFString_npos);

    OFString& insert(size_t pos, const char* s, size_t n);

    OFString& insert(size_t pos, const char* s);

    OFString& insert(size_t pos, size_t rep, char c);

    OFString& erase (size_t pos = 0, size_t n = OFString_npos);

    OFString& replace(size_t pos1, size_t n1, const OFString& str,
               size_t pos2 = 0, size_t n2 = OFString_npos);

    OFString& replace(size_t pos, size_t n, const char* s, size_t n2);

    OFString& replace(size_t pos, size_t n, const char* s);

    OFString& replace(size_t pos, size_t n, size_t rep, char s);

    const char& at(size_t pos) const
    {
        OFSTRING_OUTOFRANGE (pos >= this->size());
        return this->theCString[pos];
    }

    char& at(size_t pos)
    {
        OFSTRING_OUTOFRANGE (pos >= this->size());
        return this->theCString[pos];
    }

    char operator[] (size_t pos) const
    {
        if (pos == this->size()) return '\0';
        else
        {
          OFSTRING_OUTOFRANGE (pos > this->size());
          return this->theCString[pos];
        }
    }

    char& operator[] (size_t pos)
    {
        OFSTRING_OUTOFRANGE (pos >= this->size());
        return this->theCString[pos];
    }

    const char* c_str() const
    {
        return (this->theCString)?(this->theCString):("");
    }

    const char* data() const;

    size_t size() const
    {
        return (this->theCString)?(strlen(this->theCString)):(0);
    }

    size_t length() const
    {
        return this->size();
    }

    OFBool empty() const
    {
        return (this->size() == 0)?(OFTrue):(OFFalse);
    }

    void resize (size_t n, char c = '\0');

    size_t capacity () const
    {
        return this->theCapacity;
    }

    size_t max_size() const
    {
        return ((OFString_npos - 1)/sizeof(char));
    }

    void clear()
    {
        this->erase();
    }

    void reserve(size_t res_arg);

    size_t copy(char* s, size_t n, size_t pos = 0) const;

    OFString substr(size_t pos = 0, size_t n = OFString_npos) const;

    void swap(OFString& s);

    int compare(const OFString& str) const;

    int compare(size_t pos1, size_t n1, const OFString& str) const;

    int compare(size_t pos1, size_t n1, const OFString& str,
         size_t pos2, size_t n2) const;

    int compare(const char* s) const;

    int compare(size_t pos1, size_t n1,
         const char* s, size_t n2 = OFString_npos) const;

    size_t find(const OFString& pattern, size_t pos = 0) const;

    size_t find(const char* pattern, size_t pos, size_t n) const;

    size_t find(const char* pattern, size_t pos = 0) const;

    size_t find(char pattern, size_t pos = 0) const;

    size_t rfind(const OFString& pattern, size_t pos = OFString_npos) const;

    size_t rfind(const char* pattern, size_t pos, size_t n) const;

    size_t rfind(const char* pattern, size_t pos = OFString_npos) const;

    size_t rfind(char pattern, size_t pos = OFString_npos) const;

    size_t find_first_of(const OFString& str, size_t pos = 0) const;

    size_t find_first_of(const char* s, size_t pos, size_t n) const;

    size_t find_first_of(const char* s, size_t pos = 0) const;

    size_t find_first_of(char s, size_t pos = 0) const;

    size_t find_last_of(const OFString& str, size_t pos = OFString_npos) const;

    size_t find_last_of(const char* s, size_t pos, size_t n) const;

    size_t find_last_of(const char* s, size_t pos = OFString_npos) const;

    size_t find_last_of(char s, size_t pos = OFString_npos) const;

    size_t find_first_not_of(const OFString& str, size_t pos = 0) const;

    size_t find_first_not_of(const char* s, size_t pos, size_t n) const;

    size_t find_first_not_of(const char* s, size_t pos = 0) const;

    size_t find_first_not_of(char c, size_t pos = 0) const;

    size_t find_last_not_of(const OFString& str, size_t pos = OFString_npos) const;

    size_t find_last_not_of(const char* s, size_t pos, size_t n) const;

    size_t find_last_not_of(const char* s, size_t pos = OFString_npos) const;

    size_t find_last_not_of(char c, size_t pos = OFString_npos) const;

private:
    char* theCString;

    size_t theCapacity;

};


ostream& operator<< (ostream& o, const OFString& s);

istream& operator>> (istream& i, OFString& s);

OFString operator+ (const OFString& lhs, const OFString& rhs);

OFString operator+ (const char* lhs, const OFString& rhs);

OFString operator+ (char lhs, const OFString& rhs);

OFString operator+ (const OFString& lhs, const char* rhs);

OFString operator+ (const OFString& lhs, char rhs);

OFBool operator== (const OFString& lhs, const OFString& rhs);

OFBool operator== (const char* lhs, const OFString& rhs);

OFBool operator== (char lhs, const OFString& rhs);

OFBool operator== (const OFString& lhs, const char* rhs);

OFBool operator== (const OFString& lhs, char rhs);

OFBool operator< (const OFString& lhs, const OFString& rhs);

OFBool operator< (const char* lhs, const OFString& rhs);

OFBool operator< (char lhs, const OFString& rhs);

OFBool operator< (const OFString& lhs, const char* rhs);

OFBool operator< (const OFString& lhs, char rhs);

OFBool operator<= (const OFString& lhs, const OFString& rhs);

OFBool operator<= (const char* lhs, const OFString& rhs);

OFBool operator<= (char lhs, const OFString& rhs);

OFBool operator<= (const OFString& lhs, const char* rhs);

OFBool operator<= (const OFString& lhs, char rhs);

OFBool operator!= (const OFString& lhs, const OFString& rhs);

OFBool operator!= (const char* lhs, const OFString& rhs);

OFBool operator!= (char lhs, const OFString& rhs);

OFBool operator!= (const OFString& lhs, const char* rhs);

OFBool operator!= (const OFString& lhs, char rhs);

OFBool operator> (const OFString& lhs, const OFString& rhs);

OFBool operator> (const char* lhs, const OFString& rhs);

OFBool operator> (char lhs, const OFString& rhs);

OFBool operator> (const OFString& lhs, const char* rhs);

OFBool operator> (const OFString& lhs, char rhs);

OFBool operator>= (const OFString& lhs, const OFString& rhs);

OFBool operator>= (const char* lhs, const OFString& rhs);

OFBool operator>= (char lhs, const OFString& rhs);

OFBool operator>= (const OFString& lhs, const char* rhs);

OFBool operator>= (const OFString& lhs, char rhs);

#endif /* HAVE_STD_STRING */

#endif /* OFSTRING_H */


/*
** CVS/RCS Log:
** $Log: ofstring.h,v $
** Revision 1.20  2005/12/08 16:06:07  meichel
** Changed include path schema for all DCMTK header files
**
** Revision 1.19  2004/08/03 11:45:42  meichel
** Headers libc.h and unistd.h are now included via ofstdinc.h
**
** Revision 1.18  2004/01/16 10:30:12  joergr
** Removed acknowledgements with e-mail addresses from CVS log.
**
** Revision 1.17  2003/08/07 11:44:55  joergr
** Slightly modified header comments to conform to doxygen syntax.
**
** Revision 1.16  2003/07/09 13:57:43  meichel
** Adapted type casts to new-style typecast operators defined in ofcast.h
**
** Revision 1.15  2003/07/04 13:31:51  meichel
** Fixed issues with compiling with HAVE_STD_STRING
**
** Revision 1.14  2003/06/12 13:13:51  joergr
** Fixed inconsistent API documentation reported by Doxygen.
**
** Revision 1.13  2002/11/27 11:23:06  meichel
** Adapted module ofstd to use of new header file ofstdinc.h
**
** Revision 1.12  2002/04/16 13:36:03  joergr
** Added configurable support for C++ ANSI standard includes (e.g. streams).
**
** Revision 1.11  2001/12/04 16:48:16  meichel
** Completed doc++ documentation, fixed bug in OFString::copy.
**
** Revision 1.10  2001/11/02 13:18:53  meichel
** Removed character sequences that could be interpreted as ISO C++ trigraphs
**
** Revision 1.9  2001/06/01 15:51:35  meichel
** Updated copyright header
**
** Revision 1.8  2000/03/08 16:36:02  meichel
** Updated copyright header.
**
** Revision 1.7  2000/02/23 15:13:44  meichel
** Corrected macro for Borland C++ Builder 4 workaround.
**
** Revision 1.6  2000/02/01 10:09:37  meichel
** Avoiding to include <stdlib.h> as extern "C" on Borland C++ Builder 4,
**   workaround for bug in compiler header files.
**
** Revision 1.5  1998/11/27 12:42:52  joergr
** Added copyright message to source files and changed CVS header.
**
** Revision 1.4  1997/09/01 10:00:12  hewett
** Added absent $ terminator to RCS/CVS Revision keyword in header.
**
** Revision 1.3  1997/07/14 13:37:31  meichel
** Simplified OFString code to allow compilation with Sun CC 2.0.1
**
** Revision 1.2  1997/07/07 14:05:24  hewett
** Renamed the constant OFnpos to OFString_npos to look more like
** the real ANSI constant string::npos.
**
** Revision 1.1  1997/07/07 11:52:18  meichel
** Added string class OFString to ofstd library.
** This class implements a subset of the ANSI C++ "string" class.
**
**
*/

---

Generated on 20 Dec 2005 for OFFIS DCMTK Version 3.5.4 by Doxygen 1.4.5