src/cxx/StringHelper.hpp

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