src/Model/Model_Expression.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        Model_Expression.cpp
   4 // Created:     5 Aug 2015
   5 // Author:      Sergey POKHODENKO
   6
   7 #include "Model_Expression.h"
   8
   9 #include <TCollection_AsciiString.hxx>
  10 #include <TCollection_ExtendedString.hxx>
  11 #include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
  12 #include <TDataStd_UAttribute.hxx>
  13
  14 #include <TDataStd_RealArray.hxx>
  15 #include <TDataStd_ExtStringArray.hxx>
  16
  17 #include <limits>
  18
  19 static Standard_GUID kInvalidGUID("caee5ce4-34b1-4b29-abcb-685287d18096");
  20
  21
  22 Model_Expression::Model_Expression(TDF_Label& theLabel)
  23 {
  24   if (!theLabel.FindAttribute(TDataStd_Name::GetID(), myText)) {
  25     myText = TDataStd_Name::Set(theLabel, TCollection_ExtendedString());
  26   }
  27   if (!theLabel.FindAttribute(TDataStd_Comment::GetID(), myError)) {
  28     myError = TDataStd_Comment::Set(theLabel, TCollection_ExtendedString());
  29   }
  30   if (!theLabel.FindAttribute(TDataStd_ExtStringList::GetID(), myUsedParameters)) {
  31     myUsedParameters = TDataStd_ExtStringList::Set(theLabel);
  32   }
  33 }
  34
  35 void Model_Expression::setText(const std::string& theValue)
  36 {
  37   if (text() != theValue) {
  38     myText->Set(TCollection_ExtendedString(theValue.c_str()));
  39     myIsInitialized = true; // the value will be set very soon
  40   }
  41
  42   setError(text().empty() ? "" : "Not a double value.");
  43 }
  44
  45 std::string Model_Expression::text() const
  46 {
  47   return TCollection_AsciiString(myText->Get()).ToCString();
  48 }
  49
  50 void Model_Expression::setError(const std::string& theError)
  51 {
  52   if (error() != theError)
  53     myError->Set(TCollection_ExtendedString(theError.c_str()));
  54 }
  55
  56 std::string Model_Expression::error()
  57 {
  58   return TCollection_AsciiString(myError->Get()).ToCString();
  59 }
  60
  61 void Model_Expression::setUsedParameters(const std::set<std::string>& theUsedParameters)
  62 {
  63   myUsedParameters->Clear();
  64   std::set<std::string>::const_iterator anIt = theUsedParameters.begin();
  65   for (; anIt != theUsedParameters.end(); ++anIt)
  66     myUsedParameters->Append(TCollection_ExtendedString(anIt->c_str()));
  67 }
  68
  69 std::set<std::string> Model_Expression::usedParameters() const
  70 {
  71   std::set<std::string> aResult;
  72   TDataStd_ListIteratorOfListOfExtendedString aIt;
  73   for (aIt.Initialize(myUsedParameters->List()); aIt.More(); aIt.Next())
  74     aResult.insert(TCollection_AsciiString(aIt.Value()).ToCString());
  75   return aResult;
  76 }
  77
  78 Model_ExpressionDouble::Model_ExpressionDouble(TDF_Label& theLabel)
  79     : Model_Expression(theLabel)
  80 {
  81   if (!theLabel.FindAttribute(TDataStd_Real::GetID(), myReal)) {
  82     myIsInitialized = false;
  83     // MPV: temporarily to support the previously saved files (to check and resolve bugs), to be removed
  84     Handle(TDataStd_RealArray) anOldArray;
  85     if (theLabel.Father().FindAttribute(TDataStd_RealArray::GetID(), anOldArray) == Standard_True) {
  86       myReal = TDataStd_Real::Set(theLabel, 0.);
  87       myReal->Set(anOldArray->Value(theLabel.Tag() - 1));
  88       myIsInitialized = true;
  89       Handle(TDataStd_ExtStringArray) anOldExp;
  90       if (theLabel.Father().FindAttribute(TDataStd_ExtStringArray::GetID(), anOldExp) == Standard_True) {
  91         myText->Set(anOldExp->Value(theLabel.Tag() - 1));
  92       }
  93     } else {
  94       Handle(TDataStd_Real) anOldReal;
  95       if (theLabel.Father().FindAttribute(TDataStd_Real::GetID(), anOldReal)) {
  96         myIsInitialized = true;
  97         myReal = TDataStd_Real::Set(theLabel, 0.);
  98         myReal->Set(anOldReal->Get());
  99         Handle(TDataStd_Name) aText;
 100         if (theLabel.Father().FindAttribute(TDataStd_Name::GetID(), aText)) {
 101           myText->Set(aText->Get());
 102         }
 103       }
 104     }
 105   } else
 106     myIsInitialized = true;
 107 }
 108
 109 void Model_ExpressionDouble::setValue(const double theValue)
 110 {
 111   if (!myIsInitialized || myReal.IsNull()) {
 112     myReal = TDataStd_Real::Set(myText->Label(), theValue);
 113     myIsInitialized = true;
 114   } else if (value() != theValue) {
 115     myReal->Set(theValue);
 116   }
 117 }
 118
 119 double Model_ExpressionDouble::value()
 120 {
 121   if (myIsInitialized)
 122     return myReal->Get();
 123   return std::numeric_limits<double>::max(); // error
 124 }
 125
 126 void Model_ExpressionDouble::setInvalid(const bool theFlag)
 127 {
 128   if (theFlag) {
 129     TDataStd_UAttribute::Set(myText->Label(), kInvalidGUID);
 130   } else {
 131     myText->Label().ForgetAttribute(kInvalidGUID);
 132   }
 133 }
 134
 135 bool Model_ExpressionDouble::isInvalid()
 136 {
 137   return myText->Label().IsAttribute(kInvalidGUID) == Standard_True;
 138 }
 139
 140
 141 Model_ExpressionInteger::Model_ExpressionInteger(TDF_Label& theLabel)
 142     : Model_Expression(theLabel)
 143 {
 144   if (!theLabel.FindAttribute(TDataStd_Integer::GetID(), myInteger)) {
 145     myIsInitialized = false;
 146   } else
 147     myIsInitialized = true;
 148 }
 149
 150 void Model_ExpressionInteger::setValue(const int theValue)
 151 {
 152   if (!myIsInitialized || myInteger.IsNull()) {
 153     myInteger = TDataStd_Integer::Set(myText->Label(), theValue);
 154     myIsInitialized = true;
 155   } else if (value() != theValue) {
 156     myInteger->Set(theValue);
 157   }
 158 }
 159
 160 int Model_ExpressionInteger::value()
 161 {
 162   if (myIsInitialized)
 163     return myInteger->Get();
 164   return std::numeric_limits<int>::max(); // error
 165 }
 166
 167 void Model_ExpressionInteger::setInvalid(const bool theFlag)
 168 {
 169   if (theFlag) {
 170     TDataStd_UAttribute::Set(myText->Label(), kInvalidGUID);
 171   } else {
 172     myText->Label().ForgetAttribute(kInvalidGUID);
 173   }
 174 }
 175
 176 bool Model_ExpressionInteger::isInvalid()
 177 {
 178   return myText->Label().IsAttribute(kInvalidGUID) == Standard_True;
 179 }