Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
change consecutive to the renaming of the CXX wrappers
[simgrid.git] / src / cxx / StringHelper.hpp
index a1675d3..ebf3a8b 100644 (file)
-/*\r
- * StringHelper.hpp\r
- *\r
- * Copyright 2006,2007 Martin Quinson, Malek Cherier           \r
- * All right reserved. \r
- *\r
- * This program is free software; you can redistribute \r
- * it and/or modify it under the terms of the license \r
- *(GNU LGPL) which comes with this package. \r
- *\r
- */  \r
\r
-#ifndef STRING_HELPER_HPP\r
-#define STRING_HELPER_HPP\r
-\r
- #ifndef __cplusplus\r
-       #error StringHelper.hpp requires C++ compilation (use a .cxx suffix)\r
-#endif\r
-\r
-#include <string>\r
-using std::string;\r
-\r
-#include<iostream>\r
-using std::ostream;\r
-using std::istream;\r
-\r
-#include <Config.hpp>\r
-\r
-// namespace SimGrid::Msg\r
-namespace SimGrid\r
-{\r
-       namespace Msg\r
-       {\r
-               class SIMGRIDX_EXPORT StringHelper\r
-               {\r
-                       public:\r
-                               \r
-                               // Default constructor\r
-                                       StringHelper();\r
-\r
-                                       StringHelper(unsigned char c);\r
-                               \r
-                                       StringHelper(unsigned char c, int n);\r
-                               \r
-                                       StringHelper(char c);\r
-                               \r
-                                       StringHelper(char c, int n);\r
-                               \r
-                                       StringHelper(const char* cstr);\r
-                                       \r
-                                       StringHelper(const char* cstr, int n);\r
-                                       \r
-                                       StringHelper(const char* cstr, int pos, int n);\r
-                                       \r
-                                       StringHelper(const string& rstr);\r
-                                       \r
-                                       StringHelper(const string& rstr, int n);\r
-                                       \r
-                                       StringHelper(const string& rstr, int pos, int n);\r
-                                       \r
-                                       StringHelper(short si);\r
-                                       \r
-                                       StringHelper(int i);\r
-                                       \r
-                                       StringHelper(long l);\r
-                                       \r
-                                       StringHelper(float f);\r
-                                       \r
-                                       StringHelper(double d);\r
-\r
-                                       StringHelper(double d, const char* format);\r
-                                       \r
-                                       StringHelper(unsigned short usi);\r
-                                       \r
-                                       StringHelper(unsigned int ui);\r
-                                       \r
-                                       StringHelper(unsigned long ul);\r
-                               \r
-                               // Copy constructor\r
-                                       StringHelper(const StringHelper& rStringHelper);\r
-                               \r
-                               // Destructor\r
-                                       ~StringHelper();\r
-\r
-                               // Operations\r
-                               \r
-                                       StringHelper& append(unsigned char c);\r
-                               \r
-                                       StringHelper& append(unsigned char c, int n);\r
-                               \r
-                                       StringHelper& append(char c);\r
-                               \r
-                                       StringHelper& append(char c, int n);\r
-                               \r
-                                       StringHelper& append(const char* cstr);\r
-                                       \r
-                                       StringHelper& append(const char* cstr, int n);\r
-                                       \r
-                                       StringHelper& append(const char* cstr, int pos, int n);\r
-                                       \r
-                                       StringHelper& append(const string& rstr);\r
-                                       \r
-                                       StringHelper& append(const string& rstr, int n);\r
-                                       \r
-                                       StringHelper& append(const string& rstr, int pos, int n);\r
-                                       \r
-                                       StringHelper& append(short si);\r
-                                       \r
-                                       StringHelper& append(int i);\r
-                                       \r
-                                       StringHelper& append(long l);\r
-                                       \r
-                                       StringHelper& append(float f);\r
-                                       \r
-                                       StringHelper& append(double d);\r
-                                       \r
-                                       StringHelper& append(double d, const char* format);\r
-                                       \r
-                                       StringHelper& append(unsigned short usi);\r
-                                       \r
-                                       StringHelper& append(unsigned int ui);\r
-                                       \r
-                                       StringHelper& append(unsigned long ul);\r
-                                       \r
-                               const char& at(int pos) const;\r
-                               \r
-                               char& at(int pos);\r
-                                       \r
-                                       const char* cstr(void) const;\r
-                                       \r
-                                       string& toString(void);\r
-                                       \r
-                                       int size(void) const;\r
-\r
-                                       void clear(void);\r
-\r
-                                       bool empty(void);\r
-                                       \r
-                               //  Operators\r
-                                       \r
-                                       // Assignement\r
-                                       StringHelper& operator = (const StringHelper& rStringHelper);\r
-                                       \r
-                                       StringHelper& operator = (const char* cstr);\r
-                                       \r
-                                       StringHelper& operator = (const string& str);\r
-                                       \r
-                                       StringHelper& operator = (short n);\r
-                                       \r
-                                       StringHelper& operator = (int n);\r
-                                       \r
-                                       StringHelper& operator = (long n);\r
-                                       \r
-                                       StringHelper& operator = (float n);\r
-                                       \r
-                                       StringHelper& operator = (double n);\r
-                                       \r
-                                       StringHelper& operator = (unsigned short n);\r
-                                       \r
-                                       StringHelper& operator = (unsigned int n);\r
-                                       \r
-                                       StringHelper& operator = (unsigned long n);\r
-                                       \r
-                                       char& operator[](int pos);\r
-                                       \r
-                                       char operator[](int pos) const;\r
-                                       \r
-                                       StringHelper& operator += (short n);\r
-                                       \r
-                                       StringHelper& operator += (int n);\r
-                                       \r
-                                       StringHelper& operator += (long n);\r
-                                       \r
-                                       StringHelper& operator += (float n);\r
-                                       \r
-                                       StringHelper& operator += (double n);\r
-                                       \r
-                                       StringHelper& operator += (unsigned short n);\r
-                                       \r
-                                       StringHelper& operator += (unsigned int n);\r
-                                       \r
-                                       StringHelper& operator += (unsigned long n);\r
-                                       \r
-                                       StringHelper& operator += (const StringHelper& rStringHelper);\r
-                                       \r
-                                       StringHelper& operator += (const string& rstr);\r
-                                       \r
-                               StringHelper& operator += (const char* cstr);\r
-                               \r
-                               StringHelper& operator += (char c);\r
-                               \r
-                                       StringHelper& operator + (short n);\r
-                                       \r
-                                       StringHelper& operator + (int n);\r
-                                       \r
-                                       StringHelper& operator + (long n);\r
-                                       \r
-                                       StringHelper& operator + (float n);\r
-                                       \r
-                                       StringHelper& operator + (double n);\r
-                                       \r
-                                       StringHelper& operator + (unsigned short n);\r
-                                       \r
-                                       StringHelper& operator + (unsigned int n);\r
-                                       \r
-                                       StringHelper& operator + (unsigned long n);\r
-                                       \r
-                                       StringHelper& operator + (const StringHelper& rStringHelper);\r
-                                       \r
-                                       StringHelper& operator + (const string& rstr);\r
-                                       \r
-                               StringHelper& operator + (const char* cstr);\r
-                               \r
-                               StringHelper& operator + (char c);\r
-\r
-                                       operator char *();\r
-\r
-                                       operator const char *();\r
-\r
-                                       friend SIMGRIDX_EXPORT ostream& operator<<(ostream& stream, const StringHelper& s);\r
-\r
-                                       friend SIMGRIDX_EXPORT istream& operator<<(istream& stream, StringHelper& s);\r
-                               \r
-                               private:\r
-\r
-                                       // Methods\r
-                                       void init(void);\r
-                                       \r
-                                       // Attributes\r
-                                       \r
-                                       char* content;\r
-                                       int capacity;\r
-                                       int len;\r
-               };\r
-               \r
-               typedef class StringHelper* StringHelperPtr;\r
-\r
-               #define TEXT_(___x)     StringHelper((___x))\r
-\r
-\r
-       } // namespace Msg\r
-} // namespace SimGrid\r
-\r
-\r
-#endif // !STRING_HELPER_HPP
\ No newline at end of file
+/*
+ * StringHelper.hpp
+ *
+ * Copyright 2006,2007 Martin Quinson, Malek Cherier           
+ * All right reserved. 
+ *
+ * This program is free software; you can redistribute 
+ * it and/or modify it under the terms of the license 
+ *(GNU LGPL) which comes with this package. 
+ *
+ */  
+#ifndef STRING_HELPER_HPP
+#define STRING_HELPER_HPP
+
+ #ifndef __cplusplus
+       #error StringHelper.hpp requires C++ compilation (use a .cxx suffix)
+#endif
+
+#include <string>
+using std::string;
+
+#include<iostream>
+using std::ostream;
+using std::istream;
+
+#include <Config.hpp>
+
+// namespace SimGrid::Msg
+namespace SimGrid
+{
+       namespace Msg
+       {
+               class SIMGRIDX_EXPORT StringHelper
+               {
+                       public:
+                               
+                               // Default constructor
+                                       StringHelper();
+
+                                       StringHelper(unsigned char c);
+                               
+                                       StringHelper(unsigned char c, int n);
+                               
+                                       StringHelper(char c);
+                               
+                                       StringHelper(char c, int n);
+                               
+                                       StringHelper(const char* cstr);
+                                       
+                                       StringHelper(const char* cstr, int n);
+                                       
+                                       StringHelper(const char* cstr, int pos, int n);
+                                       
+                                       StringHelper(const string& rstr);
+                                       
+                                       StringHelper(const string& rstr, int n);
+                                       
+                                       StringHelper(const string& rstr, int pos, int n);
+                                       
+                                       StringHelper(short si);
+                                       
+                                       StringHelper(int i);
+                                       
+                                       StringHelper(long l);
+                                       
+                                       StringHelper(float f);
+                                       
+                                       StringHelper(double d);
+
+                                       StringHelper(double d, const char* format);
+                                       
+                                       StringHelper(unsigned short usi);
+                                       
+                                       StringHelper(unsigned int ui);
+                                       
+                                       StringHelper(unsigned long ul);
+                               
+                               // Copy constructor
+                                       StringHelper(const StringHelper& rStringHelper);
+                               
+                               // Destructor
+                                       ~StringHelper();
+
+                               // Operations
+                               
+                                       StringHelper& append(unsigned char c);
+                               
+                                       StringHelper& append(unsigned char c, int n);
+                               
+                                       StringHelper& append(char c);
+                               
+                                       StringHelper& append(char c, int n);
+                               
+                                       StringHelper& append(const char* cstr);
+                                       
+                                       StringHelper& append(const char* cstr, int n);
+                                       
+                                       StringHelper& append(const char* cstr, int pos, int n);
+                                       
+                                       StringHelper& append(const string& rstr);
+                                       
+                                       StringHelper& append(const string& rstr, int n);
+                                       
+                                       StringHelper& append(const string& rstr, int pos, int n);
+                                       
+                                       StringHelper& append(short si);
+                                       
+                                       StringHelper& append(int i);
+                                       
+                                       StringHelper& append(long l);
+                                       
+                                       StringHelper& append(float f);
+                                       
+                                       StringHelper& append(double d);
+                                       
+                                       StringHelper& append(double d, const char* format);
+                                       
+                                       StringHelper& append(unsigned short usi);
+                                       
+                                       StringHelper& append(unsigned int ui);
+                                       
+                                       StringHelper& append(unsigned long ul);
+                                       
+                               const char& at(int pos) const;
+                               
+                               char& at(int pos);
+                                       
+                                       const char* cstr(void) const;
+                                       
+                                       string& toString(void);
+                                       
+                                       int size(void) const;
+
+                                       void clear(void);
+
+                                       bool empty(void);
+                                       
+                               //  Operators
+                                       
+                                       // Assignement
+                                       StringHelper& operator = (const StringHelper& rStringHelper);
+                                       
+                                       StringHelper& operator = (const char* cstr);
+                                       
+                                       StringHelper& operator = (const string& str);
+                                       
+                                       StringHelper& operator = (short n);
+                                       
+                                       StringHelper& operator = (int n);
+                                       
+                                       StringHelper& operator = (long n);
+                                       
+                                       StringHelper& operator = (float n);
+                                       
+                                       StringHelper& operator = (double n);
+                                       
+                                       StringHelper& operator = (unsigned short n);
+                                       
+                                       StringHelper& operator = (unsigned int n);
+                                       
+                                       StringHelper& operator = (unsigned long n);
+                                       
+                                       char& operator[](int pos);
+                                       
+                                       char operator[](int pos) const;
+                                       
+                                       StringHelper& operator += (short n);
+                                       
+                                       StringHelper& operator += (int n);
+                                       
+                                       StringHelper& operator += (long n);
+                                       
+                                       StringHelper& operator += (float n);
+                                       
+                                       StringHelper& operator += (double n);
+                                       
+                                       StringHelper& operator += (unsigned short n);
+                                       
+                                       StringHelper& operator += (unsigned int n);
+                                       
+                                       StringHelper& operator += (unsigned long n);
+                                       
+                                       StringHelper& operator += (const StringHelper& rStringHelper);
+                                       
+                                       StringHelper& operator += (const string& rstr);
+                                       
+                               StringHelper& operator += (const char* cstr);
+                               
+                               StringHelper& operator += (char c);
+                               
+                                       StringHelper& operator + (short n);
+                                       
+                                       StringHelper& operator + (int n);
+                                       
+                                       StringHelper& operator + (long n);
+                                       
+                                       StringHelper& operator + (float n);
+                                       
+                                       StringHelper& operator + (double n);
+                                       
+                                       StringHelper& operator + (unsigned short n);
+                                       
+                                       StringHelper& operator + (unsigned int n);
+                                       
+                                       StringHelper& operator + (unsigned long n);
+                                       
+                                       StringHelper& operator + (const StringHelper& rStringHelper);
+                                       
+                                       StringHelper& operator + (const string& rstr);
+                                       
+                               StringHelper& operator + (const char* cstr);
+                               
+                               StringHelper& operator + (char c);
+
+                                       operator char *();
+
+                                       operator const char *();
+
+                                       friend SIMGRIDX_EXPORT ostream& operator<<(ostream& stream, const StringHelper& s);
+
+                                       friend SIMGRIDX_EXPORT istream& operator<<(istream& stream, StringHelper& s);
+                               
+                               private:
+
+                                       // Methods
+                                       void init(void);
+                                       
+                                       // Attributes
+                                       
+                                       char* content;
+                                       int capacity;
+                                       int len;
+               };
+               
+               typedef class StringHelper* StringHelperPtr;
+
+               #define TEXT_(___x)     StringHelper((___x))
+
+
+       } // namespace Msg
+} // namespace SimGrid
+
+
+#endif // !STRING_HELPER_HPP
+