---

CString.h

Go to the documentation of this file.

/* --------------------------------------------------------------
Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-------------------------------------------------------------- */
#ifndef _CSTRING__H
#define _CSTRING__H

/*
 * This weird construction is due to the fact that both CString.h and the Orbacus header files
 * insist on defining these.
 * To avoid compiler problems they must be undefined to be able to define them...
 */
#ifdef HAVE_STDIO_H
#undef HAVE_STDIO_H
#endif
#ifdef HAVE_STRING_H
#undef HAVE_STRING_H
#endif
#ifdef HAVE_STDLIB_H
#undef HAVE_STDLIB_H
#endif

#ifdef _WIN32
#define HAVE_STDIO_H 1
#define HAVE_STDARG_H 1
#define HAVE_CTYPE_H 1
#define HAVE_STRING_H 1
#define HAVE_STDLIB_H 1
#else
#include "config.h"
#endif

#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#ifdef HAVE_STDARG_H
#include <stdarg.h>
#endif
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#if !HAVE_SETENV
extern "C" {
int setenv (const char *name, const char *value, int overwrite);
}
#endif

#define CString CString_

#ifndef CSTR_WASTE_LIMIT

#define CSTR_WASTE_LIMIT 32
#endif

#ifndef CSTR_REUSE_ALLOC

#define CSTR_REUSE_ALLOC 16
#endif

typedef void (*CSTRING_CRIT) (void *hLock, bool setLock);

extern void CString_init (void *hLock = NULL, CSTRING_CRIT locker = NULL);

extern void CString_term ();

#ifdef CSTR_PROFL_USAGE

extern void CString_stat ();
extern void CString_statReset ();
#endif

class CString_ {
    friend class CString_support;
private:
    char *s;
    size_t l;
    size_t r;
public:
    void MakeLower();
    void MakeUpper();
    CString_ ();
    CString_ (const char *psz);
    CString_ (const unsigned char *psz);
    CString_ (const CString_ & stringSrc);
    CString_ (const char *psz, const size_t siz);
    CString_ (const unsigned char *psz, const size_t siz);
    const CString_ & operator = (const CString_ & stringSrc);
    const CString_ & operator = (const char *psz);
    const CString_ & operator = (const unsigned char *psz);
    ~CString_ ();
    void Empty ();
    const CString_ & operator += (const CString_ & string);
    const CString_ & operator += (char ch);
    const CString_ & operator += (const char * psz);
    friend CString_ operator + (const CString_ & string, const char * lpsz);
    
    operator const char * () const {
        return s;
    };
    void Format (const char *fmt, ...);
    int CompareNoCase (const CString_ &string) const
    {
#ifdef _WIN32
        return stricmp (s, string.s);
#else
        return strcasecmp (s, string.s);
#endif
    };
    int Compare (const CString_ &string) const
    {
        return strcmp (s, string.s);
    };
    int GetLength () const
    {
        return l;
    };
    bool IsEmpty ()
    {
        return l == 0;
    };
    char GetAt (int p)
    {
        if (p >= 0 && p <= (int) l) {
            return s [p];
        }
        return 0;
    };
    void SetAt (int p, char ch)
    {
        if (p >= 0 && p <= (int) l) {
            s [p] = ch;
        }
    };
    CString_ Mid (int nFirst, int nCount = -1) const;
    int Find (int ch, int startAt = 0) const {
        if (startAt < 0 || startAt >= (int) l) return -1;
        char *s2 = strchr (s + startAt, ch);
        if (s2) return s2 - s;
        return -1;
    };
    int Find (const char *str, int startAt = 0) const {
        if (startAt < 0 || startAt >= (int) l) return -1;
        char *s2 = strstr (s + startAt, str);
        if (s2) return s2 - s;
        return -1;
    };
    int ReverseFind (int ch) const {
        char *s2 = strrchr (s, ch);
        if (s2) return s2 - s;
        return -1;
    };
    CString_ Left (int nCount) const {
        if (nCount < 0) nCount = 0;
        return Mid (0, nCount);
    };
    CString_ Right (int nCount) const {
        if (nCount < 0) nCount = 0;
        return Mid (GetLength () - nCount);
    };
};


inline bool operator == (const CString_ & s1, const CString_ & s2) {
    return s1.Compare (s2) == 0;
}

inline bool operator == (const CString_ & s1, const char * s2) {
    return s1.Compare (s2) == 0;
}

inline bool operator == (const char * s1, const CString_ & s2) {
    return s2.Compare (s1) == 0;
}

inline bool operator != (const CString_ & s1, const CString_ & s2) {
    return s1.Compare (s2) != 0;
}


inline bool operator != (const CString_ & s1, const char * s2) {
    return s1.Compare (s2) != 0;
}


inline bool operator != (const char * s1, const CString_ & s2) {
    return s2.Compare (s1) != 0;
}


inline bool operator < (const CString_ & s1, const CString_ & s2) {
    return s1.Compare (s2) < 0;
}

inline bool operator < (const CString_ & s1, const char * s2) {
    return s1.Compare (s2) < 0;
}

inline bool operator < (const char * s1, const CString_ & s2) {
    return s2.Compare (s1) > 0;
}

inline bool operator > (const CString_ & s1, const CString_ & s2) {
    return s1.Compare (s2) > 0;
}

inline bool operator > (const CString_ & s1, const char * s2) {
    return s1.Compare (s2) > 0;
}

inline bool operator > (const char * s1, const CString_ & s2) {
    return s2.Compare (s1) < 0;
}

inline bool operator <= (const CString_ & s1, const CString_ & s2) {
    return s1.Compare (s2) <= 0;
}

inline bool operator <= (const CString_ & s1, const char * s2) {
    return s1.Compare (s2) <= 0;
}

inline bool operator <= (const char * s1, const CString_ & s2) {
    return s2.Compare (s1) >= 0;
}

inline bool operator >= (const CString_ & s1, const CString_ & s2) {
    return s1.Compare (s2) >= 0;
}

inline bool operator >= (const CString_ & s1, const char * s2) {
    return s1.Compare (s2) >= 0;
}

inline bool operator >= (const char * s1, const CString_ & s2) {
    return s2.Compare (s1) <= 0;
}

#endif // defined _CSTRING__H

---