1 files changed, 387 insertions, 0 deletions
diff --git a/src/core/model/RBAAllocatable.cpp b/src/core/model/RBAAllocatable.cpp
new file mode 100644
index 0000000..aac639b
--- /dev/null
+++ b/src/core/model/RBAAllocatable.cpp
@@ -0,0 +1,387 @@
+/**
+ * Copyright (c) 2019 DENSO CORPORATION.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Allocatable class implementation
+ */
+
+#include <algorithm>
+
+#include "RBAAllocatable.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAViewContent.hpp"
+#include "RBAAreaImpl.hpp"
+#include "RBAConstraintImpl.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAConstraintMap.hpp"
+
+namespace rba
+{
+
+RBAAllocatable::RBAAllocatable(const std::string& name)
+  : RBARuleObject{name},
+    RBAAbstractAllocatable{name}
+{
+}
+
+void RBAAllocatable::clearStatus()
+{
+  allocatablesAffectedByThisAllocatable_.clear();
+  state_ = nullptr;
+  hiddenChecked_ = false;
+  checked_ = false;
+  attenuateChecked_ = false;
+  hidden_ = false;
+  attenuated_ = false;
+}
+
+bool
+RBAAllocatable::isArea() const
+{
+  return isModelElementType(RBAModelElementType::Area);
+}
+
+bool
+RBAAllocatable::isZone() const
+{
+  return isModelElementType(RBAModelElementType::Zone);
+}
+
+RBAArbitrationPolicy
+RBAAllocatable::getAllocatableArbitrationPolicy() const
+{
+  return arbitrationPolicy_;
+}
+
+void
+RBAAllocatable::setArbitrationPolicy(const RBAArbitrationPolicy newPolicy)
+{
+  arbitrationPolicy_ = newPolicy;
+}
+
+std::int32_t
+RBAAllocatable::getVisibility() const
+{
+  return visibility_;
+}
+
+void
+RBAAllocatable::setVisibility(const std::int32_t newVisibility)
+{
+  visibility_ = newVisibility;
+}
+  
+const std::list<const RBAAllocatable*>&
+RBAAllocatable::getAllocatablesAffectedByYou() const
+{
+  return allocatablesAffectedByThisAllocatable_;
+}
+
+void
+RBAAllocatable::clearAllocatablesAffectedByYou()
+{
+  return allocatablesAffectedByThisAllocatable_.clear();
+}
+
+void
+RBAAllocatable::addAllocatableWhichHasBeenAffectedByYou(const RBAAllocatable* const allocatable)
+{
+  allocatablesAffectedByThisAllocatable_.push_back(allocatable);
+}
+
+void
+RBAAllocatable::removeAffectAllocatable(const RBAAllocatable* const allocatable)
+{
+  const auto it = std::find(allocatablesAffectedByThisAllocatable_.begin(),
+		      allocatablesAffectedByThisAllocatable_.end(), allocatable);
+  if(it != allocatablesAffectedByThisAllocatable_.end()) {
+    static_cast<void>(allocatablesAffectedByThisAllocatable_.erase(it));
+  }
+}
+
+void
+RBAAllocatable::clearAffectAllocatable()
+{
+  allocatablesAffectedByThisAllocatable_.clear();
+}
+
+void
+RBAAllocatable::clearChecked()
+{
+  hiddenChecked_ = false;
+  checked_ = false;
+  attenuateChecked_ =false;
+  hidden_ = false;
+  attenuated_ = false;
+}
+
+std::int32_t
+RBAAllocatable::getIndex() const
+{
+  return index_;
+}
+
+void
+RBAAllocatable::setIndex(const std::int32_t newIndex)
+{
+  index_ = newIndex;
+}
+
+bool
+RBAAllocatable::compare(const RBAAllocatable* const arg0, 
+                        const RBAAllocatable* const arg1)
+{
+  const std::int32_t visibility0 {arg0->getVisibility()};
+  const std::int32_t visibility1 {arg1->getVisibility()};
+  // Do not swap because the front element is more visible than the rear element
+  if(visibility0 > visibility1) {
+    return true;
+  }
+  // Compare the Z orders because the front element and the rear element
+  // have the same visibility.
+  else if(visibility0 == visibility1) {
+    std::int32_t zorder0{0};
+    std::int32_t zorder1{0};
+    if(arg0->isModelElementType(RBAModelElementType::Area)) {
+      zorder0 = (dynamic_cast<const RBAAreaImpl*>(arg0))->getZorder();
+      zorder1 = (dynamic_cast<const RBAAreaImpl*>(arg1))->getZorder();
+    }
+    else {
+      zorder0 = ZONE_ZORDER;
+      zorder1 = ZONE_ZORDER;
+    }
+    // Do not swap because the front element has a larger Z order than 
+    // the rear element.
+    if(zorder0 > zorder1) {
+      return true;
+    }
+    // Do not swap because the Z order of the front element and the rear element 
+    // is the same
+    else if(zorder0 == zorder1) {
+      return false;
+    }
+    // Swap because the front element has a smaller Z order than 
+    // the rear element.
+    else {
+      return false;
+    }
+  }
+  // Replace because the front element is less visible than 
+  // the rear element.
+  else {
+    return false;
+  }
+}
+
+bool
+RBAAllocatable::compareIndex(const RBAAllocatable* const arg0,
+			     const RBAAllocatable* const arg1)
+{
+  return arg0->getIndex() < arg1->getIndex();
+}
+
+void
+RBAAllocatable::addConstraint(RBAConstraintImpl* const constraint,
+                              const RBAConstraintMap& kind)
+{
+  if (kind == RBAConstraintMap::CONTENT_ALLOCATE_CONSTRAINTS) {
+    addConstraintImpl(constraint, constraints_);
+  } else if (kind == RBAConstraintMap::HIDDEN_TRUE_CHECK_CONSTRAINTS) {
+    addConstraintImpl(constraint, hiddenTrueCheckConstraints_);
+  } else if (kind == RBAConstraintMap::HIDDEN_FALSE_CHECK_CONSTRAINTS) {
+    addConstraintImpl(constraint, hiddenFalseCheckConstraints_);
+  } else if (kind == RBAConstraintMap::ATTENUATE_TRUE_CHECK_CONSTRAINTS) {
+    addConstraintImpl(constraint, attenuateTrueCheckConstraints_);
+  } else {
+    addConstraintImpl(constraint, attenuateFalseCheckConstraints_);
+  }
+}
+
+std::list<RBAConstraintImpl*>&
+RBAAllocatable::getConstraints()
+{
+  return constraints_;
+}
+std::list<RBAConstraintImpl*>& RBAAllocatable::getHiddenTrueCheckConstraints()
+{
+  return hiddenTrueCheckConstraints_;
+}
+std::list<RBAConstraintImpl*>& RBAAllocatable::getHiddenFalseCheckConstraints()
+{
+  return hiddenFalseCheckConstraints_;
+}
+std::list<RBAConstraintImpl*>& RBAAllocatable::getAttenuateTrueCheckConstraints()
+{
+  return attenuateTrueCheckConstraints_;
+}
+std::list<RBAConstraintImpl*>& RBAAllocatable::getAttenuateFalseCheckConstraints()
+{
+  return attenuateFalseCheckConstraints_;
+}
+
+bool RBAAllocatable::hasConstraint(const RBAConstraintImpl* const constraint) const
+{
+  if ((std::find(constraints_.begin(), constraints_.end(), constraint)
+      != constraints_.end())
+      || (std::find(hiddenTrueCheckConstraints_.begin(),
+                    hiddenTrueCheckConstraints_.end(), constraint)
+          != hiddenTrueCheckConstraints_.end())
+      || (std::find(hiddenFalseCheckConstraints_.begin(),
+                    hiddenFalseCheckConstraints_.end(), constraint)
+          != hiddenFalseCheckConstraints_.end())
+      || (std::find(attenuateTrueCheckConstraints_.begin(),
+                    attenuateTrueCheckConstraints_.end(), constraint)
+          != attenuateTrueCheckConstraints_.end())
+      || (std::find(attenuateFalseCheckConstraints_.begin(),
+                    attenuateFalseCheckConstraints_.end(), constraint)
+          != attenuateFalseCheckConstraints_.end())) {
+    return true;
+  }
+  return false;
+}
+
+bool
+RBAAllocatable::isChecked() const
+{
+  return checked_;
+}
+
+void
+RBAAllocatable::setChecked(const bool checked)
+{
+  checked_ = checked;
+}
+
+bool
+RBAAllocatable::isHiddenChecked() const
+{
+  return hiddenChecked_;
+}
+
+void
+RBAAllocatable::setHiddenChecked(const bool hiddenChecked)
+{
+  hiddenChecked_ = hiddenChecked;
+}
+
+bool
+RBAAllocatable::isAttenuateChecked() const
+{
+  return attenuateChecked_;
+}
+
+void
+RBAAllocatable::setAttenuateChecked(const bool attenuateChecked)
+{
+  this->attenuateChecked_ = attenuateChecked;
+}
+
+bool
+RBAAllocatable::isAttenuated() const
+{
+  return attenuated_;
+}
+
+void
+RBAAllocatable::setAttenuated(const bool attenuated)
+{
+  this->attenuated_ = attenuated;
+}
+
+bool
+RBAAllocatable::isHidden() const
+{
+  return hidden_;
+}
+
+void
+RBAAllocatable::setHidden(const bool hidden)
+{
+  hidden_ = hidden;
+}
+
+const RBAContentState*
+RBAAllocatable::getState() const
+{
+  return state_;
+}
+
+void
+RBAAllocatable::setState(const RBAContentState* const state)
+{
+  state_ = state;
+}
+
+#ifdef RBA_USE_LOG
+std::string
+RBAAllocatable::getSymbol() const
+{
+  // This function is never called because the function of the derived class 
+  // is called.
+  return "Allocatable";
+}
+
+std::string
+RBAAllocatable::getHiddenSymbol() const
+{
+  // This function is never called because the function of the derived class 
+  // is called.
+  return "Allocatable: Unsuppored operation exception";
+}
+
+std::string
+RBAAllocatable::getArbitrationPolicyString() const
+{
+  std::string res;
+  switch(arbitrationPolicy_) {
+  case RBAArbitrationPolicy::FIRST_COME_FIRST:
+    res = "FIRST_COME_FIRST";
+    break;
+  case RBAArbitrationPolicy::LAST_COME_FIRST:
+    res = "LAST_COME_FIRST";
+    break;
+  case RBAArbitrationPolicy::PRIORITY_FIRST_COME_FIRST:
+    res = "PRIORITY_FIRST_COME_FIRST";
+    break;
+  case RBAArbitrationPolicy::PRIORITY_LAST_COME_FIRST:
+    res = "PRIORITY_LAST_COME_FIRST";
+    break;
+  default:
+    res = "DEFAULT";
+    break;
+  }
+
+  return res;
+}
+
+std::string
+RBAAllocatable::getVisibilityString() const
+{
+  return std::to_string(visibility_);
+}
+#endif
+
+void
+RBAAllocatable::addConstraintImpl(RBAConstraintImpl* const constraint,
+                                  std::list<RBAConstraintImpl*>& constraints)
+{
+  if (std::find(constraints.begin(), constraints.end(), constraint)
+      == constraints.end()) {
+    constraints.push_back(constraint);
+  }
+}
+
+}