1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #ifndef _micxx_string_h
26 #define _micxx_string_h
27
28 #include <MI.h>
29 #include "linkage.h"
30 #include "atomic.h"
31
32 MI_BEGIN_NAMESPACE
33
34 class MICXX_LINKAGE String
35 {
36 public:
37
38 String();
39
40 String(const MI_Char* str);
41
42 String(const MI_Char* str, MI_Uint32 size);
43 mike 1.1
44 String(const String& x);
45
46 ~String();
47
48 void Clear();
49
50 String& operator=(const String& x);
51
52 String& operator+=(const String& x);
53
54 String& operator+=(const MI_Char* str);
55
56 String& operator+=(const MI_Char ch);
57
58 void Append(const MI_Char* str, MI_Uint32 size);
59
60 MI_Char& operator[](MI_Uint32 index);
61
62 MI_Char operator[](MI_Uint32 index) const;
63
64 mike 1.1 #if 0
65 /* ATTN: disabled for now (not in standard basic_string<>) */
66 operator const MI_Char*() const;
67 #endif
68
69 const MI_Char* Str() const;
70
71 bool Equal(const String& x) const;
72
73 bool Equal(const MI_Char* str) const;
74
75 MI_Uint32 GetSize() const;
76
77 private:
78
79 struct Header
80 {
81 AtomicType m_refCounter;
82 MI_Uint32 m_size;
83 MI_Uint32 m_capacity;
84 };
85 mike 1.1
86 String& StrCat(const MI_Char* str, MI_Uint32 size);
87
88 void AddRef();
89
90 void Release();
91
92 static MI_Char* Allocate(int capacity);
93
94 // returns 0 - for 0; 16 for 1-6; 32 for 17-32 etc
95 static int AlignCapacity(MI_Uint32 size)
96 {
97 const MI_Uint32 ALIGNMENT = 16;
98 return ((size + ALIGNMENT -1) / ALIGNMENT) * ALIGNMENT;
99 }
100
101 static Header* GetHeader(MI_Char* buf)
102 {
103 return reinterpret_cast<Header*>(
104 reinterpret_cast<char*>(buf) - sizeof(Header));
105 }
106 mike 1.1
107 // for compatability with "C", it must have only one pointer memeber!
108 MI_Char* m_data;
109 };
110
111 inline String::String() : m_data(0)
112 {
113 }
114
115 inline String::String(const String& x)
116 {
117 m_data = x.m_data;
118 AddRef();
119 }
120
121 inline String::~String()
122 {
123 Release();
124 }
125
126 inline void String::AddRef()
127 mike 1.1 {
128 if ( m_data )
129 AtomicInc(GetHeader(m_data)->m_refCounter);
130 }
131
132 inline String& String::operator+=(const String& x)
133 {
134 if ( !m_data )
135 return operator=(x);
136
137 return StrCat(x.Str(), x.GetSize());
138 }
139
140 inline const MI_Char* String::Str() const
141 {
142 return m_data ? m_data : MI_T("");
143 }
144
145 inline bool String::Equal(const MI_Char* str) const
146 {
147 return memcmp(str, Str(), (GetSize()+1) * sizeof(MI_Char)) == 0;
148 mike 1.1 }
149
150 inline MI_Uint32 String::GetSize() const
151 {
152 return m_data ? GetHeader(m_data)->m_size : 0;
153 }
154
155 inline bool operator==(const String& x, const String& y)
156 {
157 return x.Equal(y);
158 }
159
160 inline bool operator==(const String& x, const MI_Char* str)
161 {
162 return x.Equal(str);
163 }
164
165 inline bool operator==(const MI_Char* str, const String& x)
166 {
167 return x.Equal(str);
168 }
169 mike 1.1
170 inline bool operator!=(const String& x, const String& y)
171 {
172 return !x.Equal(y);
173 }
174
175 inline bool operator!=(const String& x, const MI_Char* str)
176 {
177 return !x.Equal(str);
178 }
179
180 inline bool operator!=(const MI_Char* str, const String& x)
181 {
182 return !x.Equal(str);
183 }
184
185 MI_END_NAMESPACE
186
187 #endif /* _micxx_string_h */
|