src/Model/Model_AttributeRefList.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        ModelAPI_AttributeRefList.cxx
   4 // Created:     8 May 2014
   5 // Author:      Mikhail PONIKAROV
   6
   7 #include "Model_AttributeRefList.h"
   8 #include "Model_Application.h"
   9 #include "Model_Data.h"
  10 #include "Model_Objects.h"
  11 #include <ModelAPI_Feature.h>
  12 #include <TDF_ListIteratorOfLabelList.hxx>
  13
  14 using namespace std;
  15
  16 void Model_AttributeRefList::append(ObjectPtr theObject)
  17 {
  18   std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theObject->data());
  19   myRef->Append(aData->label().Father());  // store label of the object
  20   // do it before the transaction finish to make just created/removed objects know dependencies
  21   // and reference from composite feature is removed automatically
  22   ADD_BACK_REF(theObject);
  23
  24   owner()->data()->sendAttributeUpdated(this);
  25 }
  26
  27 void Model_AttributeRefList::remove(ObjectPtr theObject)
  28 {
  29   std::shared_ptr<Model_Data> aData;
  30   if (theObject.get() != NULL) {
  31     aData = std::dynamic_pointer_cast<Model_Data>(theObject->data());
  32     myRef->Remove(aData->label().Father());
  33     REMOVE_BACK_REF(theObject);
  34   }
  35   else { // in case of empty object remove, the first empty object is removed from the list
  36     std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
  37         owner()->document());
  38     if (aDoc) {
  39       const TDF_LabelList& aList = myRef->List();
  40       for (TDF_ListIteratorOfLabelList aLIter(aList); aLIter.More(); aLIter.Next()) {
  41         ObjectPtr anObj = aDoc->objects()->object(aLIter.Value());
  42         if (anObj.get() == NULL) {
  43           myRef->Remove(aLIter.Value());
  44           REMOVE_BACK_REF(theObject);
  45           break;
  46         }
  47       }
  48     }
  49   }
  50   owner()->data()->sendAttributeUpdated(this);
  51 }
  52
  53 void Model_AttributeRefList::clear()
  54 {
  55   std::list<ObjectPtr> anOldList = list();
  56   myRef->Clear();
  57   std::list<ObjectPtr>::iterator anOldIter = anOldList.begin();
  58   for(; anOldIter != anOldList.end(); anOldIter++) {
  59     REMOVE_BACK_REF((*anOldIter));
  60   }
  61   owner()->data()->sendAttributeUpdated(this);
  62 }
  63
  64 int Model_AttributeRefList::size(const bool theWithEmpty) const
  65 {
  66   if (theWithEmpty)
  67     return myRef->Extent();
  68   int aResult = 0;
  69   const TDF_LabelList& aList = myRef->List();
  70   for (TDF_ListIteratorOfLabelList aLIter(aList); aLIter.More(); aLIter.Next()) {
  71     if (!aLIter.Value().IsNull()) aResult++;
  72   }
  73   return aResult;
  74 }
  75
  76 bool Model_AttributeRefList::isInitialized()
  77 {
  78   if (size(false) == 0) { // empty list is not initialized list: sketch will be not valid after add/undo
  79     return false;
  80   }
  81   return ModelAPI_AttributeRefList::isInitialized();
  82 }
  83
  84 list<ObjectPtr> Model_AttributeRefList::list()
  85 {
  86   std::list<ObjectPtr> aResult;
  87   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
  88       owner()->document());
  89   if (aDoc) {
  90     const TDF_LabelList& aList = myRef->List();
  91     for (TDF_ListIteratorOfLabelList aLIter(aList); aLIter.More(); aLIter.Next()) {
  92       ObjectPtr anObj;
  93       if (!aLIter.Value().IsNull())
  94         anObj = aDoc->objects()->object(aLIter.Value());
  95       aResult.push_back(anObj);
  96     }
  97   }
  98   return aResult;
  99 }
 100
 101 bool Model_AttributeRefList::isInList(const ObjectPtr& theObj)
 102 {
 103   if(!theObj.get()) {
 104     return false;
 105   }
 106   std::list<ObjectPtr> aResult;
 107   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
 108       owner()->document());
 109   if (aDoc) {
 110     std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theObj->data());
 111     if (aData.get() && aData->isValid()) {
 112       TDF_Label anObjLab = aData->label().Father();
 113       const TDF_LabelList& aList = myRef->List();
 114       for (TDF_ListIteratorOfLabelList aLIter(aList); aLIter.More(); aLIter.Next()) {
 115         if (aLIter.Value().IsEqual(anObjLab)) {
 116           return true;
 117         }
 118       }
 119     }
 120   }
 121   return false;
 122 }
 123
 124 ObjectPtr Model_AttributeRefList::object(const int theIndex, const bool theWithEmpty) const
 125 {
 126   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
 127       owner()->document());
 128   if (aDoc) {
 129     const TDF_LabelList& aList = myRef->List();
 130     int anIndex = -1;
 131     for (TDF_ListIteratorOfLabelList aLIter(aList); aLIter.More(); aLIter.Next()) {
 132       if (theWithEmpty || !aLIter.Value().IsNull())
 133         anIndex++;
 134       if (anIndex == theIndex) {
 135         if (aLIter.Value().IsNull()) { // null label => null sub
 136           return ObjectPtr();
 137         }
 138         return aDoc->objects()->object(aLIter.Value());
 139       }
 140     }
 141   }
 142   return ObjectPtr();
 143 }
 144
 145 void Model_AttributeRefList::substitute(const ObjectPtr& theCurrent, const ObjectPtr& theNew)
 146 {
 147   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
 148       owner()->document());
 149   if (aDoc) {
 150     std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theCurrent->data());
 151     if (aData.get() && aData->isValid()) {
 152       TDF_Label aCurrentLab = aData->label().Father();
 153       TDF_Label aNewLab;
 154       if (theNew.get() && theNew->data()->isValid()) { // the new may be null
 155         std::shared_ptr<Model_Data> aNewData =
 156           std::dynamic_pointer_cast<Model_Data>(theNew->data());
 157         aNewLab = aNewData->label().Father();
 158       }
 159       // do the substitution
 160       ADD_BACK_REF(theNew);
 161       if (myRef->InsertAfter(aNewLab, aCurrentLab)) {
 162         myRef->Remove(aCurrentLab);
 163         REMOVE_BACK_REF(theCurrent);
 164       }
 165       owner()->data()->sendAttributeUpdated(this);
 166     }
 167   }
 168 }
 169
 170 void Model_AttributeRefList::exchange(const ObjectPtr& theObject1, const ObjectPtr& theObject2)
 171 {
 172   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
 173       owner()->document());
 174   if (aDoc) {
 175     std::shared_ptr<Model_Data> aData1 = std::dynamic_pointer_cast<Model_Data>(theObject1->data());
 176     if (aData1.get() && aData1->isValid()) {
 177       TDF_Label aLab1 = aData1->label().Father();
 178       if (theObject2.get() && theObject2->data()->isValid()) { // the new may be null
 179         std::shared_ptr<Model_Data> aData2 =
 180           std::dynamic_pointer_cast<Model_Data>(theObject2->data());
 181         if (aData2.get() && aData2->isValid()) {
 182           TDF_Label aLab2 = aData2->label().Father();
 183           // do the substitution: use the temporary label, as usually in exchange
 184           TDF_Label aTmpLab = aLab1.Root();
 185           if (myRef->InsertAfter(aTmpLab, aLab1)) {
 186             myRef->Remove(aLab1);
 187           }
 188           if (myRef->InsertAfter(aLab1, aLab2)) {
 189             myRef->Remove(aLab2);
 190           }
 191           if (myRef->InsertAfter(aLab2, aTmpLab)) {
 192             myRef->Remove(aTmpLab);
 193           }
 194           owner()->data()->sendAttributeUpdated(this);
 195         }
 196       }
 197     }
 198   }
 199 }
 200
 201 void Model_AttributeRefList::removeLast()
 202 {
 203   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
 204       owner()->document());
 205   if (aDoc && !myRef->IsEmpty()) {
 206     ObjectPtr anObj = aDoc->objects()->object(myRef->Last());
 207     if (anObj.get()) {
 208       myRef->Remove(myRef->Last());
 209       REMOVE_BACK_REF(anObj);
 210       owner()->data()->sendAttributeUpdated(this);
 211     }
 212   }
 213 }
 214
 215 void Model_AttributeRefList::remove(const std::set<int>& theIndices)
 216 {
 217   std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(
 218       owner()->document());
 219   if (aDoc && !myRef->IsEmpty()) {
 220     // collet labels that will be removed
 221     TDF_LabelList aLabelsToRemove;
 222     TDF_ListIteratorOfLabelList aLabIter(myRef->List());
 223     for(int aCurrent = 0; aLabIter.More(); aLabIter.Next(), aCurrent++) {
 224       if (theIndices.find(aCurrent) != theIndices.end())
 225         aLabelsToRemove.Append(aLabIter.Value());
 226     }
 227     // remove labels
 228     for(aLabIter.Initialize(aLabelsToRemove); aLabIter.More(); aLabIter.Next()) {
 229       ObjectPtr anObj = aDoc->objects()->object(aLabIter.Value());
 230       if (anObj.get()) {
 231         myRef->Remove(aLabIter.Value());
 232         REMOVE_BACK_REF(anObj);
 233       }
 234     }
 235     if (!aLabelsToRemove.IsEmpty()) {
 236       owner()->data()->sendAttributeUpdated(this);
 237     }
 238   }
 239 }
 240
 241 Model_AttributeRefList::Model_AttributeRefList(TDF_Label& theLabel)
 242 {
 243   myIsInitialized = theLabel.FindAttribute(TDataStd_ReferenceList::GetID(), myRef) == Standard_True;
 244   if (!myIsInitialized) {
 245     myRef = TDataStd_ReferenceList::Set(theLabel);
 246   }
 247 }