b311480e |
1 | // Copyright (c) 1999-2012 OPEN CASCADE SAS |
2 | // |
3 | // The content of this file is subject to the Open CASCADE Technology Public |
4 | // License Version 6.5 (the "License"). You may not use the content of this file |
5 | // except in compliance with the License. Please obtain a copy of the License |
6 | // at http://www.opencascade.org and read it completely before using this file. |
7 | // |
8 | // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its |
9 | // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. |
10 | // |
11 | // The Original Code and all software distributed under the License is |
12 | // distributed on an "AS IS" basis, without warranty of any kind, and the |
13 | // Initial Developer hereby disclaims all such warranties, including without |
14 | // limitation, any warranties of merchantability, fitness for a particular |
15 | // purpose or non-infringement. Please see the License for the specific terms |
16 | // and conditions governing the rights and limitations under the License. |
17 | |
7fd59977 |
18 | #include <MoniTool_TypedValue.ixx> |
19 | |
20 | #include <Dico_DictionaryOfInteger.hxx> |
21 | #include <Dico_IteratorOfDictionaryOfInteger.hxx> |
22 | #include <Dico_DictionaryOfTransient.hxx> |
23 | #include <Dico_IteratorOfDictionaryOfTransient.hxx> |
24 | #include <MoniTool_Element.hxx> |
25 | #include <Message_Messenger.hxx> |
26 | |
27 | #include <OSD_Path.hxx> |
28 | #include <stdio.h> |
29 | |
30 | |
31 | |
32 | // Not Used : |
33 | //static char defmess[30]; |
34 | |
35 | static Handle(Dico_DictionaryOfTransient) libtv() |
36 | { |
37 | static Handle(Dico_DictionaryOfTransient) thelibtv; |
38 | if (thelibtv.IsNull()) { |
39 | thelibtv = new Dico_DictionaryOfTransient; |
40 | Handle(MoniTool_TypedValue) tv; |
41 | tv = new MoniTool_TypedValue("Integer",MoniTool_ValueInteger); |
42 | thelibtv->SetItem ("Integer",tv); |
43 | tv = new MoniTool_TypedValue("Real",MoniTool_ValueReal); |
44 | thelibtv->SetItem ("Real",tv); |
45 | tv = new MoniTool_TypedValue("Text",MoniTool_ValueText); |
46 | thelibtv->SetItem ("Text",tv); |
47 | tv = new MoniTool_TypedValue("Transient",MoniTool_ValueIdent); |
48 | thelibtv->SetItem ("Transient",tv); |
49 | tv = new MoniTool_TypedValue("Boolean",MoniTool_ValueEnum); |
50 | tv->AddDef ("enum 0"); // = 0 False , > 0 True |
51 | tv->AddDef ("eval False"); |
52 | tv->AddDef ("eval True"); |
53 | thelibtv->SetItem ("Boolean",tv); |
54 | tv = new MoniTool_TypedValue("Logical",MoniTool_ValueEnum); |
55 | tv->AddDef ("enum -1"); // < 0 False , = 0 Unk , > 0 True |
56 | tv->AddDef ("eval False"); |
57 | tv->AddDef ("eval Unknown"); |
58 | tv->AddDef ("eval True"); |
59 | thelibtv->SetItem ("Logical",tv); |
60 | } |
61 | return thelibtv; |
62 | } |
63 | |
64 | |
65 | // Fonctions Satisfies offertes en standard ... |
66 | /* Not Used |
67 | |
68 | static Standard_Boolean StaticPath(const Handle(TCollection_HAsciiString)& val) |
69 | { |
70 | OSD_Path apath; |
71 | return apath.IsValid (TCollection_AsciiString(val->ToCString())); |
72 | } |
73 | */ |
74 | |
75 | MoniTool_TypedValue::MoniTool_TypedValue |
76 | (const Standard_CString name, |
77 | const MoniTool_ValueType type, const Standard_CString init) |
78 | : thename (name) , thetype (type) , |
79 | thelims (0), themaxlen (0) , theintlow (0) , theintup (-1) , |
80 | theinterp (NULL) , thesatisf (NULL) , |
81 | theival (0), |
82 | thehval (new TCollection_HAsciiString("")) |
83 | { |
84 | if (type != MoniTool_ValueInteger && type != MoniTool_ValueReal && |
85 | type != MoniTool_ValueEnum && type != MoniTool_ValueText && |
86 | type != MoniTool_ValueIdent) |
87 | Standard_ConstructionError::Raise("MoniTool_TypedValue : Type not supported"); |
88 | if (init[0] != '\0') |
89 | if (Satisfies(new TCollection_HAsciiString(init))) SetCStringValue (init); |
90 | |
91 | } |
92 | |
93 | |
94 | MoniTool_TypedValue::MoniTool_TypedValue |
95 | (const Handle(MoniTool_TypedValue)& other) |
96 | : thename (other->Name()) , thedef (other->Definition()) , |
97 | thelabel (other->Label()) , thetype (other->ValueType()) , |
98 | theotyp (other->ObjectType()) , |
99 | thelims (0) , themaxlen (other->MaxLength()) , |
100 | theintlow (0) , theintup (0) , therealow (0) , therealup (0) , |
101 | theunidef (other->UnitDef()) , |
102 | theival (other->IntegerValue()) , thehval (other->HStringValue()) , |
103 | theoval (other->ObjectValue()) |
104 | { |
105 | Handle(Dico_DictionaryOfInteger) eadds; |
106 | Standard_CString satisname; |
107 | other->Internals (theinterp,thesatisf,satisname, eadds); |
108 | thesatisn.AssignCat (satisname); |
109 | |
110 | if (other->IntegerLimit (Standard_False,theintlow)) thelims |= 1; |
111 | if (other->IntegerLimit (Standard_True ,theintup )) thelims |= 2; |
112 | if (other->RealLimit (Standard_False,therealow)) thelims |= 1; |
113 | if (other->RealLimit (Standard_True ,therealup)) thelims |= 2; |
114 | |
115 | Standard_Integer startcase, endcase; Standard_Boolean match; |
116 | if (other->EnumDef (startcase,endcase,match)) { |
117 | theintlow = startcase; theintup = endcase; |
118 | if (match) thelims |= 4; |
119 | if (theintup >= theintlow) theenums = new TColStd_HArray1OfAsciiString (theintlow,theintup); |
120 | for (startcase = theintlow; startcase <= theintup; startcase ++) { |
121 | theenums->SetValue (startcase,other->EnumVal (startcase)); |
122 | } |
123 | } |
124 | // dupliquer theeadds |
125 | if (!eadds.IsNull()) { |
126 | theeadds = new Dico_DictionaryOfInteger; |
127 | Dico_IteratorOfDictionaryOfInteger itad (eadds); |
128 | for (; itad.More(); itad.Next()) theeadds->SetItem (itad.Name(),itad.Value()); |
129 | } |
130 | |
131 | // on duplique la string |
132 | if (!thehval.IsNull()) thehval = new TCollection_HAsciiString (other->CStringValue()); |
133 | } |
134 | |
135 | |
136 | void MoniTool_TypedValue::Internals |
137 | (MoniTool_ValueInterpret& interp, MoniTool_ValueSatisfies& satisf, |
138 | Standard_CString& satisname, |
139 | Handle(Dico_DictionaryOfInteger)& enums) const |
140 | { interp = theinterp; satisf = thesatisf; satisname = thesatisn.ToCString(); |
141 | enums = theeadds; } |
142 | |
143 | Standard_CString MoniTool_TypedValue::Name () const |
144 | { return thename.ToCString(); } |
145 | |
146 | MoniTool_ValueType MoniTool_TypedValue::ValueType () const |
147 | { return thetype; } |
148 | |
149 | TCollection_AsciiString MoniTool_TypedValue::Definition () const |
150 | { |
151 | if (thedef.Length() > 0) return thedef; |
152 | TCollection_AsciiString def; |
153 | char mess[50]; |
154 | switch (thetype) { |
155 | case MoniTool_ValueInteger : { |
156 | def.AssignCat("Integer"); |
157 | Standard_Integer ilim; |
158 | if (IntegerLimit(Standard_False, ilim)) { |
91322f44 |
159 | Sprintf(mess," >= %d",ilim); |
7fd59977 |
160 | def.AssignCat(mess); |
161 | } |
162 | if (IntegerLimit(Standard_True, ilim)) { |
91322f44 |
163 | Sprintf(mess," <= %d",ilim); |
7fd59977 |
164 | def.AssignCat(mess); |
165 | } |
166 | } |
167 | break; |
168 | case MoniTool_ValueReal : { |
169 | def.AssignCat("Real"); |
170 | Standard_Real rlim; |
171 | if (RealLimit(Standard_False, rlim)) { |
91322f44 |
172 | Sprintf(mess," >= %f",rlim); |
7fd59977 |
173 | def.AssignCat(mess); |
174 | } |
175 | if (RealLimit(Standard_True, rlim)) { |
91322f44 |
176 | Sprintf(mess," <= %f",rlim); |
7fd59977 |
177 | def.AssignCat(mess); |
178 | } |
179 | if (theunidef.Length() > 0) |
180 | { def.AssignCat(" Unit:"); def.AssignCat(UnitDef()); } |
181 | } |
182 | break; |
183 | case MoniTool_ValueEnum : { |
184 | def.AssignCat("Enum"); |
185 | Standard_Integer startcase, endcase; Standard_Boolean match; |
186 | EnumDef (startcase,endcase,match); |
91322f44 |
187 | Sprintf(mess," [%s%d-%d]",(match ? "in " : ""),startcase,endcase); |
7fd59977 |
188 | def.AssignCat(mess); |
189 | for (Standard_Integer i = startcase; i <= endcase; i ++) { |
190 | Standard_CString enva = EnumVal(i); |
191 | if (enva[0] == '?' || enva[0] == '\0') continue; |
91322f44 |
192 | Sprintf(mess," %d:%s",i,enva); |
7fd59977 |
193 | def.AssignCat (mess); |
194 | } |
195 | if (!theeadds.IsNull()) { |
196 | def.AssignCat(" , alpha: "); |
197 | Dico_IteratorOfDictionaryOfInteger listadd(theeadds); |
198 | for (listadd.Start(); listadd.More(); listadd.Next()) { |
199 | Standard_CString enva = listadd.Name().ToCString(); |
200 | if (enva[0] == '?') continue; |
91322f44 |
201 | Sprintf(mess,":%d ",listadd.Value()); |
7fd59977 |
202 | def.AssignCat (enva); |
203 | def.AssignCat (mess); |
204 | } |
205 | } |
206 | } |
207 | break; |
208 | case MoniTool_ValueIdent : { |
209 | def.AssignCat("Object(Entity)"); |
210 | if (!theotyp.IsNull()) { |
211 | def.AssignCat(":"); |
212 | def.AssignCat(theotyp->Name()); |
213 | } |
214 | } |
215 | break; |
216 | case MoniTool_ValueText : { |
217 | def.AssignCat("Text"); |
218 | if (themaxlen > 0) { |
91322f44 |
219 | Sprintf (mess," <= %d C.",themaxlen); |
7fd59977 |
220 | def.AssignCat (mess); |
221 | } |
222 | break; |
223 | } |
224 | default : def.AssignCat("(undefined)"); break; |
225 | } |
226 | return def; |
227 | } |
228 | |
229 | void MoniTool_TypedValue::SetDefinition (const Standard_CString deftext) |
230 | { thedef.Clear(); thedef.AssignCat(deftext); } |
231 | |
232 | // ## Print ## |
233 | |
234 | void MoniTool_TypedValue::Print (const Handle(Message_Messenger)& S) const |
235 | { |
236 | S<<"--- Typed Value : "<<Name(); |
237 | if (thelabel.Length() > 0) S<<" Label : "<<Label(); |
238 | S<<endl<<"--- Type : "<<Definition()<<endl<<"--- Value : "; |
239 | |
240 | PrintValue (S); |
241 | S<<endl; |
242 | |
243 | if (thesatisf) S<<" -- Specific Function for Satisfies : "<<thesatisn.ToCString()<<endl; |
244 | } |
245 | |
246 | |
247 | void MoniTool_TypedValue::PrintValue (const Handle(Message_Messenger)& S) const |
248 | { |
249 | if (IsSetValue()) { |
250 | if (thetype == MoniTool_ValueIdent) |
251 | S<<" (type) "<<theoval->DynamicType()->Name(); |
252 | if (!thehval.IsNull()) |
253 | S<<(thetype == MoniTool_ValueIdent ? " : " : "")<<thehval->ToCString(); |
254 | |
255 | if (HasInterpret()) { |
256 | S<<" ("; |
257 | Handle(TCollection_HAsciiString) str = Interpret (thehval,Standard_True); |
258 | if (!str.IsNull() && str != thehval) S<<"Native:"<<str->ToCString(); |
259 | str = Interpret (thehval,Standard_False); |
260 | if (!str.IsNull() && str != thehval) S<<" Coded:"<<str->ToCString(); |
261 | S<<")"; |
262 | } |
263 | } |
264 | else S<<"(not set)"; |
265 | } |
266 | |
267 | |
268 | // ######### COMPLEMENTS ########## |
269 | |
270 | Standard_Boolean MoniTool_TypedValue::AddDef |
271 | (const Standard_CString init) |
272 | { |
273 | // Editions : init donne un petit texte d edition, en 2 termes "cmd var" : |
274 | Standard_Integer i,iblc = 0; |
275 | for (i = 0; init[i] != '\0'; i ++) if (init[i] == ' ') iblc = i+1; |
276 | if (iblc == 0) return Standard_False; |
277 | // Reconnaissance du sous-cas et aiguillage |
278 | if (init[0] == 'i' && init[2] == 'i') // imin ival |
279 | SetIntegerLimit (Standard_False,atoi(&init[iblc])); |
280 | else if (init[0] == 'i' && init[2] == 'a') // imax ival |
281 | SetIntegerLimit (Standard_True ,atoi(&init[iblc])); |
282 | else if (init[0] == 'r' && init[2] == 'i') // rmin rval |
91322f44 |
283 | SetRealLimit (Standard_False,Atof(&init[iblc])); |
7fd59977 |
284 | else if (init[0] == 'r' && init[2] == 'a') // rmax rval |
91322f44 |
285 | SetRealLimit (Standard_True ,Atof(&init[iblc])); |
7fd59977 |
286 | else if (init[0] == 'u') // unit name |
287 | SetUnitDef (&init[iblc]); |
288 | else if (init[0] == 'e' && init[1] == 'm') // ematch istart |
289 | StartEnum (atoi(&init[iblc]),Standard_True); |
290 | else if (init[0] == 'e' && init[1] == 'n') // enum istart |
291 | StartEnum (atoi(&init[iblc]),Standard_False); |
292 | else if (init[0] == 'e' && init[1] == 'v') // eval text |
293 | AddEnum (&init[iblc]); |
294 | else if (init[0] == 't' && init[1] == 'm') // tmax length |
295 | SetMaxLength (atoi(&init[iblc])); |
296 | |
297 | else return Standard_False; |
298 | |
299 | return Standard_True; |
300 | } |
301 | |
302 | |
303 | void MoniTool_TypedValue::SetLabel (const Standard_CString label) |
304 | { thelabel.Clear(); thelabel.AssignCat (label); } |
305 | |
306 | Standard_CString MoniTool_TypedValue::Label () const |
307 | { return thelabel.ToCString(); } |
308 | |
309 | |
310 | |
311 | void MoniTool_TypedValue::SetMaxLength |
312 | (const Standard_Integer max) |
313 | { themaxlen = max; if (max < 0) themaxlen = 0; } |
314 | |
315 | Standard_Integer MoniTool_TypedValue::MaxLength () const |
316 | { return themaxlen; } |
317 | |
318 | void MoniTool_TypedValue::SetIntegerLimit |
319 | (const Standard_Boolean max, const Standard_Integer val) |
320 | { |
321 | if (thetype != MoniTool_ValueInteger) Standard_ConstructionError::Raise |
322 | ("MoniTool_TypedValue : SetIntegerLimit, not an Integer"); |
323 | |
324 | if (max) { thelims |= 2; theintup = val; } |
325 | else { thelims |= 1; theintlow = val; } |
326 | } |
327 | |
328 | Standard_Boolean MoniTool_TypedValue::IntegerLimit |
329 | (const Standard_Boolean max, Standard_Integer& val) const |
330 | { |
331 | Standard_Boolean res = Standard_False; |
332 | if (max) { res = (thelims & 2) != 0; val = (res ? theintup : IntegerLast()); } |
333 | else { res = (thelims & 1) != 0; val = (res ? theintlow : IntegerFirst()); } |
334 | return res; |
335 | } |
336 | |
337 | |
338 | void MoniTool_TypedValue::SetRealLimit |
339 | (const Standard_Boolean max, const Standard_Real val) |
340 | { |
341 | if (thetype != MoniTool_ValueReal) Standard_ConstructionError::Raise |
342 | ("MoniTool_TypedValue : SetRealLimit, not a Real"); |
343 | |
344 | if (max) { thelims |= 2; therealup = val; } |
345 | else { thelims |= 1; therealow = val; } |
346 | } |
347 | |
348 | Standard_Boolean MoniTool_TypedValue::RealLimit |
349 | (const Standard_Boolean max, Standard_Real& val) const |
350 | { |
351 | Standard_Boolean res = Standard_False; |
352 | if (max) { res = (thelims & 2) != 0; val = (res ? therealup : RealLast()); } |
353 | else { res = (thelims & 1) != 0; val = (res ? therealow : RealFirst()); } |
354 | return res; |
355 | } |
356 | |
357 | void MoniTool_TypedValue::SetUnitDef (const Standard_CString def) |
358 | { theunidef.Clear(); theunidef.AssignCat(def); } |
359 | |
360 | Standard_CString MoniTool_TypedValue::UnitDef () const |
361 | { return theunidef.ToCString(); } |
362 | |
363 | // ****** les enums ****** |
364 | |
365 | void MoniTool_TypedValue::StartEnum |
366 | (const Standard_Integer start, const Standard_Boolean match) |
367 | { |
368 | if (thetype != MoniTool_ValueEnum) Standard_ConstructionError::Raise |
369 | ("MoniTool_TypedValue : StartEnum, Not an Enum"); |
370 | |
371 | thelims |= 4; if (!match) thelims -= 4; |
372 | theintlow = start; theintup = start -1; |
373 | } |
374 | |
375 | void MoniTool_TypedValue::AddEnum |
376 | (const Standard_CString v1, const Standard_CString v2, |
377 | const Standard_CString v3, const Standard_CString v4, |
378 | const Standard_CString v5, const Standard_CString v6, |
379 | const Standard_CString v7, const Standard_CString v8, |
380 | const Standard_CString v9, const Standard_CString v10) |
381 | { |
382 | if (thetype != MoniTool_ValueEnum) Standard_ConstructionError::Raise |
383 | ("MoniTool_TypedValue : AddEnum, Not an Enum"); |
384 | if (theenums.IsNull()) theenums = |
385 | new TColStd_HArray1OfAsciiString(theintlow,theintlow+10); |
386 | else if (theenums->Upper() < theintup + 10) { |
387 | Handle(TColStd_HArray1OfAsciiString) enums = |
388 | new TColStd_HArray1OfAsciiString(theintlow,theintup+10); |
389 | for (Standard_Integer i = theintlow; i <= theintup; i ++) |
390 | enums->SetValue(i,theenums->Value(i)); |
391 | theenums = enums; |
392 | } |
393 | |
394 | if (theeadds.IsNull()) theeadds = new Dico_DictionaryOfInteger; |
395 | if (v1[0] != '\0') { |
396 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v1)); |
397 | theeadds->SetItem (v1,theintup); |
398 | } |
399 | if (v2[0] != '\0') { |
400 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v2)); |
401 | theeadds->SetItem (v2,theintup); |
402 | } |
403 | if (v3[0] != '\0') { |
404 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v3)); |
405 | theeadds->SetItem (v3,theintup); |
406 | } |
407 | if (v4[0] != '\0') { |
408 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v4)); |
409 | theeadds->SetItem (v4,theintup); |
410 | } |
411 | if (v5[0] != '\0') { |
412 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v5)); |
413 | theeadds->SetItem (v5,theintup); |
414 | } |
415 | if (v6[0] != '\0') { |
416 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v6)); |
417 | theeadds->SetItem (v6,theintup); |
418 | } |
419 | if (v7[0] != '\0') { |
420 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v7)); |
421 | theeadds->SetItem (v7,theintup); |
422 | } |
423 | if (v8[0] != '\0') { |
424 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v8)); |
425 | theeadds->SetItem (v8,theintup); |
426 | } |
427 | if (v9[0] != '\0') { |
428 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v9)); |
429 | theeadds->SetItem (v9,theintup); |
430 | } |
431 | if (v10[0] != '\0') { |
432 | theintup ++; theenums->SetValue(theintup,TCollection_AsciiString(v10)); |
433 | theeadds->SetItem (v10,theintup); |
434 | } |
435 | } |
436 | |
437 | void MoniTool_TypedValue::AddEnumValue |
438 | (const Standard_CString val, const Standard_Integer num) |
439 | { |
440 | if (thetype != MoniTool_ValueEnum) Standard_ConstructionError::Raise |
441 | ("MoniTool_TypedValue : AddEnum, Not an Enum"); |
442 | if (num < theintlow) Standard_ConstructionError::Raise |
443 | ("MoniTool_TypedValue : AddEnum, out of range"); |
444 | if (val[0] == '\0') return; |
445 | if (theenums.IsNull()) theenums = |
446 | new TColStd_HArray1OfAsciiString(theintlow,num+1); |
447 | else if (theenums->Upper() < num) { |
448 | Handle(TColStd_HArray1OfAsciiString) enums = |
449 | new TColStd_HArray1OfAsciiString(theintlow,num+1); |
450 | for (Standard_Integer i = theintlow; i <= theintup; i ++) |
451 | enums->SetValue(i,theenums->Value(i)); |
452 | theenums = enums; |
453 | } |
454 | |
455 | if (theintup < num) theintup = num; |
456 | if (theenums->Value(num).Length() == 0) |
457 | theenums->SetValue(num,TCollection_AsciiString(val)); |
458 | // On met AUSSI dans le dictionnaire |
459 | // else { |
460 | if (theeadds.IsNull()) theeadds = new Dico_DictionaryOfInteger; |
461 | theeadds->SetItem (val,num); |
462 | // } |
463 | } |
464 | |
465 | Standard_Boolean MoniTool_TypedValue::EnumDef |
466 | (Standard_Integer& startcase, Standard_Integer& endcase, |
467 | Standard_Boolean& match) const |
468 | { |
469 | if (thetype != MoniTool_ValueEnum) return Standard_False; |
470 | startcase = theintlow; endcase = theintup; |
471 | match = ((thelims & 4) != 0); |
472 | return Standard_True; |
473 | } |
474 | |
475 | Standard_CString MoniTool_TypedValue::EnumVal |
476 | (const Standard_Integer num) const |
477 | { |
478 | if (thetype != MoniTool_ValueEnum) return ""; |
479 | if (num < theintlow || num > theintup) return ""; |
480 | return theenums->Value(num).ToCString(); |
481 | } |
482 | |
483 | Standard_Integer MoniTool_TypedValue::EnumCase |
484 | (const Standard_CString val) const |
485 | { |
486 | if (thetype != MoniTool_ValueEnum) return (theintlow - 1); |
487 | Standard_Integer i; // svv Jan 10 2000 : porting on DEC |
488 | for (i = theintlow; i <= theintup; i ++) |
489 | if (theenums->Value(i).IsEqual(val)) return i; |
490 | // cas additionnel ? |
491 | if (!theeadds.IsNull()) { |
492 | if (theeadds->GetItem (val,i,Standard_False)) return i; |
493 | } |
494 | // entier possible |
495 | //gka S4054 |
496 | for (i = 0; val[i] != '\0'; i ++) |
497 | if (val[i] != ' ' && val[i] != '-' && (val[i] < '0' || val[i] > '9' )) return (theintlow -1); |
498 | return atoi(val); |
499 | } |
500 | |
501 | // ****** object/entity ****** |
502 | |
503 | void MoniTool_TypedValue::SetObjectType |
504 | (const Handle(Standard_Type)& typ) |
505 | { |
506 | if (thetype != MoniTool_ValueIdent) Standard_ConstructionError::Raise |
507 | ("MoniTool_TypedValue : AddEnum, Not an Entity/Object"); |
508 | theotyp = typ; |
509 | } |
510 | |
511 | Handle(Standard_Type) MoniTool_TypedValue::ObjectType () const |
512 | { |
513 | if (!theotyp.IsNull()) return theotyp; |
514 | return STANDARD_TYPE(Standard_Transient); |
515 | } |
516 | |
517 | // ****** Specific Interpret/Satisfy ****** |
518 | |
519 | void MoniTool_TypedValue::SetInterpret |
520 | (const MoniTool_ValueInterpret func) |
521 | { theinterp = func; } |
522 | |
523 | Standard_Boolean MoniTool_TypedValue::HasInterpret () const |
524 | { |
525 | if (theinterp) return Standard_True; |
526 | if (thetype == MoniTool_ValueEnum) return Standard_True; |
527 | return Standard_False; |
528 | } |
529 | |
530 | void MoniTool_TypedValue::SetSatisfies |
531 | (const MoniTool_ValueSatisfies func, const Standard_CString name) |
532 | { |
533 | thesatisn.Clear(); |
534 | thesatisf = func; |
535 | if (thesatisf) thesatisn.AssignCat (name); |
536 | } |
537 | |
538 | Standard_CString MoniTool_TypedValue::SatisfiesName () const |
539 | { return thesatisn.ToCString(); } |
540 | |
541 | // ########### VALEUR DU STATIC ############ |
542 | |
543 | Standard_Boolean MoniTool_TypedValue::IsSetValue () const |
544 | { |
545 | if (thetype == MoniTool_ValueIdent) return (!theoval.IsNull()); |
546 | if (thehval->Length() > 0) return Standard_True; |
547 | if (!theoval.IsNull()) return Standard_True; |
548 | return Standard_False; |
549 | } |
550 | |
551 | Standard_CString MoniTool_TypedValue::CStringValue () const |
552 | { if (thehval.IsNull()) return ""; return thehval->ToCString(); } |
553 | |
554 | Handle(TCollection_HAsciiString) MoniTool_TypedValue::HStringValue () const |
555 | { return thehval; } |
556 | |
557 | Handle(TCollection_HAsciiString) MoniTool_TypedValue::Interpret |
558 | (const Handle(TCollection_HAsciiString)& hval, |
559 | const Standard_Boolean native) const |
560 | { |
561 | Handle(TCollection_HAsciiString) inter = hval; |
562 | if (hval.IsNull()) return hval; |
563 | if (theinterp) return theinterp (this,hval,native); |
564 | if (thetype == MoniTool_ValueEnum) { |
565 | // On admet les deux formes : Enum de preference, sinon Integer |
566 | Standard_Integer startcase, endcase; Standard_Boolean match; |
567 | EnumDef (startcase,endcase,match); |
568 | Standard_Integer encas = EnumCase (hval->ToCString()); |
569 | if (encas < startcase) return hval; // loupe |
570 | if (native) inter = new TCollection_HAsciiString (EnumVal(encas)); |
571 | else inter = new TCollection_HAsciiString (encas); |
572 | } |
573 | return inter; |
574 | } |
575 | |
576 | Standard_Boolean MoniTool_TypedValue::Satisfies |
577 | (const Handle(TCollection_HAsciiString)& val) const |
578 | { |
579 | if (val.IsNull()) return Standard_False; |
580 | if (thesatisf) |
581 | if (!thesatisf (val) ) return Standard_False; |
582 | if (val->Length() == 0) return Standard_True; |
583 | switch (thetype) { |
584 | case MoniTool_ValueInteger : { |
585 | if (!val->IsIntegerValue()) return Standard_False; |
586 | Standard_Integer ival, ilim; ival = atoi(val->ToCString()); |
587 | if (IntegerLimit(Standard_False, ilim)) |
588 | if (ilim > ival) return Standard_False; |
589 | if (IntegerLimit(Standard_True, ilim)) |
590 | if (ilim < ival) return Standard_False; |
591 | return Standard_True; |
592 | } |
593 | case MoniTool_ValueReal : { |
594 | if (!val->IsRealValue()) return Standard_False; |
595 | Standard_Real rval, rlim; rval = val->RealValue(); |
596 | if (RealLimit(Standard_False, rlim)) |
597 | if (rlim > rval) return Standard_False; |
598 | if (RealLimit(Standard_True, rlim)) |
599 | if (rlim < rval) return Standard_False; |
600 | return Standard_True; |
601 | } |
602 | case MoniTool_ValueEnum : { |
603 | // On admet les deux formes : Enum de preference, sinon Integer |
604 | Standard_Integer startcase, endcase;// unused ival; |
605 | Standard_Boolean match; |
606 | EnumDef (startcase,endcase,match); |
607 | if (!match) return Standard_True; |
608 | if (EnumCase (val->ToCString()) >= startcase) return Standard_True; |
609 | // Ici, on admet un entier dans la fourchette |
610 | //// if (val->IsIntegerValue()) ival = atoi (val->ToCString()); |
611 | |
612 | // PTV 16.09.2000 The if is comment, cause this check is never been done (You can see the logic) |
613 | // if (ival >= startcase && ival <= endcase) return Standard_True; |
614 | return Standard_False; |
615 | } |
616 | case MoniTool_ValueText : { |
617 | if (themaxlen > 0 && val->Length() > themaxlen) return Standard_False; |
618 | break; |
619 | } |
620 | default : break; |
621 | } |
622 | return Standard_True; |
623 | } |
624 | |
625 | void MoniTool_TypedValue::ClearValue () |
626 | { |
627 | thehval.Nullify(); |
628 | theoval.Nullify(); |
629 | theival = 0; |
630 | } |
631 | |
632 | Standard_Boolean MoniTool_TypedValue::SetCStringValue |
633 | (const Standard_CString val) |
634 | { |
635 | Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(val); |
636 | if (hval->IsSameString (thehval)) return Standard_True; |
637 | if (!Satisfies(hval)) return Standard_False; |
638 | if (thetype == MoniTool_ValueInteger) { |
639 | thehval->Clear(); |
640 | theival = atoi(val); |
641 | thehval->AssignCat(val); |
642 | } |
643 | else if (thetype == MoniTool_ValueEnum) { |
644 | Standard_Integer ival = EnumCase(val); |
645 | Standard_CString cval = EnumVal(ival); |
646 | if (!cval || cval[0] == '\0') return Standard_False; |
647 | theival = ival; |
648 | thehval->Clear(); |
649 | thehval->AssignCat(cval); |
650 | } else { |
651 | thehval->Clear(); |
652 | thehval->AssignCat(val); |
653 | return Standard_True; |
654 | } |
655 | return Standard_True; |
656 | } |
657 | |
658 | Standard_Boolean MoniTool_TypedValue::SetHStringValue |
659 | (const Handle(TCollection_HAsciiString)& hval) |
660 | { |
661 | if (hval.IsNull()) return Standard_False; |
662 | if (!Satisfies(hval)) return Standard_False; |
663 | thehval = hval; |
664 | if (thetype == MoniTool_ValueInteger) theival = atoi(hval->ToCString()); |
665 | else if (thetype == MoniTool_ValueEnum) theival = EnumCase(hval->ToCString()); |
666 | // else return Standard_True; |
667 | return Standard_True; |
668 | } |
669 | |
670 | Standard_Integer MoniTool_TypedValue::IntegerValue () const |
671 | { return theival; } |
672 | |
673 | Standard_Boolean MoniTool_TypedValue::SetIntegerValue |
674 | (const Standard_Integer ival) |
675 | { |
676 | Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(ival); |
677 | if (hval->IsSameString (thehval)) return Standard_True; |
678 | if (!Satisfies(hval)) return Standard_False; |
679 | thehval->Clear(); |
680 | if (thetype == MoniTool_ValueEnum) thehval->AssignCat (EnumVal(ival)); |
681 | else thehval->AssignCat (hval->ToCString()); |
682 | theival = ival; |
683 | return Standard_True; |
684 | } |
685 | |
686 | Standard_Real MoniTool_TypedValue::RealValue () const |
687 | { |
688 | if (thehval->Length() == 0) return 0.0; |
689 | if (!thehval->IsRealValue()) return 0.0; |
690 | return thehval->RealValue(); |
691 | } |
692 | |
693 | Standard_Boolean MoniTool_TypedValue::SetRealValue (const Standard_Real rval) |
694 | { |
695 | Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(rval); |
696 | if (hval->IsSameString (thehval)) return Standard_True; |
697 | if (!Satisfies(hval)) return Standard_False; |
698 | thehval->Clear(); thehval->AssignCat (hval->ToCString()); |
699 | return Standard_True; |
700 | } |
701 | |
702 | Handle(Standard_Transient) MoniTool_TypedValue::ObjectValue () const |
703 | { return theoval; } |
704 | |
705 | void MoniTool_TypedValue::GetObjectValue (Handle(Standard_Transient)& val) const |
706 | { val = theoval; } |
707 | |
708 | Standard_Boolean MoniTool_TypedValue::SetObjectValue |
709 | (const Handle(Standard_Transient)& obj) |
710 | { |
711 | if (thetype != MoniTool_ValueIdent) return Standard_False; |
712 | if (obj.IsNull()) { theoval.Nullify(); return Standard_True; } |
713 | if (!theotyp.IsNull()) |
714 | if (!obj->IsKind(theotyp)) return Standard_False; |
715 | theoval = obj; |
716 | return Standard_True; |
717 | } |
718 | |
719 | |
720 | Standard_CString MoniTool_TypedValue::ObjectTypeName () const |
721 | { |
722 | if (theoval.IsNull()) return ""; |
723 | Handle(MoniTool_Element) elm = Handle(MoniTool_Element)::DownCast(theoval); |
724 | if (!elm.IsNull()) return elm->ValueTypeName(); |
725 | return theoval->DynamicType()->Name(); |
726 | } |
727 | |
728 | |
729 | // ######## LIBRARY ######## |
730 | |
731 | Standard_Boolean MoniTool_TypedValue::AddLib |
732 | (const Handle(MoniTool_TypedValue)& tv, const Standard_CString defin) |
733 | { |
734 | if (tv.IsNull()) return Standard_False; |
735 | if (defin[0] != '\0') tv->SetDefinition(defin); |
736 | // else if (tv->Definition() == '\0') return Standard_False; |
737 | libtv()->SetItem (tv->Name(),tv); |
738 | return Standard_True; |
739 | } |
740 | |
741 | Handle(MoniTool_TypedValue) MoniTool_TypedValue::Lib |
742 | (const Standard_CString defin) |
743 | { |
744 | Handle(MoniTool_TypedValue) val; |
745 | if (!libtv()->GetItem (defin,val,Standard_False)) val.Nullify(); |
746 | return val; |
747 | } |
748 | |
749 | Handle(MoniTool_TypedValue) MoniTool_TypedValue::FromLib |
750 | (const Standard_CString defin) |
751 | { |
752 | Handle(MoniTool_TypedValue) val = MoniTool_TypedValue::Lib(defin); |
753 | if (!val.IsNull()) val = new MoniTool_TypedValue (val); |
754 | return val; |
755 | } |
756 | |
757 | Handle(TColStd_HSequenceOfAsciiString) MoniTool_TypedValue::LibList () |
758 | { |
759 | Handle(TColStd_HSequenceOfAsciiString) list = new TColStd_HSequenceOfAsciiString(); |
760 | if (libtv().IsNull()) return list; |
761 | for (Dico_IteratorOfDictionaryOfTransient it(libtv()); it.More();it.Next()) { |
762 | list->Append (it.Name()); |
763 | } |
764 | return list; |
765 | } |
766 | |
767 | |
768 | |
769 | Handle(Dico_DictionaryOfTransient) MoniTool_TypedValue::Stats () |
770 | { |
771 | static Handle(Dico_DictionaryOfTransient) astats; |
772 | if (astats.IsNull()) astats = new Dico_DictionaryOfTransient; |
773 | return astats; |
774 | } |
775 | |
776 | Handle(MoniTool_TypedValue) MoniTool_TypedValue::StaticValue |
777 | (const Standard_CString name) |
778 | { |
779 | Handle(MoniTool_TypedValue) result; |
780 | if (!Stats()->GetItem(name,result)) result.Nullify(); |
781 | return result; |
782 | } |