src/cxx/StringHelper.hpp

   1 /*
   2  * StringHelper.hpp
   3  *
   4  * Copyright 2006,2007 Martin Quinson, Malek Cherier
   5  * All right reserved.
   6  *
   7  * This program is free software; you can redistribute
   8  * it and/or modify it under the terms of the license
   9  *(GNU LGPL) which comes with this package.
  10  *
  11  */
  12
  13 #ifndef STRING_HELPER_HPP
  14 #define STRING_HELPER_HPP
  15
  16  #ifndef __cplusplus
  17         #error StringHelper.hpp requires C++ compilation (use a .cxx suffix)
  18 #endif
  19
  20 #include <string>
  21 using std::string;
  22
  23 #include<iostream>
  24 using std::ostream;
  25 using std::istream;
  26
  27 #include <Config.hpp>
  28
  29 // namespace SimGrid::Msg
  30 namespace SimGrid
  31 {
  32         namespace Msg
  33         {
  34                 class SIMGRIDX_EXPORT StringHelper
  35                 {
  36                         public:
  37
  38                                 // Default constructor
  39                                         StringHelper();
  40
  41                                         StringHelper(unsigned char c);
  42
  43                                         StringHelper(unsigned char c, int n);
  44
  45                                         StringHelper(char c);
  46
  47                                         StringHelper(char c, int n);
  48
  49                                         StringHelper(const char* cstr);
  50
  51                                         StringHelper(const char* cstr, int n);
  52
  53                                         StringHelper(const char* cstr, int pos, int n);
  54
  55                                         StringHelper(const string& rstr);
  56
  57                                         StringHelper(const string& rstr, int n);
  58
  59                                         StringHelper(const string& rstr, int pos, int n);
  60
  61                                         StringHelper(short si);
  62
  63                                         StringHelper(int i);
  64
  65                                         StringHelper(long l);
  66
  67                                         StringHelper(float f);
  68
  69                                         StringHelper(double d);
  70
  71                                         StringHelper(double d, const char* format);
  72
  73                                         StringHelper(unsigned short usi);
  74
  75                                         StringHelper(unsigned int ui);
  76
  77                                         StringHelper(unsigned long ul);
  78
  79                                 // Copy constructor
  80                                         StringHelper(const StringHelper& rStringHelper);
  81
  82                                 // Destructor
  83                                         ~StringHelper();
  84
  85                                 // Operations
  86
  87                                         StringHelper& append(unsigned char c);
  88
  89                                         StringHelper& append(unsigned char c, int n);
  90
  91                                         StringHelper& append(char c);
  92
  93                                         StringHelper& append(char c, int n);
  94
  95                                         StringHelper& append(const char* cstr);
  96
  97                                         StringHelper& append(const char* cstr, int n);
  98
  99                                         StringHelper& append(const char* cstr, int pos, int n);
 100
 101                                         StringHelper& append(const string& rstr);
 102
 103                                         StringHelper& append(const string& rstr, int n);
 104
 105                                         StringHelper& append(const string& rstr, int pos, int n);
 106
 107                                         StringHelper& append(short si);
 108
 109                                         StringHelper& append(int i);
 110
 111                                         StringHelper& append(long l);
 112
 113                                         StringHelper& append(float f);
 114
 115                                         StringHelper& append(double d);
 116
 117                                         StringHelper& append(double d, const char* format);
 118
 119                                         StringHelper& append(unsigned short usi);
 120
 121                                         StringHelper& append(unsigned int ui);
 122
 123                                         StringHelper& append(unsigned long ul);
 124
 125                                 const char& at(int pos) const;
 126
 127                                 char& at(int pos);
 128
 129                                         const char* cstr(void) const;
 130
 131                                         string& toString(void);
 132
 133                                         int size(void) const;
 134
 135                                         void clear(void);
 136
 137                                         bool empty(void);
 138
 139                                 //  Operators
 140
 141                                         // Assignement
 142                                         StringHelper& operator = (const StringHelper& rStringHelper);
 143
 144                                         StringHelper& operator = (const char* cstr);
 145
 146                                         StringHelper& operator = (const string& str);
 147
 148                                         StringHelper& operator = (short n);
 149
 150                                         StringHelper& operator = (int n);
 151
 152                                         StringHelper& operator = (long n);
 153
 154                                         StringHelper& operator = (float n);
 155
 156                                         StringHelper& operator = (double n);
 157
 158                                         StringHelper& operator = (unsigned short n);
 159
 160                                         StringHelper& operator = (unsigned int n);
 161
 162                                         StringHelper& operator = (unsigned long n);
 163
 164                                         char& operator[](int pos);
 165
 166                                         char operator[](int pos) const;
 167
 168                                         StringHelper& operator += (short n);
 169
 170                                         StringHelper& operator += (int n);
 171
 172                                         StringHelper& operator += (long n);
 173
 174                                         StringHelper& operator += (float n);
 175
 176                                         StringHelper& operator += (double n);
 177
 178                                         StringHelper& operator += (unsigned short n);
 179
 180                                         StringHelper& operator += (unsigned int n);
 181
 182                                         StringHelper& operator += (unsigned long n);
 183
 184                                         StringHelper& operator += (const StringHelper& rStringHelper);
 185
 186                                         StringHelper& operator += (const string& rstr);
 187
 188                                 StringHelper& operator += (const char* cstr);
 189
 190                                 StringHelper& operator += (char c);
 191
 192                                         StringHelper& operator + (short n);
 193
 194                                         StringHelper& operator + (int n);
 195
 196                                         StringHelper& operator + (long n);
 197
 198                                         StringHelper& operator + (float n);
 199
 200                                         StringHelper& operator + (double n);
 201
 202                                         StringHelper& operator + (unsigned short n);
 203
 204                                         StringHelper& operator + (unsigned int n);
 205
 206                                         StringHelper& operator + (unsigned long n);
 207
 208                                         StringHelper& operator + (const StringHelper& rStringHelper);
 209
 210                                         StringHelper& operator + (const string& rstr);
 211
 212                                 StringHelper& operator + (const char* cstr);
 213
 214                                 StringHelper& operator + (char c);
 215
 216                                         operator char *();
 217
 218                                         operator const char *();
 219
 220                                         friend SIMGRIDX_EXPORT ostream& operator<<(ostream& stream, const StringHelper& s);
 221
 222                                         friend SIMGRIDX_EXPORT istream& operator<<(istream& stream, StringHelper& s);
 223
 224                                 private:
 225
 226                                         // Methods
 227                                         void init(void);
 228
 229                                         // Attributes
 230
 231                                         char* content;
 232                                         int capacity;
 233                                         int len;
 234                 };
 235
 236                 typedef class StringHelper* StringHelperPtr;
 237
 238                 #define TEXT_(___x)     StringHelper((___x))
 239
 240
 241         } // namespace Msg
 242 } // namespace SimGrid
 243
 244
 245 #endif // !STRING_HELPER_HPP
 246