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
  15 #include <Message_Messenger.hxx>
  16 #include <MoniTool_Element.hxx>
  17 #include <MoniTool_TypedValue.hxx>
  18 #include <OSD_Path.hxx>
  19 #include <Standard_ConstructionError.hxx>
  20 #include <Standard_Transient.hxx>
  21 #include <Standard_Type.hxx>
  22 #include <TCollection_AsciiString.hxx>
  23 #include <TCollection_HAsciiString.hxx>
  24
  25 #include <stdio.h>
  26 IMPLEMENT_STANDARD_RTTIEXT(MoniTool_TypedValue,Standard_Transient)
  27
  28 // Not Used :
  29 //static  char defmess[30];
  30 static NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)> thelibtv;
  31 static NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)> astats;
  32
  33 static NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)>& libtv()
  34 {
  35   if (thelibtv.IsEmpty()) {
  36     Handle(MoniTool_TypedValue) tv;
  37     tv = new MoniTool_TypedValue("Integer",MoniTool_ValueInteger);
  38     thelibtv.Bind ("Integer",tv);
  39     tv = new MoniTool_TypedValue("Real",MoniTool_ValueReal);
  40     thelibtv.Bind ("Real",tv);
  41     tv = new MoniTool_TypedValue("Text",MoniTool_ValueText);
  42     thelibtv.Bind ("Text",tv);
  43     tv = new MoniTool_TypedValue("Transient",MoniTool_ValueIdent);
  44     thelibtv.Bind ("Transient",tv);
  45     tv = new MoniTool_TypedValue("Boolean",MoniTool_ValueEnum);
  46     tv->AddDef ("enum 0");    //    = 0 False  ,  > 0 True
  47     tv->AddDef ("eval False");
  48     tv->AddDef ("eval True");
  49     thelibtv.Bind ("Boolean",tv);
  50     tv = new MoniTool_TypedValue("Logical",MoniTool_ValueEnum);
  51     tv->AddDef ("enum -1");    //    < 0 False  ,  = 0 Unk  ,  > 0 True
  52     tv->AddDef ("eval False");
  53     tv->AddDef ("eval Unknown");
  54     tv->AddDef ("eval True");
  55     thelibtv.Bind ("Logical",tv);
  56   }
  57   return thelibtv;
  58 }
  59
  60
  61 //  Fonctions Satisfies offertes en standard ...
  62 /* Not Used
  63
  64 static Standard_Boolean StaticPath(const Handle(TCollection_HAsciiString)& val)
  65 {
  66   OSD_Path apath;
  67   return apath.IsValid (TCollection_AsciiString(val->ToCString()));
  68 }
  69 */
  70
  71     MoniTool_TypedValue::MoniTool_TypedValue
  72   (const Standard_CString name,
  73    const MoniTool_ValueType type, const Standard_CString init)
  74     : thename (name) , thetype (type) ,
  75       thelims (0), themaxlen (0) , theintlow (0) , theintup (-1) ,
  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 (const Handle(Message_Messenger)& S) const
 232 {
 233   S<<"--- Typed Value : "<<Name();
 234   if (thelabel.Length() > 0) S<<"  Label : "<<Label();
 235   S<<endl<<"--- Type : "<<Definition()<<endl<<"--- Value : ";
 236
 237   PrintValue (S);
 238   S<<endl;
 239
 240   if (thesatisf) S<<" -- Specific Function for Satisfies : "<<thesatisn.ToCString()<<endl;
 241 }
 242
 243
 244     void  MoniTool_TypedValue::PrintValue (const Handle(Message_Messenger)& 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     theenums->SetValue(num,TCollection_AsciiString(val));
 448 //    On met AUSSI dans le dictionnaire
 449 //  else {
 450     theeadds.Bind (val,num);
 451 //  }
 452 }
 453
 454     Standard_Boolean  MoniTool_TypedValue::EnumDef
 455   (Standard_Integer& startcase, Standard_Integer& endcase,
 456    Standard_Boolean& match) const
 457 {
 458   if (thetype != MoniTool_ValueEnum) return Standard_False;
 459   startcase = theintlow;  endcase = theintup;
 460   match = ((thelims & 4) != 0);
 461   return Standard_True;
 462 }
 463
 464     Standard_CString  MoniTool_TypedValue::EnumVal
 465   (const Standard_Integer num) const
 466 {
 467   if (thetype != MoniTool_ValueEnum) return "";
 468   if (num < theintlow || num > theintup) return "";
 469   return theenums->Value(num).ToCString();
 470 }
 471
 472     Standard_Integer  MoniTool_TypedValue::EnumCase
 473   (const Standard_CString val) const
 474 {
 475   if (thetype != MoniTool_ValueEnum) return (theintlow - 1);
 476   Standard_Integer i; // svv Jan 10 2000 : porting on DEC
 477   for (i = theintlow; i <= theintup; i ++)
 478     if (theenums->Value(i).IsEqual(val)) return i;
 479 //  cas additionnel ?
 480   if (!theeadds.IsEmpty()) {
 481     if (theeadds.Find(val,i)) return i;
 482   }
 483 //  entier possible
 484   //gka S4054
 485   for (i = 0; val[i] != '\0'; i ++)
 486     if (val[i] != ' ' && val[i] != '-' && (val[i] < '0' || val[i] > '9' )) return (theintlow -1);
 487   return atoi(val);
 488 }
 489
 490 //  ******  object/entity  ******
 491
 492     void  MoniTool_TypedValue::SetObjectType
 493   (const Handle(Standard_Type)& typ)
 494 {
 495   if (thetype != MoniTool_ValueIdent) throw Standard_ConstructionError("MoniTool_TypedValue : AddEnum, Not an Entity/Object");
 496   theotyp = typ;
 497 }
 498
 499     Handle(Standard_Type)  MoniTool_TypedValue::ObjectType () const
 500 {
 501   if (!theotyp.IsNull()) return theotyp;
 502   return STANDARD_TYPE(Standard_Transient);
 503 }
 504
 505 //  ******   Specific Interpret/Satisfy   ******
 506
 507     void  MoniTool_TypedValue::SetInterpret
 508   (const MoniTool_ValueInterpret func)
 509       {  theinterp = func;  }
 510
 511     Standard_Boolean  MoniTool_TypedValue::HasInterpret () const
 512 {
 513   if (theinterp) return Standard_True;
 514   if (thetype == MoniTool_ValueEnum) return Standard_True;
 515   return Standard_False;
 516 }
 517
 518     void  MoniTool_TypedValue::SetSatisfies
 519   (const MoniTool_ValueSatisfies func, const Standard_CString name)
 520 {
 521   thesatisn.Clear();
 522   thesatisf = func;
 523   if (thesatisf) thesatisn.AssignCat (name);
 524 }
 525
 526     Standard_CString MoniTool_TypedValue::SatisfiesName () const
 527       {  return thesatisn.ToCString();  }
 528
 529 //  ###########    VALEUR DU STATIC    ############
 530
 531     Standard_Boolean MoniTool_TypedValue::IsSetValue () const
 532 {
 533   if (thetype == MoniTool_ValueIdent) return (!theoval.IsNull());
 534   if (thehval->Length() > 0) return Standard_True;
 535   if (!theoval.IsNull()) return Standard_True;
 536   return Standard_False;
 537 }
 538
 539     Standard_CString MoniTool_TypedValue::CStringValue () const
 540       {  if (thehval.IsNull()) return "";  return thehval->ToCString();  }
 541
 542     Handle(TCollection_HAsciiString) MoniTool_TypedValue::HStringValue () const
 543       {  return thehval;  }
 544
 545     Handle(TCollection_HAsciiString)  MoniTool_TypedValue::Interpret
 546   (const Handle(TCollection_HAsciiString)& hval,
 547    const Standard_Boolean native) const
 548 {
 549   Handle(TCollection_HAsciiString) inter = hval;
 550   if (hval.IsNull()) return hval;
 551   if (theinterp) return theinterp (this,hval,native);
 552   if (thetype == MoniTool_ValueEnum) {
 553 //  On admet les deux formes : Enum de preference, sinon Integer
 554     Standard_Integer startcase, endcase; Standard_Boolean match;
 555     EnumDef (startcase,endcase,match);
 556     Standard_Integer encas = EnumCase (hval->ToCString());
 557     if (encas < startcase) return hval;    // loupe
 558     if (native) inter = new TCollection_HAsciiString (EnumVal(encas));
 559     else inter = new TCollection_HAsciiString (encas);
 560   }
 561   return inter;
 562 }
 563
 564     Standard_Boolean  MoniTool_TypedValue::Satisfies
 565   (const Handle(TCollection_HAsciiString)& val) const
 566 {
 567   if (val.IsNull()) return Standard_False;
 568   if (thesatisf)
 569     if (!thesatisf (val) ) return Standard_False;
 570   if (val->Length() == 0) return Standard_True;
 571   switch (thetype) {
 572     case MoniTool_ValueInteger : {
 573       if (!val->IsIntegerValue()) return Standard_False;
 574       Standard_Integer ival, ilim;  ival = atoi(val->ToCString());
 575       if (IntegerLimit(Standard_False, ilim))
 576         if (ilim > ival) return Standard_False;
 577       if (IntegerLimit(Standard_True,  ilim))
 578         if (ilim < ival) return Standard_False;
 579       return Standard_True;
 580     }
 581     case MoniTool_ValueReal    : {
 582       if (!val->IsRealValue()) return Standard_False;
 583       Standard_Real rval, rlim;  rval = val->RealValue();
 584       if (RealLimit(Standard_False, rlim))
 585         if (rlim > rval) return Standard_False;
 586       if (RealLimit(Standard_True,  rlim))
 587         if (rlim < rval) return Standard_False;
 588       return Standard_True;
 589     }
 590     case MoniTool_ValueEnum    : {
 591 //  On admet les deux formes : Enum de preference, sinon Integer
 592       Standard_Integer startcase, endcase;// unused ival;
 593       Standard_Boolean match;
 594       EnumDef (startcase,endcase,match);
 595       if (!match) return Standard_True;
 596       if (EnumCase (val->ToCString()) >= startcase) return Standard_True;
 597 //  Ici, on admet un entier dans la fourchette
 598 ////      if (val->IsIntegerValue()) ival = atoi (val->ToCString());
 599
 600 // PTV 16.09.2000 The if is comment, cause this check is never been done (You can see the logic)
 601 //      if (ival >= startcase && ival <= endcase) return Standard_True;
 602       return Standard_False;
 603     }
 604     case MoniTool_ValueText    : {
 605       if (themaxlen > 0 && val->Length() > themaxlen) return Standard_False;
 606       break;
 607     }
 608     default : break;
 609   }
 610   return Standard_True;
 611 }
 612
 613     void  MoniTool_TypedValue::ClearValue ()
 614 {
 615   thehval.Nullify();
 616   theoval.Nullify();
 617   theival = 0;
 618 }
 619
 620     Standard_Boolean  MoniTool_TypedValue::SetCStringValue
 621   (const Standard_CString val)
 622 {
 623   Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(val);
 624   if (hval->IsSameString (thehval)) return Standard_True;
 625   if (!Satisfies(hval))  return Standard_False;
 626   if      (thetype == MoniTool_ValueInteger) {
 627     thehval->Clear();
 628     theival = atoi(val);
 629     thehval->AssignCat(val);
 630   }
 631   else if (thetype == MoniTool_ValueEnum) {
 632     Standard_Integer ival = EnumCase(val);
 633     Standard_CString cval = EnumVal(ival);
 634     if (!cval || cval[0] == '\0') return Standard_False;
 635     theival = ival;
 636     thehval->Clear();
 637     thehval->AssignCat(cval);
 638   } else {
 639     thehval->Clear();
 640     thehval->AssignCat(val);
 641     return Standard_True;
 642   }
 643   return Standard_True;
 644 }
 645
 646     Standard_Boolean  MoniTool_TypedValue::SetHStringValue
 647   (const Handle(TCollection_HAsciiString)& hval)
 648 {
 649   if (hval.IsNull())     return Standard_False;
 650   if (!Satisfies(hval))  return Standard_False;
 651   thehval = hval;
 652   if      (thetype == MoniTool_ValueInteger) theival = atoi(hval->ToCString());
 653   else if (thetype == MoniTool_ValueEnum)    theival = EnumCase(hval->ToCString());
 654 //  else return Standard_True;
 655   return Standard_True;
 656 }
 657
 658     Standard_Integer  MoniTool_TypedValue::IntegerValue () const
 659       {  return theival;  }
 660
 661     Standard_Boolean  MoniTool_TypedValue::SetIntegerValue
 662   (const Standard_Integer ival)
 663 {
 664   Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(ival);
 665   if (hval->IsSameString (thehval)) return Standard_True;
 666   if (!Satisfies(hval))  return Standard_False;
 667   thehval->Clear();
 668   if (thetype == MoniTool_ValueEnum) thehval->AssignCat (EnumVal(ival));
 669   else thehval->AssignCat (hval->ToCString());
 670   theival = ival;
 671   return Standard_True;
 672 }
 673
 674     Standard_Real     MoniTool_TypedValue::RealValue () const
 675 {
 676   if (thehval->Length() == 0)  return 0.0;
 677   if (!thehval->IsRealValue()) return 0.0;
 678   return thehval->RealValue();
 679 }
 680
 681     Standard_Boolean  MoniTool_TypedValue::SetRealValue (const Standard_Real rval)
 682 {
 683   Handle(TCollection_HAsciiString) hval = new TCollection_HAsciiString(rval);
 684   if (hval->IsSameString (thehval)) return Standard_True;
 685   if (!Satisfies(hval))  return Standard_False;
 686   thehval->Clear();  thehval->AssignCat (hval->ToCString());
 687   return Standard_True;
 688 }
 689
 690     Handle(Standard_Transient)  MoniTool_TypedValue::ObjectValue () const
 691       {  return theoval;  }
 692
 693     void  MoniTool_TypedValue::GetObjectValue (Handle(Standard_Transient)& val) const
 694       {  val = theoval;  }
 695
 696     Standard_Boolean  MoniTool_TypedValue::SetObjectValue
 697   (const Handle(Standard_Transient)& obj)
 698 {
 699   if (thetype != MoniTool_ValueIdent) return Standard_False;
 700   if (obj.IsNull()) { theoval.Nullify();  return Standard_True; }
 701   if (!theotyp.IsNull())
 702     if (!obj->IsKind(theotyp)) return Standard_False;
 703   theoval = obj;
 704   return Standard_True;
 705 }
 706
 707
 708     Standard_CString  MoniTool_TypedValue::ObjectTypeName () const
 709 {
 710   if (theoval.IsNull()) return "";
 711   Handle(MoniTool_Element) elm = Handle(MoniTool_Element)::DownCast(theoval);
 712   if (!elm.IsNull()) return elm->ValueTypeName();
 713   return theoval->DynamicType()->Name();
 714 }
 715
 716
 717 //    ########        LIBRARY        ########
 718
 719     Standard_Boolean  MoniTool_TypedValue::AddLib
 720   (const Handle(MoniTool_TypedValue)& tv, const Standard_CString defin)
 721 {
 722   if (tv.IsNull()) return Standard_False;
 723   if (defin[0] != '\0') tv->SetDefinition(defin);
 724 //  else if (tv->Definition() == '\0') return Standard_False;
 725   libtv().Bind(tv->Name(),tv);
 726   return Standard_True;
 727 }
 728
 729     Handle(MoniTool_TypedValue)  MoniTool_TypedValue::Lib
 730   (const Standard_CString defin)
 731 {
 732   Handle(MoniTool_TypedValue) val;
 733   Handle(Standard_Transient) aTVal;
 734   if (libtv().Find(defin, aTVal))
 735     val = Handle(MoniTool_TypedValue)::DownCast(aTVal);
 736   else
 737     val.Nullify();
 738   return val;
 739 }
 740
 741     Handle(MoniTool_TypedValue)  MoniTool_TypedValue::FromLib
 742   (const Standard_CString defin)
 743 {
 744   Handle(MoniTool_TypedValue) val = MoniTool_TypedValue::Lib(defin);
 745   if (!val.IsNull()) val = new MoniTool_TypedValue (val);
 746   return val;
 747 }
 748
 749     Handle(TColStd_HSequenceOfAsciiString)  MoniTool_TypedValue::LibList ()
 750 {
 751   Handle(TColStd_HSequenceOfAsciiString) list = new TColStd_HSequenceOfAsciiString();
 752   if (libtv().IsEmpty()) return list;
 753   NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)>::Iterator it(libtv());
 754   for (; it.More();it.Next()) {
 755     list->Append (it.Key());
 756   }
 757   return list;
 758 }
 759
 760 NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)>& MoniTool_TypedValue::Stats ()
 761 {
 762   return astats;
 763 }
 764
 765     Handle(MoniTool_TypedValue)  MoniTool_TypedValue::StaticValue
 766   (const Standard_CString name)
 767 {
 768   Handle(MoniTool_TypedValue) result;
 769   Handle(Standard_Transient) aTResult;
 770   if (Stats().Find(name, aTResult))
 771     result = Handle(MoniTool_TypedValue)::DownCast(aTResult);
 772   else
 773     result.Nullify();
 774   return result;
 775 }