c15e7c9901a8e0fcd7f041f24f00ae33f74fb7ea
[occt.git] / src / MoniTool / MoniTool_TypedValue.cxx
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
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)) {
159         Sprintf(mess,"  >= %d",ilim);
160         def.AssignCat(mess);
161       }
162       if (IntegerLimit(Standard_True,  ilim)) {
163         Sprintf(mess,"  <= %d",ilim);
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)) {
172         Sprintf(mess,"  >= %f",rlim);
173         def.AssignCat(mess);
174       }
175       if (RealLimit(Standard_True,  rlim)) {
176         Sprintf(mess,"  <= %f",rlim);
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);
187       Sprintf(mess," [%s%d-%d]",(match ? "in " : ""),startcase,endcase);
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;
192         Sprintf(mess," %d:%s",i,enva);
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           TCollection_AsciiString aName = listadd.Name();
200           Standard_CString enva = aName.ToCString();
201           if (enva[0] == '?') continue;
202           Sprintf(mess,":%d ",listadd.Value());
203           def.AssignCat (enva);
204           def.AssignCat (mess);
205         }
206       }
207     }
208       break;
209     case MoniTool_ValueIdent  : {
210       def.AssignCat("Object(Entity)");
211       if (!theotyp.IsNull()) {
212         def.AssignCat(":");
213         def.AssignCat(theotyp->Name());
214       }
215     }
216       break;
217     case MoniTool_ValueText    : {
218       def.AssignCat("Text");
219       if (themaxlen > 0) {
220         Sprintf (mess," <= %d C.",themaxlen);
221         def.AssignCat (mess);
222       }
223       break;
224     }
225     default :  def.AssignCat("(undefined)");  break;
226   }
227   return def;
228 }
229
230     void  MoniTool_TypedValue::SetDefinition (const Standard_CString deftext)
231       {  thedef.Clear();  thedef.AssignCat(deftext);  }
232
233 //  ##   Print   ##
234
235     void  MoniTool_TypedValue::Print (const Handle(Message_Messenger)& S) const
236 {
237   S<<"--- Typed Value : "<<Name();
238   if (thelabel.Length() > 0) S<<"  Label : "<<Label();
239   S<<endl<<"--- Type : "<<Definition()<<endl<<"--- Value : ";
240
241   PrintValue (S);
242   S<<endl;
243
244   if (thesatisf) S<<" -- Specific Function for Satisfies : "<<thesatisn.ToCString()<<endl;
245 }
246
247
248     void  MoniTool_TypedValue::PrintValue (const Handle(Message_Messenger)& S) const
249 {
250   if (IsSetValue()) {
251     if (thetype == MoniTool_ValueIdent)
252       S<<" (type) "<<theoval->DynamicType()->Name();
253     if (!thehval.IsNull())
254       S<<(thetype == MoniTool_ValueIdent ? " : " : "")<<thehval->ToCString();
255
256     if (HasInterpret()) {
257       S<<"  (";
258       Handle(TCollection_HAsciiString) str = Interpret (thehval,Standard_True);
259       if (!str.IsNull() && str != thehval) S<<"Native:"<<str->ToCString();
260       str = Interpret (thehval,Standard_False);
261       if (!str.IsNull() && str != thehval) S<<"  Coded:"<<str->ToCString();
262       S<<")";
263     }
264   }
265   else S<<"(not set)";
266 }
267
268
269 //  #########    COMPLEMENTS    ##########
270
271     Standard_Boolean  MoniTool_TypedValue::AddDef
272   (const Standard_CString init)
273 {
274 //    Editions : init donne un petit texte d edition, en 2 termes "cmd var" :
275   Standard_Integer i,iblc = 0;
276   for (i = 0; init[i] != '\0'; i ++) if (init[i] == ' ') iblc = i+1;
277   if (iblc == 0) return Standard_False;
278 //  Reconnaissance du sous-cas et aiguillage
279   if      (init[0] == 'i' && init[2] == 'i')            // imin ival
280     SetIntegerLimit (Standard_False,atoi(&init[iblc]));
281   else if (init[0] == 'i' && init[2] == 'a')            // imax ival
282     SetIntegerLimit (Standard_True ,atoi(&init[iblc]));
283   else if (init[0] == 'r' && init[2] == 'i')            // rmin rval
284     SetRealLimit (Standard_False,Atof(&init[iblc]));
285   else if (init[0] == 'r' && init[2] == 'a')            // rmax rval
286     SetRealLimit (Standard_True ,Atof(&init[iblc]));
287   else if (init[0] == 'u')                              // unit name
288     SetUnitDef (&init[iblc]);
289   else if (init[0] == 'e' && init[1] == 'm')            // ematch istart
290     StartEnum (atoi(&init[iblc]),Standard_True);
291   else if (init[0] == 'e' && init[1] == 'n')            // enum istart
292     StartEnum (atoi(&init[iblc]),Standard_False);
293   else if (init[0] == 'e' && init[1] == 'v')            // eval text
294     AddEnum (&init[iblc]);
295   else if (init[0] == 't' && init[1] == 'm')            // tmax length
296     SetMaxLength (atoi(&init[iblc]));
297
298   else return Standard_False;
299
300   return Standard_True;
301 }
302
303
304     void  MoniTool_TypedValue::SetLabel (const Standard_CString label)
305       {  thelabel.Clear();  thelabel.AssignCat (label);  }
306
307     Standard_CString  MoniTool_TypedValue::Label  () const
308       {  return thelabel.ToCString();    }
309
310
311
312     void  MoniTool_TypedValue::SetMaxLength
313   (const Standard_Integer max)
314       {  themaxlen = max;  if (max < 0) themaxlen = 0;  }
315
316     Standard_Integer  MoniTool_TypedValue::MaxLength () const
317       {  return themaxlen;  }
318
319     void  MoniTool_TypedValue::SetIntegerLimit
320   (const Standard_Boolean max, const Standard_Integer val)
321 {
322   if (thetype != MoniTool_ValueInteger) Standard_ConstructionError::Raise
323       ("MoniTool_TypedValue : SetIntegerLimit, not an Integer");
324
325   if (max)  {  thelims |= 2;  theintup  = val; }
326   else      {  thelims |= 1;  theintlow = val; }
327 }
328
329     Standard_Boolean  MoniTool_TypedValue::IntegerLimit
330   (const Standard_Boolean max, Standard_Integer& val) const
331 {
332   Standard_Boolean res = Standard_False;
333   if (max) { res = (thelims & 2) != 0; val = (res ? theintup  : IntegerLast()); }
334   else     { res = (thelims & 1) != 0; val = (res ? theintlow : IntegerFirst()); }
335   return res;
336 }
337
338
339     void  MoniTool_TypedValue::SetRealLimit
340   (const Standard_Boolean max, const Standard_Real val)
341 {
342   if (thetype != MoniTool_ValueReal) Standard_ConstructionError::Raise
343       ("MoniTool_TypedValue : SetRealLimit, not a Real");
344
345   if (max)  {  thelims |= 2;  therealup = val; }
346   else      {  thelims |= 1;  therealow = val; }
347 }
348
349     Standard_Boolean  MoniTool_TypedValue::RealLimit
350   (const Standard_Boolean max, Standard_Real& val) const
351 {
352   Standard_Boolean res = Standard_False;
353   if (max) { res = (thelims & 2) != 0; val = (res ? therealup : RealLast()); }
354   else     { res = (thelims & 1) != 0; val = (res ? therealow : RealFirst()); }
355   return res;
356 }
357
358     void   MoniTool_TypedValue::SetUnitDef (const Standard_CString def)
359       {  theunidef.Clear();  theunidef.AssignCat(def);  }
360
361     Standard_CString  MoniTool_TypedValue::UnitDef () const
362       {  return  theunidef.ToCString();  }
363
364 //  ******  les enums  ******
365
366     void  MoniTool_TypedValue::StartEnum
367   (const Standard_Integer start, const Standard_Boolean match)
368 {
369   if (thetype != MoniTool_ValueEnum) Standard_ConstructionError::Raise
370     ("MoniTool_TypedValue : StartEnum, Not an Enum");
371
372   thelims |= 4;  if (!match) thelims -= 4;
373   theintlow = start;  theintup = start -1;
374 }
375
376     void  MoniTool_TypedValue::AddEnum
377   (const Standard_CString v1, const Standard_CString v2,
378    const Standard_CString v3, const Standard_CString v4,
379    const Standard_CString v5, const Standard_CString v6,
380    const Standard_CString v7, const Standard_CString v8,
381    const Standard_CString v9, const Standard_CString v10)
382 {
383   if (thetype != MoniTool_ValueEnum) Standard_ConstructionError::Raise
384     ("MoniTool_TypedValue : AddEnum, Not an Enum");
385   if (theenums.IsNull()) theenums =
386     new TColStd_HArray1OfAsciiString(theintlow,theintlow+10);
387   else if (theenums->Upper() < theintup + 10) {
388     Handle(TColStd_HArray1OfAsciiString) enums =
389       new TColStd_HArray1OfAsciiString(theintlow,theintup+10);
390     for (Standard_Integer i = theintlow; i <= theintup; i ++)
391       enums->SetValue(i,theenums->Value(i));
392     theenums = enums;
393   }
394
395   if (theeadds.IsNull()) theeadds = new Dico_DictionaryOfInteger;
396   if (v1[0] != '\0') {
397     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v1));
398     theeadds->SetItem (v1,theintup);
399   }
400   if (v2[0] != '\0') {
401     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v2));
402     theeadds->SetItem (v2,theintup);
403   }
404   if (v3[0] != '\0') {
405     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v3));
406     theeadds->SetItem (v3,theintup);
407   }
408   if (v4[0] != '\0') {
409     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v4));
410     theeadds->SetItem (v4,theintup);
411   }
412   if (v5[0] != '\0') {
413     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v5));
414     theeadds->SetItem (v5,theintup);
415   }
416   if (v6[0] != '\0') {
417     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v6));
418     theeadds->SetItem (v6,theintup);
419   }
420   if (v7[0] != '\0') {
421     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v7));
422     theeadds->SetItem (v7,theintup);
423   }
424   if (v8[0] != '\0') {
425     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v8));
426     theeadds->SetItem (v8,theintup);
427   }
428   if (v9[0] != '\0') {
429     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v9));
430     theeadds->SetItem (v9,theintup);
431   }
432   if (v10[0] != '\0') {
433     theintup ++;  theenums->SetValue(theintup,TCollection_AsciiString(v10));
434     theeadds->SetItem (v10,theintup);
435   }
436 }
437
438     void  MoniTool_TypedValue::AddEnumValue
439   (const Standard_CString val, const Standard_Integer num)
440 {
441   if (thetype != MoniTool_ValueEnum) Standard_ConstructionError::Raise
442     ("MoniTool_TypedValue : AddEnum, Not an Enum");
443   if (num < theintlow) Standard_ConstructionError::Raise
444     ("MoniTool_TypedValue : AddEnum, out of range");
445   if (val[0] == '\0') return;
446   if (theenums.IsNull()) theenums =
447     new TColStd_HArray1OfAsciiString(theintlow,num+1);
448   else if (theenums->Upper() < num) {
449     Handle(TColStd_HArray1OfAsciiString) enums =
450       new TColStd_HArray1OfAsciiString(theintlow,num+1);
451     for (Standard_Integer i = theintlow; i <= theintup; i ++)
452       enums->SetValue(i,theenums->Value(i));
453     theenums = enums;
454   }
455
456   if (theintup < num) theintup = num;
457   if (theenums->Value(num).Length() == 0)
458     theenums->SetValue(num,TCollection_AsciiString(val));
459 //    On met AUSSI dans le dictionnaire
460 //  else {
461     if (theeadds.IsNull()) theeadds = new Dico_DictionaryOfInteger;
462     theeadds->SetItem (val,num);
463 //  }
464 }
465
466     Standard_Boolean  MoniTool_TypedValue::EnumDef
467   (Standard_Integer& startcase, Standard_Integer& endcase,
468    Standard_Boolean& match) const
469 {
470   if (thetype != MoniTool_ValueEnum) return Standard_False;
471   startcase = theintlow;  endcase = theintup;
472   match = ((thelims & 4) != 0);
473   return Standard_True;
474 }
475
476     Standard_CString  MoniTool_TypedValue::EnumVal
477   (const Standard_Integer num) const
478 {
479   if (thetype != MoniTool_ValueEnum) return "";
480   if (num < theintlow || num > theintup) return "";
481   return theenums->Value(num).ToCString();
482 }
483
484     Standard_Integer  MoniTool_TypedValue::EnumCase
485   (const Standard_CString val) const
486 {
487   if (thetype != MoniTool_ValueEnum) return (theintlow - 1);
488   Standard_Integer i; // svv Jan 10 2000 : porting on DEC
489   for (i = theintlow; i <= theintup; i ++)
490     if (theenums->Value(i).IsEqual(val)) return i;
491 //  cas additionnel ?
492   if (!theeadds.IsNull()) {
493     if (theeadds->GetItem (val,i,Standard_False)) return i;
494   }
495 //  entier possible
496   //gka S4054
497   for (i = 0; val[i] != '\0'; i ++)
498     if (val[i] != ' ' && val[i] != '-' && (val[i] < '0' || val[i] > '9' )) return (theintlow -1);
499   return atoi(val);
500 }
501
502 //  ******  object/entity  ******
503
504     void  MoniTool_TypedValue::SetObjectType
505   (const Handle(Standard_Type)& typ)
506 {
507   if (thetype != MoniTool_ValueIdent) Standard_ConstructionError::Raise
508     ("MoniTool_TypedValue : AddEnum, Not an Entity/Object");
509   theotyp = typ;
510 }
511
512     Handle(Standard_Type)  MoniTool_TypedValue::ObjectType () const
513 {
514   if (!theotyp.IsNull()) return theotyp;
515   return STANDARD_TYPE(Standard_Transient);
516 }
517
518 //  ******   Specific Interpret/Satisfy   ******
519
520     void  MoniTool_TypedValue::SetInterpret
521   (const MoniTool_ValueInterpret func)
522       {  theinterp = func;  }
523
524     Standard_Boolean  MoniTool_TypedValue::HasInterpret () const
525 {
526   if (theinterp) return Standard_True;
527   if (thetype == MoniTool_ValueEnum) return Standard_True;
528   return Standard_False;
529 }
530
531     void  MoniTool_TypedValue::SetSatisfies
532   (const MoniTool_ValueSatisfies func, const Standard_CString name)
533 {
534   thesatisn.Clear();
535   thesatisf = func;
536   if (thesatisf) thesatisn.AssignCat (name);
537 }
538
539     Standard_CString MoniTool_TypedValue::SatisfiesName () const
540       {  return thesatisn.ToCString();  }
541
542 //  ###########    VALEUR DU STATIC    ############
543
544     Standard_Boolean MoniTool_TypedValue::IsSetValue () const
545 {
546   if (thetype == MoniTool_ValueIdent) return (!theoval.IsNull());
547   if (thehval->Length() > 0) return Standard_True;
548   if (!theoval.IsNull()) return Standard_True;
549   return Standard_False;
550 }
551
552     Standard_CString MoniTool_TypedValue::CStringValue () const
553       {  if (thehval.IsNull()) return "";  return thehval->ToCString();  }
554
555     Handle(TCollection_HAsciiString) MoniTool_TypedValue::HStringValue () const
556       {  return thehval;  }
557
558     Handle(TCollection_HAsciiString)  MoniTool_TypedValue::Interpret
559   (const Handle(TCollection_HAsciiString)& hval,
560    const Standard_Boolean native) const
561 {
562   Handle(TCollection_HAsciiString) inter = hval;
563   if (hval.IsNull()) return hval;
564   if (theinterp) return theinterp (this,hval,native);
565   if (thetype == MoniTool_ValueEnum) {
566 //  On admet les deux formes : Enum de preference, sinon Integer
567     Standard_Integer startcase, endcase; Standard_Boolean match;
568     EnumDef (startcase,endcase,match);
569     Standard_Integer encas = EnumCase (hval->ToCString());
570     if (encas < startcase) return hval;    // loupe
571     if (native) inter = new TCollection_HAsciiString (EnumVal(encas));
572     else inter = new TCollection_HAsciiString (encas);
573   }
574   return inter;
575 }
576
577     Standard_Boolean  MoniTool_TypedValue::Satisfies
578   (const Handle(TCollection_HAsciiString)& val) const
579 {
580   if (val.IsNull()) return Standard_False;
581   if (thesatisf)
582     if (!thesatisf (val) ) return Standard_False;
583   if (val->Length() == 0) return Standard_True;
584   switch (thetype) {
585     case MoniTool_ValueInteger : {
586       if (!val->IsIntegerValue()) return Standard_False;
587       Standard_Integer ival, ilim;  ival = atoi(val->ToCString());
588       if (IntegerLimit(Standard_False, ilim))
589         if (ilim > ival) return Standard_False;
590       if (IntegerLimit(Standard_True,  ilim))
591         if (ilim < ival) return Standard_False;
592       return Standard_True;
593     }
594     case MoniTool_ValueReal    : {
595       if (!val->IsRealValue()) return Standard_False;
596       Standard_Real rval, rlim;  rval = val->RealValue();
597       if (RealLimit(Standard_False, rlim))
598         if (rlim > rval) return Standard_False;
599       if (RealLimit(Standard_True,  rlim))
600         if (rlim < rval) return Standard_False;
601       return Standard_True;
602     }
603     case MoniTool_ValueEnum    : {
604 //  On admet les deux formes : Enum de preference, sinon Integer
605       Standard_Integer startcase, endcase;// unused ival;
606       Standard_Boolean match;
607       EnumDef (startcase,endcase,match);
608       if (!match) return Standard_True;
609       if (EnumCase (val->ToCString()) >= startcase) return Standard_True;
610 //  Ici, on admet un entier dans la fourchette
611 ////      if (val->IsIntegerValue()) ival = atoi (val->ToCString());
612
613 // PTV 16.09.2000 The if is comment, cause this check is never been done (You can see the logic)
614 //      if (ival >= startcase && ival <= endcase) return Standard_True;
615       return Standard_False;
616     }
617     case MoniTool_ValueText    : {
618       if (themaxlen > 0 && val->Length() > themaxlen) return Standard_False;
619       break;
620     }
621     default : break;
622   }
623   return Standard_True;
624 }
625
626     void  MoniTool_TypedValue::ClearValue ()
627 {
628   thehval.Nullify();
629   theoval.Nullify();
630   theival = 0;
631 }
632
633     Standard_Boolean  MoniTool_TypedValue::SetCStringValue
634   (const Standard_CString val)
635 {
636   Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(val);
637   if (hval->IsSameString (thehval)) return Standard_True;
638   if (!Satisfies(hval))  return Standard_False;
639   if      (thetype == MoniTool_ValueInteger) {
640     thehval->Clear();
641     theival = atoi(val);
642     thehval->AssignCat(val);
643   }
644   else if (thetype == MoniTool_ValueEnum) {
645     Standard_Integer ival = EnumCase(val);
646     Standard_CString cval = EnumVal(ival);
647     if (!cval || cval[0] == '\0') return Standard_False;
648     theival = ival;
649     thehval->Clear();
650     thehval->AssignCat(cval);
651   } else {
652     thehval->Clear();
653     thehval->AssignCat(val);
654     return Standard_True;
655   }
656   return Standard_True;
657 }
658
659     Standard_Boolean  MoniTool_TypedValue::SetHStringValue
660   (const Handle(TCollection_HAsciiString)& hval)
661 {
662   if (hval.IsNull())     return Standard_False;
663   if (!Satisfies(hval))  return Standard_False;
664   thehval = hval;
665   if      (thetype == MoniTool_ValueInteger) theival = atoi(hval->ToCString());
666   else if (thetype == MoniTool_ValueEnum)    theival = EnumCase(hval->ToCString());
667 //  else return Standard_True;
668   return Standard_True;
669 }
670
671     Standard_Integer  MoniTool_TypedValue::IntegerValue () const
672       {  return theival;  }
673
674     Standard_Boolean  MoniTool_TypedValue::SetIntegerValue
675   (const Standard_Integer ival)
676 {
677   Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(ival);
678   if (hval->IsSameString (thehval)) return Standard_True;
679   if (!Satisfies(hval))  return Standard_False;
680   thehval->Clear();
681   if (thetype == MoniTool_ValueEnum) thehval->AssignCat (EnumVal(ival));
682   else thehval->AssignCat (hval->ToCString());
683   theival = ival;
684   return Standard_True;
685 }
686
687     Standard_Real     MoniTool_TypedValue::RealValue () const
688 {
689   if (thehval->Length() == 0)  return 0.0;
690   if (!thehval->IsRealValue()) return 0.0;
691   return thehval->RealValue();
692 }
693
694     Standard_Boolean  MoniTool_TypedValue::SetRealValue (const Standard_Real rval)
695 {
696   Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(rval);
697   if (hval->IsSameString (thehval)) return Standard_True;
698   if (!Satisfies(hval))  return Standard_False;
699   thehval->Clear();  thehval->AssignCat (hval->ToCString());
700   return Standard_True;
701 }
702
703     Handle(Standard_Transient)  MoniTool_TypedValue::ObjectValue () const
704       {  return theoval;  }
705
706     void  MoniTool_TypedValue::GetObjectValue (Handle(Standard_Transient)& val) const
707       {  val = theoval;  }
708
709     Standard_Boolean  MoniTool_TypedValue::SetObjectValue
710   (const Handle(Standard_Transient)& obj)
711 {
712   if (thetype != MoniTool_ValueIdent) return Standard_False;
713   if (obj.IsNull()) { theoval.Nullify();  return Standard_True; }
714   if (!theotyp.IsNull())
715     if (!obj->IsKind(theotyp)) return Standard_False;
716   theoval = obj;
717   return Standard_True;
718 }
719
720
721     Standard_CString  MoniTool_TypedValue::ObjectTypeName () const
722 {
723   if (theoval.IsNull()) return "";
724   Handle(MoniTool_Element) elm = Handle(MoniTool_Element)::DownCast(theoval);
725   if (!elm.IsNull()) return elm->ValueTypeName();
726   return theoval->DynamicType()->Name();
727 }
728
729
730 //    ########        LIBRARY        ########
731
732     Standard_Boolean  MoniTool_TypedValue::AddLib
733   (const Handle(MoniTool_TypedValue)& tv, const Standard_CString defin)
734 {
735   if (tv.IsNull()) return Standard_False;
736   if (defin[0] != '\0') tv->SetDefinition(defin);
737 //  else if (tv->Definition() == '\0') return Standard_False;
738   libtv()->SetItem (tv->Name(),tv);
739   return Standard_True;
740 }
741
742     Handle(MoniTool_TypedValue)  MoniTool_TypedValue::Lib
743   (const Standard_CString defin)
744 {
745   Handle(MoniTool_TypedValue) val;
746   if (!libtv()->GetItem (defin,val,Standard_False)) val.Nullify();
747   return val;
748 }
749
750     Handle(MoniTool_TypedValue)  MoniTool_TypedValue::FromLib
751   (const Standard_CString defin)
752 {
753   Handle(MoniTool_TypedValue) val = MoniTool_TypedValue::Lib(defin);
754   if (!val.IsNull()) val = new MoniTool_TypedValue (val);
755   return val;
756 }
757
758     Handle(TColStd_HSequenceOfAsciiString)  MoniTool_TypedValue::LibList ()
759 {
760   Handle(TColStd_HSequenceOfAsciiString) list = new TColStd_HSequenceOfAsciiString();
761   if (libtv().IsNull()) return list;
762   for (Dico_IteratorOfDictionaryOfTransient it(libtv()); it.More();it.Next()) {
763     list->Append (it.Name());
764   }
765   return list;
766 }
767
768
769
770     Handle(Dico_DictionaryOfTransient)  MoniTool_TypedValue::Stats ()
771 {
772   static Handle(Dico_DictionaryOfTransient) astats;
773   if (astats.IsNull()) astats  = new Dico_DictionaryOfTransient;
774   return astats;
775 }
776
777     Handle(MoniTool_TypedValue)  MoniTool_TypedValue::StaticValue
778   (const Standard_CString name)
779 {
780   Handle(MoniTool_TypedValue) result;
781   if (!Stats()->GetItem(name,result)) result.Nullify();
782   return result;
783 }