1

/* $Id$ */

     2

     3

/** @file str.hpp */

     4

     5

#ifndef  STR_HPP

     6

#define  STR_HPP

     7

     8

#include <errno.h>

     9

#include <stdarg.h>

    10

#include "strapi.hpp"

    11

    12

/** Blob based string. */

    13

template <typename Tchar, bool TcaseInsensitive>

    14

struct CStrT : public CBlobT<Tchar>

    15

{

    16

	typedef CBlobT<Tchar> base;                    ///< base class

    17

	typedef CStrApiT<Tchar, TcaseInsensitive> Api; ///< string API abstraction layer

    18

	typedef typename base::bsize_t bsize_t;        ///< size type inherited from blob

    19

	typedef typename base::OnTransfer OnTransfer;  ///< temporary 'transfer ownership' object type

    20

    21

	/** Construction from C zero ended string. */

    22

	FORCEINLINE CStrT(const Tchar* str = NULL)

    23

	{

    24

		AppendStr(str);

    25

	}

    26

    27

	/** Construction from C string and given number of characters. */

    28

	FORCEINLINE CStrT(const Tchar* str, bsize_t num_chars) : base(str, num_chars)

    29

	{

    30

		base::FixTail();

    31

	}

    32

    33

	/** Construction from C string determined by 'begin' and 'end' pointers. */

    34

	FORCEINLINE CStrT(const Tchar* str, const Tchar* end)

    35

		: base(str, end - str)

    36

	{

    37

		base::FixTail();

    38

	}

    39

    40

	/** Construction from blob contents. */

    41

	FORCEINLINE CStrT(const CBlobBaseSimple& src)

    42

		: base(src)

    43

	{

    44

		base::FixTail();

    45

	}

    46

    47

	/** Copy constructor. */

    48

	FORCEINLINE CStrT(const CStrT& src)

    49

		: base(src)

    50

	{

    51

		base::FixTail();

    52

	}

    53

    54

	/** Take over ownership constructor */

    55

	FORCEINLINE CStrT(const OnTransfer& ot)

    56

		: base(ot)

    57

	{

    58

	}

    59

    60

	/** Grow the actual buffer and fix the trailing zero at the end. */

    61

	FORCEINLINE Tchar* GrowSizeNC(bsize_t count)

    62

	{

    63

		Tchar* ret = base::GrowSizeNC(count);

    64

		base::FixTail();

    65

		return ret;

    66

	}

    67

    68

	/** Append zero-ended C string. */

    69

	FORCEINLINE void AppendStr(const Tchar* str)

    70

	{

    71

		if (str != NULL && str[0] != '\0') {

    72

			base::Append(str, (bsize_t)Api::StrLen(str));

    73

			base::FixTail();

    74

		}

    75

	}

    76

    77

	/** Append another CStrT or blob. */

    78

	FORCEINLINE void Append(const CBlobBaseSimple& src)

    79

	{

    80

		if (src.RawSize() > 0) {

    81

			base::AppendRaw(src);

    82

			base::FixTail();

    83

		}

    84

	}

    85

    86

	/** Assignment from C string. */

    87

	FORCEINLINE CStrT& operator = (const Tchar* src)

    88

	{

    89

		base::Clear();

    90

		AppendStr(src);

    91

		return *this;

    92

	}

    93

    94

	/** Assignment from another CStrT or blob. */

    95

	FORCEINLINE CStrT& operator = (const CBlobBaseSimple& src)

    96

	{

    97

		base::Clear();

    98

		base::AppendRaw(src);

    99

		base::FixTail();

   100

		return *this;

   101

	}

   102

   103

	/** Assignment from another CStrT or blob. */

   104

	FORCEINLINE CStrT& operator = (const CStrT& src)

   105

	{

   106

		base::Clear();

   107

		base::AppendRaw(src);

   108

		base::FixTail();

   109

		return *this;

   110

	}

   111

   112

	/** Lower-than operator (to support stl collections) */

   113

	FORCEINLINE bool operator < (const CStrT &other) const

   114

	{

   115

		return (Api::StrCmp(base::Data(), other.Data()) < 0);

   116

	}

   117

   118

	/** Add formated string (like vsprintf) at the end of existing contents. */

   119

	int AddFormatL(const Tchar *format, va_list args)

   120

	{

   121

		bsize_t addSize = Api::StrLen(format);

   122

		if (addSize < 16) addSize = 16;

   123

		addSize += addSize / 2;

   124

		int ret;

   125

		int err = 0;

   126

		for (;;) {

   127

			Tchar *buf = MakeFreeSpace(addSize);

   128

			ret = Api::SPrintFL(buf, base::GetReserve(), format, args);

   129

			if (ret >= base::GetReserve()) {

   130

				/* Greater return than given count means needed buffer size. */

   131

				addSize = ret + 1;

   132

				continue;

   133

			}

   134

			if (ret >= 0) {

   135

				/* success */

   136

				break;

   137

			}

   138

			err = errno;

   139

			if (err != ERANGE && err != ENOENT && err != 0) {

   140

				/* some strange failure */

   141

				break;

   142

			}

   143

			/* small buffer (M$ implementation) */

   144

			addSize *= 2;

   145

		}

   146

		if (ret > 0) {

   147

			GrowSizeNC(ret);

   148

		} else {

   149

			base::FixTail();

   150

		}

   151

		return ret;

   152

	}

   153

   154

	/** Add formated string (like sprintf) at the end of existing contents. */

   155

	int AddFormat(const Tchar *format, ...)

   156

	{

   157

		va_list args;

   158

		va_start(args, format);

   159

		int ret = AddFormatL(format, args);

   160

		va_end(args);

   161

		return ret;

   162

	}

   163

   164

	/** Assign formated string (like vsprintf). */

   165

	int FormatL(const Tchar *format, va_list args)

   166

	{

   167

		base::Free();

   168

		int ret = AddFormatL(format, args);

   169

		return ret;

   170

	}

   171

   172

	/** Assign formated string (like sprintf). */

   173

	int Format(const Tchar *format, ...)

   174

	{

   175

		base::Free();

   176

		va_list args;

   177

		va_start(args, format);

   178

		int ret = AddFormatL(format, args);

   179

		va_end(args);

   180

		return ret;

   181

	}

   182

};

   183

   184

typedef CStrT<char   , false> CStrA;   ///< Case sensitive ANSI/UTF-8 string

   185

typedef CStrT<char   , true > CStrCiA; ///< Case insensitive ANSI/UTF-8 string

   186

#if defined(HAS_WCHAR)

   187

typedef CStrT<wchar_t, false> CStrW;   ///< Case sensitive unicode string

   188

typedef CStrT<wchar_t, true > CStrCiW; ///< Case insensitive unicode string

   189

#endif /* HAS_WCHAR */

   190

   191

#endif /* STR_HPP */