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