1 : //==============================================================================
2 : // File <$/src/cpp/prod/lib/string.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_stdc.h"
25 :
26 : #include <yaorb/CORBA.h>
27 : #include <yaorb/YAORB.h>
28 :
29 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
30 : #include "src/cpp/prod/tool/Assert.h"
31 : #include "src/cpp/prod/tool/Log.h"
32 :
33 18 : char* CORBA::string_alloc(CORBA::ULong len)
34 : {
35 18 : char *result = new char[len+1] ;
36 18 : memset (result, 0, len+1) ;
37 : return result ;
38 : }
39 :
40 1579 : char* CORBA::string_dup(const char* str)
41 : {
42 1579 : if (str == NULL)
43 : {
44 : str = "" ;
45 : }
46 1579 : int len = strlen(str) + 1 ;
47 3158 : char *dup = new char[len] ;
48 1579 : strcpy(dup, str) ;
49 : return dup ;
50 : }
51 :
52 151 : void CORBA::string_free(char* str)
53 : {
54 151 : if (str != NULL)
55 : {
56 151 : delete [] (str) ;
57 : }
58 : }
59 :
60 : // CORBA::String_var : FIXME !!!
61 :
62 84 : CORBA::String_var::String_var()
63 84 : : _ptr(NULL)
64 : {
65 84 : _ptr = string_dup("") ;
66 : }
67 :
68 0 : CORBA::String_var::String_var(char* p)
69 0 : : _ptr(p)
70 : {
71 : ASSERT(p != NULL) ;
72 : }
73 :
74 1425 : CORBA::String_var::String_var(const char* p)
75 1425 : : _ptr(NULL)
76 : {
77 : ASSERT(p != NULL) ;
78 1425 : _ptr = CORBA::string_dup(p) ;
79 : }
80 :
81 0 : CORBA::String_var::String_var(const CORBA::String_var& s)
82 0 : : _ptr(NULL)
83 : {
84 0 : _ptr = CORBA::string_dup(s._ptr) ;
85 : }
86 :
87 62 : CORBA::String_var::~String_var()
88 : {
89 62 : CORBA::string_free(_ptr) ;
90 : }
91 :
92 19 : CORBA::String_var& CORBA::String_var::operator=(char* p)
93 : {
94 : ASSERT(p != NULL) ;
95 19 : CORBA::string_free(_ptr) ;
96 19 : _ptr = p ;
97 : return *this ;
98 : }
99 :
100 34 : CORBA::String_var& CORBA::String_var::operator=(const char* p)
101 : {
102 : ASSERT(p != NULL) ;
103 34 : CORBA::string_free(_ptr) ;
104 34 : _ptr = CORBA::string_dup(p) ;
105 : return *this ;
106 : }
107 :
108 36 : CORBA::String_var& CORBA::String_var::operator=(const CORBA::String_var& s)
109 : {
110 36 : CORBA::string_free(_ptr) ;
111 36 : _ptr = CORBA::string_dup(s._ptr) ;
112 : return *this ;
113 : }
114 :
115 : CORBA::Boolean
116 : CORBA::String_var::operator == (
117 0 : const char * p) const
118 : {
119 0 : return ((strcmp(_ptr, p) == 0) ? true : false ) ;
120 : }
121 :
122 : CORBA::Boolean
123 : CORBA::String_var::operator == (
124 4 : const CORBA::String_var & s) const
125 : {
126 4 : return ((strcmp(_ptr, s._ptr) == 0) ? true : false ) ;
127 : }
128 :
129 : CORBA::Boolean
130 : CORBA::String_var::operator != (
131 0 : const char * p) const
132 : {
133 0 : return ((strcmp(_ptr, p) != 0) ? true : false ) ;
134 : }
135 :
136 : CORBA::Boolean
137 : CORBA::String_var::operator != (
138 0 : const CORBA::String_var & s) const
139 : {
140 0 : return ((strcmp(_ptr, s._ptr) != 0) ? true : false ) ;
141 : }
142 :
143 14 : CORBA::String_var::operator char* ()
144 : {
145 : ASSERT(_ptr != NULL) ;
146 :
147 14 : NON_DEV("Revise pointer ownership") ;
148 14 : LOG("Revise me") ;
149 :
150 : return _ptr ;
151 : }
152 :
153 60 : CORBA::String_var::operator const char* () const
154 : {
155 : ASSERT(_ptr != NULL) ;
156 : return _ptr ;
157 : }
158 :
159 33 : const char* CORBA::String_var::in() const
160 : {
161 : ASSERT(_ptr != NULL) ;
162 : return _ptr ;
163 : }
164 :
165 0 : char*& CORBA::String_var::inout()
166 : {
167 : ASSERT(_ptr != NULL) ;
168 : return _ptr ;
169 : }
170 :
171 0 : char*& CORBA::String_var::out()
172 : {
173 0 : string_free(_ptr) ;
174 0 : _ptr = NULL ;
175 : return _ptr ;
176 : }
177 :
178 0 : char* CORBA::String_var::_retn()
179 : {
180 : ASSERT(_ptr != NULL) ;
181 0 : char *ret = _ptr ;
182 0 : _ptr = NULL ;
183 : return ret ;
184 : }
185 :
186 0 : char& CORBA::String_var::operator[](CORBA::ULong index)
187 : {
188 : ASSERT(_ptr != NULL) ;
189 : return _ptr[index] ;
190 : }
191 :
192 0 : char CORBA::String_var::operator[](CORBA::ULong index) const
193 : {
194 : ASSERT(_ptr != NULL) ;
195 : return _ptr[index] ;
196 : }
197 :
198 6 : void CORBA::String_var::cdr(YAORB::CDR* cdrs)
199 : {
200 6 : cdrs->cdr_String_var(this) ;
201 : }
202 :
203 : // CORBA::String_out : FIXME !!!
204 :
205 0 : CORBA::String_out::String_out(char*& p)
206 0 : : _ptr(p)
207 : {
208 0 : NON_DEV("") ;
209 : }
210 :
211 0 : CORBA::String_out::String_out(CORBA::String_var& p)
212 0 : : _ptr(p.out())
213 : {
214 0 : NON_DEV("") ;
215 : }
216 :
217 0 : CORBA::String_out::String_out(CORBA::String_out& s)
218 0 : : _ptr(s._ptr)
219 : {
220 0 : NON_DEV("") ;
221 : }
222 :
223 0 : CORBA::String_out& CORBA::String_out::operator=(CORBA::String_out& s)
224 : {
225 0 : NON_DEV("") ;
226 : return *this ;
227 : }
228 :
229 0 : CORBA::String_out& CORBA::String_out::operator=(char *p)
230 : {
231 0 : NON_DEV("") ;
232 : return *this ;
233 : }
234 :
235 0 : CORBA::String_out::operator char*& ()
236 : {
237 0 : NON_DEV("") ;
238 : return _ptr ;
239 : }
240 :
241 0 : char*& CORBA::String_out::ptr()
242 : {
243 0 : NON_DEV("") ;
244 : return _ptr ;
245 : }
246 :
|
