src/ModelAPI/ModelAPI_Events.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 /*
   4  * ModelAPI_Events.cpp
   5  *
   6  *  Created on: Dec 8, 2014
   7  *      Author: sbh
   8  */
   9
  10 #include <ModelAPI.h>
  11 #include <ModelAPI_Events.h>
  12
  13 ModelAPI_ObjectUpdatedMessage::ModelAPI_ObjectUpdatedMessage(const Events_ID theID,
  14                                                              const void* theSender)
  15     : Events_MessageGroup(theID, theSender)
  16 {
  17
  18 }
  19
  20 ModelAPI_ObjectUpdatedMessage::~ModelAPI_ObjectUpdatedMessage()
  21 {
  22
  23 }
  24
  25 ModelAPI_ObjectDeletedMessage::ModelAPI_ObjectDeletedMessage(const Events_ID theID,
  26                                                              const void* theSender)
  27     : Events_MessageGroup(theID, theSender)
  28 {
  29
  30 }
  31
  32 ModelAPI_ObjectDeletedMessage::~ModelAPI_ObjectDeletedMessage()
  33 {
  34
  35 }
  36
  37 ModelAPI_OrderUpdatedMessage::ModelAPI_OrderUpdatedMessage(const Events_ID theID,
  38                                                            const void* theSender)
  39     : Events_Message(theID, theSender)
  40 {
  41
  42 }
  43
  44 ModelAPI_OrderUpdatedMessage::~ModelAPI_OrderUpdatedMessage()
  45 {
  46
  47 }
  48
  49 ModelAPI_FeatureStateMessage::ModelAPI_FeatureStateMessage(const Events_ID theID,
  50                                                            const void* theSender)
  51  : Events_Message(theID, theSender)
  52 {
  53   myCurrentFeature = std::shared_ptr<ModelAPI_Feature>();
  54 }
  55
  56 ModelAPI_FeatureStateMessage::~ModelAPI_FeatureStateMessage()
  57 {
  58
  59 }
  60
  61 std::shared_ptr<ModelAPI_Feature> ModelAPI_FeatureStateMessage::feature() const
  62 {
  63   return myCurrentFeature;
  64 }
  65
  66 void ModelAPI_FeatureStateMessage::setFeature(std::shared_ptr<ModelAPI_Feature>& theFeature)
  67 {
  68   myCurrentFeature = theFeature;
  69 }
  70
  71 bool ModelAPI_FeatureStateMessage::hasState(const std::string& theKey) const
  72 {
  73   return myFeatureState.find(theKey) != myFeatureState.end();
  74 }
  75
  76 bool ModelAPI_FeatureStateMessage::state(const  std::string& theFeatureId, bool theDefault) const
  77 {
  78   if(hasState(theFeatureId)) {
  79     return myFeatureState.at(theFeatureId);
  80   }
  81   return theDefault;
  82 }
  83
  84 void ModelAPI_FeatureStateMessage::setState(const std::string& theFeatureId, bool theValue)
  85 {
  86   myFeatureState[theFeatureId] = theValue;
  87 }
  88
  89 std::list<std::string> ModelAPI_FeatureStateMessage::features() const
  90 {
  91   std::list<std::string> result;
  92   std::map<std::string, bool>::const_iterator it = myFeatureState.begin();
  93   for( ; it != myFeatureState.end(); ++it) {
  94     result.push_back(it->first);
  95   }
  96   return result;
  97 }
  98
  99
 100 ModelAPI_DocumentCreatedMessage::ModelAPI_DocumentCreatedMessage(const Events_ID theID,
 101                                                                  const void* theSender)
 102 : Events_Message(theID, theSender)
 103 {
 104
 105 }
 106
 107 ModelAPI_DocumentCreatedMessage::~ModelAPI_DocumentCreatedMessage()
 108 {
 109
 110 }
 111
 112 DocumentPtr ModelAPI_DocumentCreatedMessage::document() const
 113 {
 114   return myDocument;
 115 }
 116
 117 void ModelAPI_DocumentCreatedMessage::setDocument(DocumentPtr theDocument)
 118 {
 119   myDocument = theDocument;
 120 }
 121
 122 ModelAPI_AttributeEvalMessage::ModelAPI_AttributeEvalMessage(const Events_ID theID,
 123                                                                          const void* theSender)
 124 : Events_Message(theID, theSender)
 125 {
 126
 127 }
 128
 129 ModelAPI_AttributeEvalMessage::~ModelAPI_AttributeEvalMessage()
 130 {
 131
 132 }
 133
 134 AttributePtr ModelAPI_AttributeEvalMessage::attribute() const
 135 {
 136   return myAttribute;
 137 }
 138
 139 void ModelAPI_AttributeEvalMessage::setAttribute(AttributePtr theDocument)
 140 {
 141   myAttribute = theDocument;
 142 }
 143
 144 ModelAPI_ObjectRenamedMessage::ModelAPI_ObjectRenamedMessage(const Events_ID theID,
 145                                                              const void* theSender)
 146 : Events_Message(theID, theSender)
 147 {
 148
 149 }
 150
 151 ModelAPI_ObjectRenamedMessage::~ModelAPI_ObjectRenamedMessage()
 152 {
 153
 154 }
 155
 156 void ModelAPI_ObjectRenamedMessage::send(ObjectPtr theObject,
 157                                          const std::string& theOldName,
 158                                          const std::string& theNewName,
 159                                          const void* theSender)
 160 {
 161   std::shared_ptr<ModelAPI_ObjectRenamedMessage> aMessage(
 162     new ModelAPI_ObjectRenamedMessage(eventId(), theSender));
 163   aMessage->setObject(theObject);
 164   aMessage->setOldName(theOldName);
 165   aMessage->setNewName(theNewName);
 166   Events_Loop::loop()->send(aMessage);
 167 }
 168
 169 ObjectPtr ModelAPI_ObjectRenamedMessage::object() const
 170 {
 171   return myObject;
 172 }
 173
 174 void ModelAPI_ObjectRenamedMessage::setObject(ObjectPtr theObject)
 175 {
 176   myObject = theObject;
 177 }
 178
 179 std::string ModelAPI_ObjectRenamedMessage::oldName() const
 180 {
 181   return myOldName;
 182 }
 183
 184 void ModelAPI_ObjectRenamedMessage::setOldName(const std::string& theOldName)
 185 {
 186   myOldName = theOldName;
 187 }
 188
 189 std::string ModelAPI_ObjectRenamedMessage::newName() const
 190 {
 191   return myNewName;
 192 }
 193
 194 void ModelAPI_ObjectRenamedMessage::setNewName(const std::string& theNewName)
 195 {
 196   myNewName = theNewName;
 197 }
 198
 199 ModelAPI_ReplaceParameterMessage::ModelAPI_ReplaceParameterMessage(const Events_ID theID,
 200                                                                    const void* theSender)
 201 : Events_Message(theID, theSender)
 202 {
 203
 204 }
 205
 206 ModelAPI_ReplaceParameterMessage::~ModelAPI_ReplaceParameterMessage()
 207 {
 208
 209 }
 210
 211 void ModelAPI_ReplaceParameterMessage::send(ObjectPtr theObject,
 212                                             const void* theSender)
 213 {
 214   std::shared_ptr<ModelAPI_ReplaceParameterMessage> aMessage(
 215       new ModelAPI_ReplaceParameterMessage(eventId(), theSender));
 216   aMessage->setObject(theObject);
 217   Events_Loop::loop()->send(aMessage);
 218 }
 219
 220 ObjectPtr ModelAPI_ReplaceParameterMessage::object() const
 221 {
 222   return myObject;
 223 }
 224
 225 void ModelAPI_ReplaceParameterMessage::setObject(ObjectPtr theObject)
 226 {
 227   myObject = theObject;
 228 }
 229
 230
 231 // =====   ModelAPI_SolverFailedMessage   =====
 232 ModelAPI_SolverFailedMessage::ModelAPI_SolverFailedMessage(const Events_ID theID,
 233                                                            const void* theSender)
 234   : Events_Message(theID, theSender),
 235     myDOF(-1)
 236 {
 237 }
 238
 239 ModelAPI_SolverFailedMessage::~ModelAPI_SolverFailedMessage()
 240 {
 241 }
 242
 243 void ModelAPI_SolverFailedMessage::setObjects(const std::set<ObjectPtr>& theObjects)
 244 {
 245   myObjects = theObjects;
 246 }
 247
 248 const std::set<ObjectPtr>& ModelAPI_SolverFailedMessage::objects() const
 249 {
 250   return myObjects;
 251 }
 252