diff options
Diffstat (limited to 'Src/Plugins/Visualization/vis_milk2/gstring.h')
| -rw-r--r-- | Src/Plugins/Visualization/vis_milk2/gstring.h | 229 |
1 files changed, 229 insertions, 0 deletions
diff --git a/Src/Plugins/Visualization/vis_milk2/gstring.h b/Src/Plugins/Visualization/vis_milk2/gstring.h new file mode 100644 index 00000000..c7134645 --- /dev/null +++ b/Src/Plugins/Visualization/vis_milk2/gstring.h @@ -0,0 +1,229 @@ +#ifndef __GSTRING_SMART_STRING_CLASS__ +#define __GSTRING_SMART_STRING_CLASS__ 1 + +// This is just a streamlined version of std::string. +// It cleans itself up automatically, it can copy itself, +// test for equality, etc. +// and you can use .c_str() to get the string const, so it's +// sytactically the same (usage-wise) as std::string. +// Written by Ryan Geiss. + +#include <windows.h> + +class GString +{ +public: + GString() + { + m_data = new wchar_t[1]; + m_data[0] = 0; + m_size = 1; + } + + GString(const wchar_t* src) + { + m_data = NULL; + m_size = 0; + operator=(src); + } + + GString(const GString &src_string) + { + m_data = NULL; + m_size = 0; + operator=(src_string); + } + + ~GString() + { + delete m_data; // note: delete is safe on NULL ptrs + m_data = NULL; + m_size = 0; + } + + inline GString& operator=(const wchar_t* src) + { + if (src != m_data) // don't do anything on "x = x.c_str();" + { + delete m_data; // note: delete is safe on NULL ptrs + if (src) + { + m_size = wcslen(src)+1; + m_data = new wchar_t[m_size]; + memcpy(m_data, src, m_size*2); + } + else + { + m_size = 1; + m_data = new wchar_t[1]; + m_data[0] = 0; + } + } + return *this; + } + + inline GString& operator=(const GString &src_string) + { + if (&src_string != this) // don't do anything on "x = x;" + { + if (src_string.GetSize() != m_size) //optimization + { + delete m_data; + m_size = src_string.GetSize(); + m_data = new wchar_t[m_size]; + } + memcpy(m_data, src_string.c_str(), m_size*2); + } + return *this; + } + + inline wchar_t operator[](int index) const + { + return m_data[index]; + } + + inline bool operator==(const wchar_t* comp) + { + return (wcscmp(m_data,comp) == 0); + } + + inline bool operator==(const GString &comp) + { + if (m_size != comp.m_size) // shortcut + return false; + return (wcscmp(m_data,comp.c_str()) == 0); //return operator==(comp.m_data); + } + + inline const wchar_t* c_str() const + { + return m_data; + } + + // This is actually unsafe, but we need it for convenience, unless we really + // feel like copying all data twice. BE WARNED! When this class reallocates + // memory, all old references to _data are invalid! + //operator const char*() const { return _data; } + inline int GetSize() const //in bytes - including terminating NULL char. + { + return m_size; + } + + inline int GetLength() const + { + return (m_size >= 1) ? m_size-1 : 0; + } + +private: + wchar_t* m_data; + int m_size; +}; + +class GStringA +{ +public: + GStringA() + { + m_data = new char[1]; + m_data[0] = 0; + m_size = 1; + } + + GStringA(const char* src) + { + m_data = NULL; + m_size = 0; + operator=(src); + } + + GStringA(const GStringA &src_string) + { + m_data = NULL; + m_size = 0; + operator=(src_string); + } + + ~GStringA() + { + delete m_data; // note: delete is safe on NULL ptrs + m_data = NULL; + m_size = 0; + } + + inline GStringA& operator=(const char* src) + { + if (src != m_data) // don't do anything on "x = x.c_str();" + { + delete m_data; // note: delete is safe on NULL ptrs + if (src) + { + m_size = strlen(src)+1; + m_data = new char[m_size]; + memcpy(m_data, src, m_size); + } + else + { + m_size = 1; + m_data = new char[1]; + m_data[0] = 0; + } + } + return *this; + } + + inline GStringA& operator=(const GStringA &src_string) + { + if (&src_string != this) // don't do anything on "x = x;" + { + if (src_string.GetSize() != m_size) //optimization + { + delete m_data; + m_size = src_string.GetSize(); + m_data = new char[m_size]; + } + memcpy(m_data, src_string.c_str(), m_size); + } + return *this; + } + + inline char operator[](int index) const + { + return m_data[index]; + } + + inline bool operator==(const char* comp) + { + return (strcmp(m_data,comp) == 0); + } + + inline bool operator==(const GStringA &comp) + { + if (m_size != comp.m_size) // shortcut + return false; + return (strcmp(m_data,comp.c_str()) == 0); //return operator==(comp.m_data); + } + + inline const char* c_str() const + { + return m_data; + } + + // This is actually unsafe, but we need it for convenience, unless we really + // feel like copying all data twice. BE WARNED! When this class reallocates + // memory, all old references to _data are invalid! + //operator const char*() const { return _data; } + inline int GetSize() const //in bytes - including terminating NULL char. + { + return m_size; + } + + inline int GetLength() const + { + return (m_size >= 1) ? m_size-1 : 0; + } + +private: + char* m_data; + int m_size; +}; + +#endif
\ No newline at end of file |