First commitjellyfish_9.99.4jellyfish/9.99.49.99.4

Signed-off-by: Kenji Hosokawa <khosokawa@jp.adit-jv.com>
Change-Id: I381abb0a6521f5349768a76ef7ceecbce4b2d701

277 files changed, 25055 insertions, 0 deletions

diff --git a/src/core/expression/RBAActionOperator.cpp b/src/core/expression/RBAActionOperator.cpp
new file mode 100644
index 0000000..7cd38ec
--- /dev/null
+++ b/src/core/expression/RBAActionOperator.cpp
@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+
+/* 
+ * Action operator class　definition
+ */
+
+#include "RBAActionOperator.hpp"
+#include "RBAExpressionType.hpp"
+
+namespace rba
+{
+
+#ifdef RBA_USE_LOG
+RBAExpressionType
+RBAActionOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::ACTION;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAActionOperator.hpp b/src/core/expression/RBAActionOperator.hpp
new file mode 100644
index 0000000..677f699
--- /dev/null
+++ b/src/core/expression/RBAActionOperator.hpp
@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+/**
+ * Action operator class
+ */
+
+#ifndef RBAACTIONOPERATOR_HPP
+#define RBAACTIONOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAActionOperator : public RBAOperator
+{
+protected:
+  RBAActionOperator()=default;
+  RBAActionOperator(const RBAActionOperator&)=delete;
+  RBAActionOperator(const RBAActionOperator&&)=delete;
+  RBAActionOperator& operator=(const RBAActionOperator&)=delete;
+  RBAActionOperator& operator=(const RBAActionOperator&&)=delete;
+
+public:
+  // Log
+#ifdef RBA_USE_LOG
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAActiveContents.cpp b/src/core/expression/RBAActiveContents.cpp
new file mode 100644
index 0000000..b5d88a7
--- /dev/null
+++ b/src/core/expression/RBAActiveContents.cpp
@@ -0,0 +1,108 @@
+/**
+ * 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.
+ */
+
+/**
+ * Select operator class definition
+ */
+
+#include <memory>
+#include "RBAActiveContents.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+RBAActiveContents::RBAActiveContents()
+: RBAAllocatableOperator(),
+  contentSet_{std::make_unique<RBAContentSet>()}
+{
+}
+
+void
+RBAActiveContents::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAActiveContents::getModelElementType() const
+{
+  return RBAModelElementType::ActiveContents;
+}
+
+const RBARuleObject*
+RBAActiveContents::getReferenceObjectCore(RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  LOG_addHierarchy(LOG_getSymbol());
+  const RBARuleObject* returnObj {nullptr};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const lhsObj {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  }
+  else if (lhsObj != nullptr) {
+    contentSet_->clear();
+    const RBAAllocatable* const alloc {dynamic_cast<const RBAAllocatable*>(lhsObj->getRawObject())};
+#ifdef RBA_USE_LOG
+    if (arb == nullptr) {
+      // Follow this path when called from createHierarchy()
+      returnObj = alloc->getContentSet();
+    } else {
+#endif
+      for (auto& content : alloc->getInternalContents()) {
+        if (alloc->isPrevious()) {
+          if (arb->getResult()->isPreActive(content)) {
+            contentSet_->addTarget(content);
+          }
+        } else {
+          if (arb->getResult()->isActive(content)) {
+            contentSet_->addTarget(content);
+          }
+        }
+      }
+      returnObj = contentSet_.get();
+#ifdef RBA_USE_LOG
+    }
+#endif
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  std::string objName = "NULL";
+  if (returnObj != nullptr) {
+    objName = returnObj->getElementName();
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      " + LOG_getExpressionText() + " is " + objName);
+#endif
+  LOG_removeHierarchy();
+  return returnObj;
+}
+#ifdef RBA_USE_LOG
+const std::string
+RBAActiveContents::getSymbol() const
+{
+  return ".activeContents()";
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAActiveContents.hpp b/src/core/expression/RBAActiveContents.hpp
new file mode 100644
index 0000000..3ee9f7d
--- /dev/null
+++ b/src/core/expression/RBAActiveContents.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/**
+ * ActiveContents operator
+ */
+
+#ifndef RBAACTIVECONTENTS_HPP
+#define RBAACTIVECONTENTS_HPP
+
+#include "RBAAllocatableOperator.hpp"
+#include "RBAContentSet.hpp"
+
+namespace rba
+{
+
+class RBAActiveContents : public RBAAllocatableOperator
+{
+ public:
+  RBAActiveContents();
+  RBAActiveContents(const RBAActiveContents&)=delete;
+  RBAActiveContents(const RBAActiveContents&&)=delete;
+  RBAActiveContents& operator=(const RBAActiveContents&)=delete;
+  RBAActiveContents& operator=(const RBAActiveContents&&)=delete;
+  virtual ~RBAActiveContents()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+#endif
+ private:
+  std::unique_ptr<RBAContentSet> contentSet_;
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAActiveContentsMaker.cpp b/src/core/expression/RBAActiveContentsMaker.cpp
new file mode 100644
index 0000000..f883fee
--- /dev/null
+++ b/src/core/expression/RBAActiveContentsMaker.cpp
@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAActiveContentsMaker.cpp
+/// @brief ActiveContents object creation class defintion
+///
+
+#include "RBAActiveContentsMaker.hpp"
+#include "RBAActiveContents.hpp"
+
+namespace rba
+{
+
+RBAActiveContentsMaker::RBAActiveContentsMaker()
+  : RBAOperatorMaker{"ActiveContents"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAActiveContentsMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAActiveContents>();
+}
+
+}
diff --git a/src/core/expression/RBAActiveContentsMaker.hpp b/src/core/expression/RBAActiveContentsMaker.hpp
new file mode 100644
index 0000000..493e569
--- /dev/null
+++ b/src/core/expression/RBAActiveContentsMaker.hpp
@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAActiveContentsMaker.hpp
+/// @brief ActiveContents object creation class header
+///
+
+#ifndef RBAACTIVECONTENTSMAKER_HPP
+#define RBAACTIVECONTENTSMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ActiveContents object creation class
+class RBAActiveContentsMaker : public RBAOperatorMaker
+{
+public:
+  RBAActiveContentsMaker();
+  RBAActiveContentsMaker(const RBAActiveContentsMaker&)=delete;
+  RBAActiveContentsMaker(const RBAActiveContentsMaker&&)=delete;
+  RBAActiveContentsMaker& operator=(const RBAActiveContentsMaker&)=delete;
+  RBAActiveContentsMaker& operator=(const RBAActiveContentsMaker&&)=delete;
+  virtual ~RBAActiveContentsMaker()=default;
+
+public:
+  /// @brief Empty instanciation
+  /// @details Create an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAActiveState.cpp b/src/core/expression/RBAActiveState.cpp
new file mode 100644
index 0000000..1e0f6b3
--- /dev/null
+++ b/src/core/expression/RBAActiveState.cpp
@@ -0,0 +1,83 @@
+/**
+ * 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.
+ */
+/**
+ * activeState definition
+ */
+
+#include "RBAActiveState.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentState.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBALogManager.hpp"
+
+namespace rba
+{
+
+void RBAActiveState::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+RBAModelElementType RBAActiveState::getModelElementType() const
+{
+  return RBAModelElementType::ActiveState;
+}
+const RBARuleObject* RBAActiveState::getReferenceObjectCore(
+    RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  LOG_addHierarchy(LOG_getSymbol());
+  const RBARuleObject* returnObj {nullptr};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const ruleObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                     arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (ruleObj != nullptr) {
+    const RBAContent* const c {
+        dynamic_cast<const RBAContent*>(ruleObj->getRawObject())};
+    if (ruleObj->isPrevious()) {
+      returnObj = arb->getResult()->getPreActiveState(c);
+    } else {
+      returnObj = arb->getResult()->getActiveState(c);
+    }
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  std::string str;
+  if (info->isExceptionBeforeArbitrate()) {
+    str = " is before arbitrate skip";
+  } else if (ruleObj == nullptr) {
+    str = " no Content";
+  } else if (returnObj == nullptr) {
+    str = " has no Active State";
+  } else {
+    str = " is " + returnObj->getElementName();
+  }
+  LOG_arbitrateConstraintLogicLogLine("      " + getExpressionText() + str);
+#endif
+  LOG_removeHierarchy();
+  return returnObj;
+}
+#ifdef RBA_USE_LOG
+const std::string RBAActiveState::getSymbol() const
+{
+  return ".activeState()";
+}
+#endif
+} /* namespace rba */
diff --git a/src/core/expression/RBAActiveState.hpp b/src/core/expression/RBAActiveState.hpp
new file mode 100644
index 0000000..3876c78
--- /dev/null
+++ b/src/core/expression/RBAActiveState.hpp
@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+//
+// activeState header
+//
+
+#ifndef RBAACTIVESTATE_HPP
+#define RBAACTIVESTATE_HPP
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class RBAActiveState : public RBAContentOperator
+{
+ public:
+  RBAActiveState()=default;
+  RBAActiveState(const RBAActiveState&)=delete;
+  RBAActiveState(const RBAActiveState&&)=delete;
+  RBAActiveState& operator=(const RBAActiveState&)=delete;
+  RBAActiveState& operator=(const RBAActiveState&&)=delete;
+  virtual ~RBAActiveState()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+#endif
+};
+
+} /* namespace rba */
+
+#endif /* RBAACTIVESTATE_HPP */
diff --git a/src/core/expression/RBAActiveStateMaker.cpp b/src/core/expression/RBAActiveStateMaker.cpp
new file mode 100644
index 0000000..16d8f4c
--- /dev/null
+++ b/src/core/expression/RBAActiveStateMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAActiveStateMaker.cpp
+/// @brief ActiveState objeckt maker class definition
+
+#include "RBAActiveStateMaker.hpp"
+#include "RBAActiveState.hpp"
+
+namespace rba
+{
+
+RBAActiveStateMaker::RBAActiveStateMaker()
+  : RBAOperatorMaker{"ActiveState"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAActiveStateMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAActiveState>();
+}
+
+}
diff --git a/src/core/expression/RBAActiveStateMaker.hpp b/src/core/expression/RBAActiveStateMaker.hpp
new file mode 100644
index 0000000..7d42cbe
--- /dev/null
+++ b/src/core/expression/RBAActiveStateMaker.hpp
@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAActiveStateMaker.hpp
+/// @brief ActiveState object maker class header
+///
+
+#ifndef RBAACTIVESTATEMAKER_HPP
+#define RBAACTIVESTATEMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ActiveState object maker class
+class RBAActiveStateMaker : public RBAOperatorMaker
+{
+public:
+  RBAActiveStateMaker();
+  RBAActiveStateMaker(const RBAActiveStateMaker&)=delete;
+  RBAActiveStateMaker(const RBAActiveStateMaker&&)=delete;
+  RBAActiveStateMaker& operator=(const RBAActiveStateMaker&)=delete;
+  RBAActiveStateMaker& operator=(const RBAActiveStateMaker&&)=delete;
+  virtual ~RBAActiveStateMaker()=default;
+
+protected:
+  /// @brief Empty instanciation
+  /// @details Create an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAAllocatableOperator.cpp b/src/core/expression/RBAAllocatableOperator.cpp
new file mode 100644
index 0000000..15a9104
--- /dev/null
+++ b/src/core/expression/RBAAllocatableOperator.cpp
@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+/**
+ * Allcatable operator class definitio
+ */
+
+#include "RBAAllocatableOperator.hpp"
+
+namespace rba
+{
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAAllocatableOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+
+const std::string
+RBAAllocatableOperator::getCoverageExpressionText() const
+{
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAAllocatableOperator.hpp b/src/core/expression/RBAAllocatableOperator.hpp
new file mode 100644
index 0000000..7a4f40a
--- /dev/null
+++ b/src/core/expression/RBAAllocatableOperator.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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 operator class header
+ */
+
+#ifndef RBAALLOCATABLEOPERATOR_HPP
+#define RBAALLOCATABLEOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAAllocatableOperator : public RBAOperator
+{
+protected:
+  RBAAllocatableOperator()=default;
+  RBAAllocatableOperator(const RBAAllocatableOperator&)=delete;
+  RBAAllocatableOperator(const RBAAllocatableOperator&&)=delete;
+  RBAAllocatableOperator& operator=(const RBAAllocatableOperator&)=delete;
+  RBAAllocatableOperator& operator=(const RBAAllocatableOperator&&)=delete;
+
+public:
+  virtual ~RBAAllocatableOperator()=default;
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAAllocatedContent.cpp b/src/core/expression/RBAAllocatedContent.cpp
new file mode 100644
index 0000000..923717d
--- /dev/null
+++ b/src/core/expression/RBAAllocatedContent.cpp
@@ -0,0 +1,118 @@
+/**
+ * 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.
+ */
+/**
+ * Allocated Content class
+ */
+
+#include "RBAAllocatedContent.hpp"
+
+#include "RBAAllocatable.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAContentState.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void RBAAllocatedContent::accept(RBAExpressionVisitor& visitor)
+{
+  // RBASceneAllocatableCollector which is the only visitor at the moment
+  // does not accept this content, so it will not pass this path.
+  //  
+  // However, in the future, another visitor may accept it, so leave this.
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAAllocatedContent::getModelElementType() const
+{
+  return RBAModelElementType::AllocatedContent;
+}
+
+const RBARuleObject*
+RBAAllocatedContent::getReferenceObjectCore(RBAConstraintInfo* info,
+                                            RBAArbitrator* arb) const
+{
+  const RBARuleObject* object {nullptr};  // return value
+  const auto leftInfo = info->getChild(0U);
+  const auto ruleObj = getLhsOperand()->getReferenceObject(leftInfo, arb);
+  if (ruleObj != nullptr) {
+    if (!leftInfo->isExceptionBeforeArbitrate()) {
+      const RBAAllocatable* const alloc {dynamic_cast<const RBAAllocatable*>(ruleObj->getRawObject())};
+      if (ruleObj->isPrevious() == true) {
+        const auto contentState = arb->getResult()->getDirectPreContentState(alloc);
+        if(contentState != nullptr) {
+          object = contentState->getOwner();
+        }
+      } else if (alloc->isChecked()) {
+        const auto contentState = alloc->getState();
+        if (contentState != nullptr) {
+          object = contentState->getOwner();
+        }
+        // At this point, it is unsure whether the constraint expression will be False or True,
+        // so put it in both.
+        info->addTrueAllocatable(alloc);
+        info->addFalseAllocatable(alloc);
+      } else {
+        info->setExceptionBeforeArbitrate(true);
+      }
+    } else {
+      info->setExceptionBeforeArbitrate(true);
+    }
+  }
+#ifdef RBA_USE_LOG
+  bool pre = false;
+  std::string str;
+  if (ruleObj == nullptr) {
+    // Currently there is no constraint expression that returns an area. 
+    // Therefore, ruleObj never becomes NULL.
+    // In the future, a constraint expression that returns an area 
+    // may be created, so leave this processing.
+    str = "Allocatable[NULL] has no Content skip";
+  } else {
+    pre = ruleObj->isPrevious();
+    if (info->isExceptionBeforeArbitrate()) {
+      str = "Allocatable[" + ruleObj->getElementName() + "] is before arbitrate skip";
+    } else if (object == nullptr) {
+      str = "Allocatable[" + ruleObj->getElementName() + "] has no Allocated Content";
+    } else {
+      str = "Allocatable[" + ruleObj->getElementName() + "] has Allocated Content["
+          + object->getElementName() + "]";
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine("      " + getPreMsg(pre) + str);
+#endif
+  return object;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAAllocatedContent::getSymbol() const
+{
+  return ".allocatedContent()";
+}
+
+void
+RBAAllocatedContent::createHierarchy()
+{
+  getLhsOperand()->createHierarchy();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAAllocatedContent.hpp b/src/core/expression/RBAAllocatedContent.hpp
new file mode 100644
index 0000000..6fb44e2
--- /dev/null
+++ b/src/core/expression/RBAAllocatedContent.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+/**
+ * Allocated Content class
+ */
+
+#ifndef RBAALLOCATEDCONTENT_HPP
+#define RBAALLOCATEDCONTENT_HPP
+
+#include "RBAAllocatableOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAAllocatedContent : public RBAAllocatableOperator
+{
+ public:
+  RBAAllocatedContent()=default;
+  RBAAllocatedContent(const RBAAllocatedContent&)=delete;
+  RBAAllocatedContent(const RBAAllocatedContent&&)=delete;
+  RBAAllocatedContent& operator=(const RBAAllocatedContent&)=delete;
+  RBAAllocatedContent& operator=(const RBAAllocatedContent&&)=delete;
+  virtual ~RBAAllocatedContent()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  void createHierarchy() override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAAllocatedContentMaker.cpp b/src/core/expression/RBAAllocatedContentMaker.cpp
new file mode 100644
index 0000000..36d3ad7
--- /dev/null
+++ b/src/core/expression/RBAAllocatedContentMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAllocatedContentMaker.cpp
+/// @brief AllocatedContent object maker class
+
+#include "RBAAllocatedContentMaker.hpp"
+#include "RBAAllocatedContent.hpp"
+
+namespace rba
+{
+
+RBAAllocatedContentMaker::RBAAllocatedContentMaker()
+  : RBAOperatorMaker{"AllocatedContent"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAAllocatedContentMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAAllocatedContent>();
+}
+
+}
diff --git a/src/core/expression/RBAAllocatedContentMaker.hpp b/src/core/expression/RBAAllocatedContentMaker.hpp
new file mode 100644
index 0000000..10f83b9
--- /dev/null
+++ b/src/core/expression/RBAAllocatedContentMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAllocatedContentMaker.hpp
+/// @brief AllocatedContent object maker class header file
+
+#ifndef RBAALLOCATEDCONTENTMAKER_HPP
+#define RBAALLOCATEDCONTENTMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief AllocatedContent object maker class
+class RBAAllocatedContentMaker : public RBAOperatorMaker
+{
+public:
+  RBAAllocatedContentMaker();
+  RBAAllocatedContentMaker(const RBAAllocatedContentMaker&)=delete;
+  RBAAllocatedContentMaker(const RBAAllocatedContentMaker&&)=delete;
+  RBAAllocatedContentMaker& operator=(const RBAAllocatedContentMaker&)=delete;
+  RBAAllocatedContentMaker& operator=(const RBAAllocatedContentMaker&&)=delete;
+  virtual ~RBAAllocatedContentMaker()=default;
+
+protected:
+  /// @brief Empty instanciation
+  /// @details Create an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAAndOperator.cpp b/src/core/expression/RBAAndOperator.cpp
new file mode 100644
index 0000000..0f3a30d
--- /dev/null
+++ b/src/core/expression/RBAAndOperator.cpp
@@ -0,0 +1,113 @@
+/**
+ * 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.
+ */
+
+/**
+ * AND operator class definition
+ */
+
+#include "RBAAndOperator.hpp"
+
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void
+RBAAndOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAAndOperator::getModelElementType() const
+{
+  return RBAModelElementType::AndOperator;
+}
+
+bool
+RBAAndOperator::executeCore(RBAConstraintInfo* info,
+                            RBAArbitrator * arb) const
+{
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  
+  std::uint32_t falseCount {0U};
+  std::uint32_t exceptionCount {0U};
+  std::uint32_t index {0U};
+  for(const auto& ope : getOperand()) {
+    // Add count to constraint hierarchy for coverage
+    LOG_addHierarchy("#" + std::to_string(index));
+
+    RBAConstraintInfo* const childInfo {info->getChild(index)};
+    const bool res {ope->execute(childInfo, arb)};
+    if(childInfo->isExceptionBeforeArbitrate()) {
+      exceptionCount++;
+    } else if(!res) {
+      falseCount++;
+    } else {
+      ;
+    }
+
+    // Remove count to constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    index++;
+  }
+
+  // with fail
+  if (falseCount > 0U) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+    // Rmove count to constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    return false;
+  }
+
+  // exception
+  if (exceptionCount > 0U) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+    // Rmove count to constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    info->setExceptionBeforeArbitrate(true);
+    return false;
+  }
+
+  LOG_arbitrateConstraintLogicLogLine(
+      "      [" + LOG_getExpressionText() + "] true");
+  LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                      RBAExecuteResult::TRUE);
+  // Rmove count to constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  return true;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAAndOperator::getSymbol() const
+{
+  return "AND";
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAAndOperator.hpp b/src/core/expression/RBAAndOperator.hpp
new file mode 100644
index 0000000..229c69f
--- /dev/null
+++ b/src/core/expression/RBAAndOperator.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/**
+ * AND operator class header fiel
+ */
+
+#ifndef RBAANDOPERATOR_HPP
+#define RBAANDOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAAndOperator : public RBALogicalOperator
+{
+ public:
+  RBAAndOperator()=default;
+  RBAAndOperator(const RBAAndOperator&)=delete;
+  RBAAndOperator(const RBAAndOperator&&)=delete;
+  RBAAndOperator& operator=(const RBAAndOperator&)=delete;
+  RBAAndOperator& operator=(const RBAAndOperator&&)=delete;
+  virtual ~RBAAndOperator()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAAndOperatorMaker.cpp b/src/core/expression/RBAAndOperatorMaker.cpp
new file mode 100644
index 0000000..1606e6b
--- /dev/null
+++ b/src/core/expression/RBAAndOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAndOperatorMaker.cpp
+/// @brief AndOperator object maker class defintion file
+
+#include "RBAAndOperatorMaker.hpp"
+#include "RBAAndOperator.hpp"
+
+namespace rba
+{
+
+RBAAndOperatorMaker::RBAAndOperatorMaker()
+  : RBAOperatorMaker{"AndOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAAndOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAAndOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAAndOperatorMaker.hpp b/src/core/expression/RBAAndOperatorMaker.hpp
new file mode 100644
index 0000000..6198440
--- /dev/null
+++ b/src/core/expression/RBAAndOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAndOperatorMaker.hpp
+/// @brief AndOperator object maker classs header file
+
+#ifndef RBAANDOPERATORMAKER_HPP
+#define RBAANDOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief AndOperator object maker classs
+class RBAAndOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAAndOperatorMaker();
+  RBAAndOperatorMaker(const RBAAndOperatorMaker&)=delete;
+  RBAAndOperatorMaker(const RBAAndOperatorMaker&&)=delete;
+  RBAAndOperatorMaker& operator=(const RBAAndOperatorMaker&)=delete;
+  RBAAndOperatorMaker& operator=(const RBAAndOperatorMaker&&)=delete;
+  virtual ~RBAAndOperatorMaker()=default;
+
+protected:
+  /// @brief Empty instanciation
+  /// @details Create an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAArithmeticOperator.cpp b/src/core/expression/RBAArithmeticOperator.cpp
new file mode 100644
index 0000000..2bf25de
--- /dev/null
+++ b/src/core/expression/RBAArithmeticOperator.cpp
@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+
+/**
+ * ArithmeticOperator class definition
+ */
+
+#include "RBAArithmeticOperator.hpp"
+
+namespace rba
+{
+
+}
diff --git a/src/core/expression/RBAArithmeticOperator.hpp b/src/core/expression/RBAArithmeticOperator.hpp
new file mode 100644
index 0000000..5113a84
--- /dev/null
+++ b/src/core/expression/RBAArithmeticOperator.hpp
@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+
+/**
+ * ArithmeticOperator class header file
+ */
+
+#ifndef RBAARITHMETICOPERATOR_HPP
+#define RBAARITHMETICOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAArithmeticOperator : public RBAOperator
+{
+protected:
+  RBAArithmeticOperator()=default;
+  RBAArithmeticOperator(const RBAArithmeticOperator&)=delete;
+  RBAArithmeticOperator(const RBAArithmeticOperator&&)=delete;
+  RBAArithmeticOperator& operator=(const RBAArithmeticOperator&)=delete;
+  RBAArithmeticOperator& operator=(const RBAArithmeticOperator&&)=delete;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAContentOperator.cpp b/src/core/expression/RBAContentOperator.cpp
new file mode 100644
index 0000000..6f7083b
--- /dev/null
+++ b/src/core/expression/RBAContentOperator.cpp
@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+
+/**
+ * ContentOperator class definition
+ */
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAContentOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+
+const std::string
+RBAContentOperator::getCoverageExpressionText() const
+{
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAContentOperator.hpp b/src/core/expression/RBAContentOperator.hpp
new file mode 100644
index 0000000..fef5ec3
--- /dev/null
+++ b/src/core/expression/RBAContentOperator.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/**
+ * ContentOperator class 
+ */
+
+#ifndef RBACONTENTOPERATOR_HPP
+#define RBACONTENTOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAContentOperator : public RBAOperator
+{
+protected:
+  RBAContentOperator()=default;
+  RBAContentOperator(const RBAContentOperator&)=delete;
+  RBAContentOperator(const RBAContentOperator&&)=delete;
+  RBAContentOperator& operator=(const RBAContentOperator&)=delete;
+  RBAContentOperator& operator=(const RBAContentOperator&&)=delete;
+
+public:
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAContentValue.cpp b/src/core/expression/RBAContentValue.cpp
new file mode 100644
index 0000000..23b1b20
--- /dev/null
+++ b/src/core/expression/RBAContentValue.cpp
@@ -0,0 +1,116 @@
+/**
+ * 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.
+ */
+
+/* 
+ * ContentValue class definition 
+ */
+
+#include <string>
+#include "RBAContentValue.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAContentState.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void RBAContentValue::accept(RBAExpressionVisitor& visitor)
+{
+  // RBA SceneAllocatableCollector which is only existing vistor at this time 
+  // does not accept the value of the content state.
+  // So this code doesn't work. 
+  //
+  // But, leave this because another visitor may accept it in the future.
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAContentValue::getModelElementType() const
+{
+  return RBAModelElementType::ContentValue;
+}
+
+std::int32_t
+RBAContentValue::getValueCore(RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  std::int32_t result { -99 };
+  const auto leftInfo = info->getChild(0U);
+  const auto r = getLhsOperand()->getReferenceObject(leftInfo, arb);
+  const RBAContentState* cs { nullptr };
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (r != nullptr) {
+      const auto a = dynamic_cast<const RBAAllocatable*>(r->getRawObject());
+      if (a != nullptr) {
+        if (r->isPrevious()) {
+          cs = arb->getResult()->getDirectPreContentState(a);
+          if (cs != nullptr) {
+            result = cs->getContentStatePriority();
+          }
+        } else {
+          info->addOperandAllocatable(a);
+          if (a->isChecked()) {
+            cs = a->getState();
+            if (cs != nullptr) {
+              result = cs->getContentStatePriority();
+            }
+          } else {
+            // Throw an Exception if arbitration is not over
+            info->setExceptionBeforeArbitrate(true);
+          }
+        }
+      }
+    }
+  }
+#ifdef RBA_USE_LOG
+  std::string pre;
+  std::string aName = "NULL";
+  std::string resultText = "no Content skip";
+  if (r != nullptr) {
+    aName = r->getElementName();
+    pre = getPreMsg(r->isPrevious());
+  }
+  if (info->isExceptionBeforeArbitrate()) {
+    resultText = "before arbitrate skip";
+  } else {
+    if (cs != nullptr) {
+      resultText = cs->getOwner()->getElementName() + "::" + cs->getElementName() + " : " + cs->getPriorityString();
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      "
+      + pre
+      + "Allocatable["
+      + aName
+      + "] has Content Priority ["
+      + resultText
+      + "]");
+  #endif
+  return result;
+}
+#ifdef RBA_USE_LOG
+const std::string
+RBAContentValue::getSymbol() const
+{
+  return ".contentValue()";
+}
+#endif
+}
diff --git a/src/core/expression/RBAContentValue.hpp b/src/core/expression/RBAContentValue.hpp
new file mode 100644
index 0000000..52bd841
--- /dev/null
+++ b/src/core/expression/RBAContentValue.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/* 
+ * ContentValue class header file 
+ */
+
+#ifndef RBACONTENTVALUE_HPP
+#define RBACONTENTVALUE_HPP
+
+#include <cstdint>
+#include "RBAAllocatableOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAContentValue : public RBAAllocatableOperator
+{
+public:
+  RBAContentValue()=default;
+  RBAContentValue(const RBAContentValue&)=delete;
+  RBAContentValue(RBAContentValue&&)=delete;
+  RBAContentValue& operator=(const RBAContentValue&)=delete;
+  RBAContentValue& operator=(RBAContentValue&&)=delete;
+  virtual ~RBAContentValue()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info,
+                            RBAArbitrator* arb) const override;
+
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAContentValueMaker.cpp b/src/core/expression/RBAContentValueMaker.cpp
new file mode 100644
index 0000000..48aaaeb
--- /dev/null
+++ b/src/core/expression/RBAContentValueMaker.cpp
@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAContentValueMaker.cpp
+/// @brief ContentValue object maker classs definition
+
+#include "RBAContentValueMaker.hpp"
+#include "RBAContentValue.hpp"
+
+namespace rba
+{
+
+RBAContentValueMaker::RBAContentValueMaker()
+  : RBAOperatorMaker{"ContentValue"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAContentValueMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAContentValue>();
+}
+
+
+}
diff --git a/src/core/expression/RBAContentValueMaker.hpp b/src/core/expression/RBAContentValueMaker.hpp
new file mode 100644
index 0000000..8f14c95
--- /dev/null
+++ b/src/core/expression/RBAContentValueMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAContentValueMaker.hpp
+/// @brief ContentValue object maker calss header file
+
+#ifndef RBACONTENTVALUEMAKER_HPP
+#define RBACONTENTVALUEMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ContentValue object generation class
+class RBAContentValueMaker : public RBAOperatorMaker
+{
+public:
+  RBAContentValueMaker();
+  RBAContentValueMaker(const RBAContentValueMaker&)=delete;
+  RBAContentValueMaker(const RBAContentValueMaker&&)=delete;
+  RBAContentValueMaker& operator=(const RBAContentValueMaker&)=delete;
+  RBAContentValueMaker& operator=(const RBAContentValueMaker&&)=delete;
+  virtual ~RBAContentValueMaker()=default;
+
+protected:
+  /// @brief Create empty instance
+  /// @details Create an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAExecuteResult.hpp b/src/core/expression/RBAExecuteResult.hpp
new file mode 100644
index 0000000..1eaf2a5
--- /dev/null
+++ b/src/core/expression/RBAExecuteResult.hpp
@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+
+/**
+ * A type that withdraws requests when arbitration loses
+ */
+
+#ifndef RBAEXECUTERESULT_HPP
+#define RBAEXECUTERESULT_HPP
+
+namespace rba
+{
+
+enum class RBAExecuteResult : std::uint8_t
+{
+  TRUE,
+  FALSE,
+  EXE,    // In case of action is performed by doAction() 
+          // (Excludes SetOfAction and IfAction)
+  NOTEXE, // In case of action is NOT performed　by doAction()
+          // (Excludes SetOfAction and IfAction)
+  SKIP    // In case of getValue() or getReferenceObject()
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAExistsOperator.cpp b/src/core/expression/RBAExistsOperator.cpp
new file mode 100644
index 0000000..8bb8f05
--- /dev/null
+++ b/src/core/expression/RBAExistsOperator.cpp
@@ -0,0 +1,175 @@
+/**
+ * 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.
+ */
+
+/**
+ * Exists operator Class definition
+ */
+
+#include "RBAExistsOperator.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAContent.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALambdaExpression.hpp"
+#include "RBALogManager.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAExistsOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAExistsOperator::getModelElementType() const
+{
+  return RBAModelElementType::ExistsOperator;
+}
+
+bool
+RBAExistsOperator::executeCore(RBAConstraintInfo* info,
+				   RBAArbitrator * arb) const
+{
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+
+  const RBAExpression* const setObj {getLhsOperand()};
+  RBALambdaExpression* const lambda {getLambda()};
+
+  // Get rule object and loop
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+
+  std::vector<const RBARuleObject*> objs;
+
+  const RBARuleObject* const ruleObj {setObj->getReferenceObject(leftInfo, arb)};
+  const RBARuleObject* objset {nullptr};
+  if (ruleObj != nullptr) { 
+    objset = ruleObj->getRawObject();
+  }
+
+  if (leftInfo->isExceptionBeforeArbitrate() || (objset == nullptr)) {
+    // Remove itself form the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+
+    info->setExceptionBeforeArbitrate(true);
+    return false;
+  }
+
+  if (dynamic_cast<const RBAAllocatableSet*>(objset) != nullptr) {
+    objs.clear();
+    for(const RBAAllocatable* alloc
+	  : dynamic_cast<const RBAAllocatableSet*>(objset)->getLeafAllocatable() ) {
+      objs.push_back(alloc);
+    }
+  }
+  else {
+    objs.clear();
+    for(const auto& cont : dynamic_cast<const RBAContentSet*>(objset)->getLeafContent() ){
+      objs.push_back(cont);
+    }
+  }
+
+  bool isTrue {false};
+  std::uint32_t i {0U};
+  for(const RBARuleObject* const obj : objs) {
+    // Add count to the constraint hierarchy for coverage
+    LOG_addHierarchy("#" + std::to_string(i));
+
+    RBAConstraintInfo* const childInfo {info->getChild(i)};
+    lambda->setRuleObj(obj);
+
+    const bool res {lambda->execute(childInfo, arb)};
+
+    // Remove count from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+
+    if(childInfo->isExceptionBeforeArbitrate()) {
+      info->setExceptionBeforeArbitrate(true);
+    } else {
+      isTrue = (isTrue || res);
+    }
+    i++;
+  }
+
+  if (isTrue == true) {
+    // Succeed
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+    // Remove itself from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    info->setExceptionBeforeArbitrate(false);
+    return true;
+  } else if (info->isExceptionBeforeArbitrate()) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+    // Remove itself from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    return false;
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+    // Remove itself from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    return false;
+  }
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAExistsOperator::getSymbol() const
+{
+  return "Exists";
+}
+
+const std::string
+RBAExistsOperator::getExpressionText() const
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  return getSymbol() + " "
+    + exprLhs->getExpressionText() + " "
+    + getLambda()->getExpressionText();
+}
+
+const std::string
+RBAExistsOperator::getCoverageExpressionText() const
+{
+  getLambda()->clearRuleObj();
+  RBAExpression* exprLhs = getLhsOperand();
+  return getSymbol() + " " +
+    exprLhs->getCoverageExpressionText() + " "
+    + getLambda()->getCoverageExpressionText();
+}
+
+RBAExpressionType
+RBAExistsOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAExistsOperator.hpp b/src/core/expression/RBAExistsOperator.hpp
new file mode 100644
index 0000000..e75af32
--- /dev/null
+++ b/src/core/expression/RBAExistsOperator.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * Exists operator Class header file
+ */
+
+#ifndef RBAEXISTSOPERATOR_HPP
+#define RBAEXISTSOPERATOR_HPP
+
+#include "RBALambdaContext.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAExistsOperator : public RBALambdaContext
+{
+public:
+  RBAExistsOperator()=default;
+  RBAExistsOperator(const RBAExistsOperator&)=delete;
+  RBAExistsOperator(const RBAExistsOperator&&)=delete;
+  RBAExistsOperator& operator=(const RBAExistsOperator&)=delete;
+  RBAExistsOperator& operator=(const RBAExistsOperator&&)=delete;
+  virtual ~RBAExistsOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAExistsOperatorMaker.cpp b/src/core/expression/RBAExistsOperatorMaker.cpp
new file mode 100644
index 0000000..eb8250a
--- /dev/null
+++ b/src/core/expression/RBAExistsOperatorMaker.cpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAExistsOperatorMaker.cpp
+/// @brief Exists Operator object maker Class definition
+
+#include "RBAExistsOperatorMaker.hpp"
+#include "RBAExistsOperator.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBAExistsOperatorMaker::RBAExistsOperatorMaker()
+  : RBALambdaContextMaker{"ExistsOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAExistsOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAExistsOperator>();
+}
+
+RBAModelElement*
+RBAExistsOperatorMaker::setProperty(RBAModelElement* element,
+                                    const RBAJsonElement* jsonElem,
+                                    RBAModelImpl* model,
+                                    RBAModelElement* owner)
+{
+  static_cast<void>(
+      RBALambdaContextMaker::setProperty(element, jsonElem, model, owner));
+
+  return element;
+}
+
+std::unique_ptr<RBALambdaContext>
+RBAExistsOperatorMaker::createLambdaContext()
+{
+  return std::make_unique<RBAExistsOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAExistsOperatorMaker.hpp b/src/core/expression/RBAExistsOperatorMaker.hpp
new file mode 100644
index 0000000..c88f610
--- /dev/null
+++ b/src/core/expression/RBAExistsOperatorMaker.hpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAExistsOperatorMaker.hpp
+/// @brief ExistsOperator object maker Class header
+
+#ifndef RBAEXISTSOPERATORMAKER_HPP
+#define RBAEXISTSOPERATORMAKER_HPP
+
+#include "RBALambdaContextMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ExistsOperator object maker Class
+class RBAExistsOperatorMaker : public RBALambdaContextMaker
+{
+public:
+  RBAExistsOperatorMaker();
+  RBAExistsOperatorMaker(const RBAExistsOperatorMaker&)=delete;
+  RBAExistsOperatorMaker(const RBAExistsOperatorMaker&&)=delete;
+  RBAExistsOperatorMaker& operator=(const RBAExistsOperatorMaker&)=delete;
+  RBAExistsOperatorMaker& operator=(const RBAExistsOperatorMaker&&)=delete;
+  virtual ~RBAExistsOperatorMaker()=default;
+
+protected:
+  /// @brief Create empty instance
+  /// @details Create an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set attributes of model element for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model Model for storing created object
+  /// @param[in,out] owner parent object(Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+
+  /// @brief Crate empty object of LambdaContext
+  /// @details Create empty object of unique_ptr
+  /// @return unique_ptr for LambdaContext object
+  std::unique_ptr<RBALambdaContext> createLambdaContext() override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAExpression.cpp b/src/core/expression/RBAExpression.cpp
new file mode 100644
index 0000000..2b9b6fc
--- /dev/null
+++ b/src/core/expression/RBAExpression.cpp
@@ -0,0 +1,156 @@
+/**
+ * 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.
+ */
+
+/**
+ * Expression class definition
+ */
+
+#include "RBAExpression.hpp"
+
+#include "RBALetStatement.hpp"
+#include "RBAConstraintInfo.hpp"
+#ifdef RBA_USE_LOG
+#include "RBAExpressionType.hpp"
+#endif
+
+namespace rba
+{
+
+void RBAExpression::addLetStatement(RBALetStatement* const letStatement)
+{
+  letStatements_.push_back(letStatement);
+}
+
+void
+RBAExpression::accept(RBAExpressionVisitor& visitor)
+{
+  // Not be called because the function of the derived class is called
+}
+
+bool
+RBAExpression::execute(RBAConstraintInfo* const info, RBAArbitrator * const arb) const
+{
+  info->setExpression(this);
+  for (RBALetStatement* const& letStatement : letStatements_) {
+    letStatement->setVariable(arb);
+  }
+  const bool result {executeCore(info, arb)};
+  if (result) {
+    info->setResult(RBAExecuteResult::TRUE);
+  } else {
+    info->setResult(RBAExecuteResult::FALSE);
+  }
+  return result;
+}
+
+bool
+RBAExpression::executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const
+{
+  // This function is called when an Expression that does not define 
+  // getReferenceObject() in evaluate() is specified. 
+  info->setExceptionBeforeArbitrate(true);
+  return false;
+}
+
+const RBARuleObject*
+RBAExpression::getReferenceObject(RBAConstraintInfo* const info,
+                                      RBAArbitrator* const arb) const
+{
+  info->setExpression(this);
+  for (RBALetStatement* const& letStatement : letStatements_) {
+    letStatement->setVariable(arb);
+  }
+  return getReferenceObjectCore(info, arb);
+}
+
+const RBARuleObject*
+RBAExpression::getReferenceObjectCore(RBAConstraintInfo* info,
+                                      RBAArbitrator* arb) const
+{
+  // This function is called when an Expression that does not define 
+  // getReferenceObject() in evaluateObject() is specified. 
+  return nullptr;
+}
+
+std::int32_t
+RBAExpression::getValue(RBAConstraintInfo* const info, RBAArbitrator * const arb) const
+{
+  info->setExpression(this);
+  for (RBALetStatement* const& letStatement : letStatements_) {
+    letStatement->setVariable(arb);
+  }
+  return getValueCore(info, arb);
+}
+
+const std::vector<RBALetStatement*>&
+RBAExpression::getLetStatements() const
+{
+  return letStatements_;
+}
+std::int32_t
+RBAExpression::getValueCore(RBAConstraintInfo* info, RBAArbitrator * arb) const
+{
+  // This function is called when an Expression that does not define 
+  // getValue() in evaluateValue() is specified. 
+  return -99;
+}
+
+void
+RBAExpression::doAction(RBAConstraintInfo* const info, RBAArbitrator* const arb)
+{
+  info->setExpression(this);
+  doActionCore(info, arb);
+  return;
+}
+
+void
+RBAExpression::doActionCore(RBAConstraintInfo* info, RBAArbitrator* arb)
+{
+  // This function is called when an Expression that does not define 
+  // doAction() in evaluateDoAction() is specified. 
+  return;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAExpression::getExpressionText() const
+{
+  // Not called because the function of the derived class is called
+  return "Unsupported operation exception";
+}
+
+const std::string
+RBAExpression::getCoverageExpressionText() const
+{
+  // Not called because the function of the derived class is called
+  return "Unsupported operation exception";
+}
+
+void
+RBAExpression::createHierarchy()
+{
+  // Not called because the function of the derived class is called
+}
+
+RBAExpressionType
+RBAExpression::getUnderlyingType() const
+{
+  // Not called because the function of the derived class is called
+  return RBAExpressionType::EXCEPTION;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAExpression.hpp b/src/core/expression/RBAExpression.hpp
new file mode 100644
index 0000000..9cd14e5
--- /dev/null
+++ b/src/core/expression/RBAExpression.hpp
@@ -0,0 +1,91 @@
+/**
+ * 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.
+ */
+
+/**
+ * Expression class header file
+ */
+
+#ifndef RBAEXPRESSION_HPP
+#define RBAEXPRESSION_HPP
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "RBAModelElement.hpp"
+
+namespace rba
+{
+
+class RBAExpressionVisitor;
+class RBALetStatement;
+class RBAArbitrator;
+class RBARuleObject;
+class RBAConstraintInfo;
+#ifdef RBA_USE_LOG
+enum class RBAExpressionType : std::uint8_t;
+#endif
+
+class DLL_EXPORT RBAExpression : public RBAModelElement
+{
+protected:
+  RBAExpression()=default;
+  RBAExpression(const RBAExpression&)=delete;
+  RBAExpression(const RBAExpression&&)=delete;
+  RBAExpression& operator=(const RBAExpression&)=delete;
+  RBAExpression& operator=(const RBAExpression&&)=delete;
+
+public:
+  virtual ~RBAExpression()=default;
+  void addLetStatement(RBALetStatement* const letStatement);
+  virtual void accept(RBAExpressionVisitor& visitor);
+  bool execute(RBAConstraintInfo* const info, RBAArbitrator* const arb) const;
+  const RBARuleObject* getReferenceObject(RBAConstraintInfo* const info,
+                                          RBAArbitrator* const arb) const;
+  std::int32_t getValue(RBAConstraintInfo* const info, RBAArbitrator* const arb) const;
+  void doAction(RBAConstraintInfo* const info, RBAArbitrator* const arb);
+  const std::vector<RBALetStatement*>& getLetStatements() const;
+
+  // Log
+#ifdef RBA_USE_LOG
+  virtual const std::string getExpressionText() const;
+  virtual const std::string getCoverageExpressionText() const;
+  virtual void createHierarchy();
+  virtual RBAExpressionType getUnderlyingType() const;
+#endif
+
+protected:
+  virtual bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const;
+  virtual const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const;
+  virtual std::int32_t getValueCore(RBAConstraintInfo* info,
+                                    RBAArbitrator* arb) const;
+  virtual void doActionCore(RBAConstraintInfo* info, RBAArbitrator* arb);
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::vector<RBALetStatement*> letStatements_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAExpressionMaker.cpp b/src/core/expression/RBAExpressionMaker.cpp
new file mode 100644
index 0000000..250ace0
--- /dev/null
+++ b/src/core/expression/RBAExpressionMaker.cpp
@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAExpreessionMaker.cpp
+/// @brief Abstract class definition file for expression object generation
+
+#include "RBAExpressionMaker.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBALetStatementMaker.hpp"
+#include "RBALetStatement.hpp"
+
+namespace rba
+{
+
+RBAExpressionMaker::RBAExpressionMaker(const std::string& label)
+  : RBAModelElementMaker{label}
+{
+}
+
+std::int32_t
+RBAExpressionMaker::setLetStatement(RBAModelImpl* const model,
+                                    RBAExpression* const expr,
+                                    const RBAJsonElement* const jsonElem)
+{
+  std::int32_t var_num {0};
+  const RBAJsonElement* const letElem {jsonElem->findChildren("letStatements")};
+  if(letElem != nullptr) {
+    RBALetStatementMaker letMaker;
+    letMaker.setFactory(getFactory());
+    for(const auto& param : letElem->getChildren()) {  
+      // execute pushVariable() in letMaker::create()
+      RBALetStatement* const letExpr
+        {dynamic_cast<RBALetStatement*>(letMaker.create(param.get(), model))};
+      expr->addLetStatement(letExpr);
+      var_num += 1;
+    }
+  }
+
+  return var_num;
+}
+
+}
diff --git a/src/core/expression/RBAExpressionMaker.hpp b/src/core/expression/RBAExpressionMaker.hpp
new file mode 100644
index 0000000..282a093
--- /dev/null
+++ b/src/core/expression/RBAExpressionMaker.hpp
@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAExpreessionMaker.hpp
+/// @brief Abstract class definition header file for expression object generation
+
+#ifndef RBAEXPRESSIONMAKER_HPP
+#define RBAEXPRESSIONMAKER_HPP
+
+#include <cstdint>
+#include "RBAModelElementMaker.hpp"
+
+namespace rba
+{
+
+class RBAExpression;
+
+/// @brief Abstract class for expression object gcreation
+class DLL_EXPORT RBAExpressionMaker : public RBAModelElementMaker
+{
+public:
+  explicit RBAExpressionMaker(const std::string& label="");
+  RBAExpressionMaker(const RBAExpressionMaker&)=delete;
+  RBAExpressionMaker(const RBAExpressionMaker&&)=delete;
+  RBAExpressionMaker& operator=(const RBAExpressionMaker&)=delete;
+  RBAExpressionMaker& operator=(const RBAExpressionMaker&&)=delete;
+  virtual ~RBAExpressionMaker()=default;
+
+protected:
+  /// @brief To set ”Let" expression
+  /// @details Generate Let expression from jsonElem and register it in expr.
+  ///          Return the number of variables that have been registered
+  ///          (pushed) to ModelFactory, and pop them when the reference of 
+  ///          variables is completed in function that called this function.
+  /// @return the number of pushed variables
+  std::int32_t setLetStatement(RBAModelImpl* model,
+                               RBAExpression* expr,
+                               const RBAJsonElement* jsonElem);
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAExpressionType.hpp b/src/core/expression/RBAExpressionType.hpp
new file mode 100644
index 0000000..6b6fcd8
--- /dev/null
+++ b/src/core/expression/RBAExpressionType.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * Expression type enumeration class header file
+ */
+
+#ifndef RBAEXPRESSIONTYPE_HPP
+#define RBAEXPRESSIONTYPE_HPP
+
+#ifdef RBA_USE_LOG
+
+#include <cstdint>
+
+namespace rba
+{
+
+enum class RBAExpressionType : std::uint8_t
+{
+  VALUE =  0,
+  BOOLEAN,
+  AREA,
+  CONTENT,
+  SET_OF_AREA,
+  SET_OF_CONTENT,
+  LAMBDA,
+  SCENE,
+  ZONE,
+  SET_OF_ZONE,
+  SOUND,
+  SET_OF_SOUND,
+  ACTION,
+  SET_OF_ACTION,
+  PROPERTY,
+  EXTENSION,
+  CONTENT_STATE,
+  EXCEPTION
+};
+
+}
+
+#endif
+#endif
diff --git a/src/core/expression/RBAExpressionVisitor.hpp b/src/core/expression/RBAExpressionVisitor.hpp
new file mode 100644
index 0000000..e678b42
--- /dev/null
+++ b/src/core/expression/RBAExpressionVisitor.hpp
@@ -0,0 +1,168 @@
+/**
+ * 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.
+ */
+
+/**
+ * Expression visitor class header file
+ */
+
+#ifndef RBAEXPRESSIONVISITOR_HPP
+#define RBAEXPRESSIONVISITOR_HPP
+
+namespace rba {
+class RBAIsDisplayed;
+class RBADisplayingContent;
+class RBAAllocatedContent;
+class RBAIsHidden;
+class RBAContentValue;
+class RBAGetContentsList;
+class RBAIsActive;
+class RBAIsVisible;
+class RBAStateValue;
+class RBAHasBeenDisplayed;
+class RBAHasComeEarlierThan;
+class RBAHasComeLaterThan;
+class RBAGetAllocatables;
+class RBAIsOutputted;
+class RBAOutputtingSound;
+class RBAIsMuted;
+class RBAIsAttenuated;
+class RBAIsSounding;
+class RBAIsOn;
+class RBAGetProperty;
+class RBAAndOperator;
+class RBAOrOperator;
+class RBANotOperator;
+class RBAImpliesOperator;
+class RBAIsEqualToOperator;
+class RBAObjectCompare;
+class RBAIsGreaterThanOperator;
+class RBAIsGreaterThanEqualOperator;
+class RBAIsLowerThanOperator;
+class RBAIsLowerThanEqualOperator;
+class RBAForAllOperator;
+class RBAExistsOperator;
+class RBAAllInstanceOfArea;
+class RBAAllInstanceOfViewContent;
+class RBAAllInstanceOfZone;
+class RBAAllInstanceOfSoundContent;
+class RBAIfStatement;
+class RBALetStatement;
+class RBAPreviousModifier;
+class RBAActiveState;
+class RBAActiveContents;
+class RBAMaxOperator;
+class RBAMinOperator;
+class RBASelectOperator;
+class RBASizeOperator;
+class RBAObjectReference;
+class RBASetOfOperator;
+class RBAIsTypeOfOperator;
+
+class RBAExpressionVisitor {
+ public:
+  RBAExpressionVisitor()=default;
+  RBAExpressionVisitor(const RBAExpressionVisitor&)=delete;
+  RBAExpressionVisitor(const RBAExpressionVisitor&&)=delete;
+  RBAExpressionVisitor& operator=(const RBAExpressionVisitor&)=delete;
+  RBAExpressionVisitor& operator=(const RBAExpressionVisitor&&)=delete;
+  virtual ~RBAExpressionVisitor() = default;
+
+  // Refer to Area status
+  virtual void visit(RBAIsDisplayed& exp) = 0;
+  virtual void visit(RBADisplayingContent& exp) = 0;
+  virtual void visit(RBAAllocatedContent& exp) = 0;
+  virtual void visit(RBAIsHidden& exp) = 0;
+  virtual void visit(RBAContentValue& exp) = 0;
+  virtual void visit(RBAGetContentsList& exp) = 0;
+  virtual void visit(RBAActiveContents& exp) = 0;
+
+  // Refer to display content status
+  virtual void visit(RBAIsActive& exp) = 0;
+  virtual void visit(RBAIsVisible& exp) = 0;
+  virtual void visit(RBAStateValue& exp) = 0;
+  virtual void visit(RBAHasBeenDisplayed& exp) = 0;
+  virtual void visit(RBAHasComeEarlierThan& exp) = 0;
+  virtual void visit(RBAHasComeLaterThan& exp) = 0;
+  virtual void visit(RBAGetAllocatables& exp) = 0;
+  virtual void visit(RBAActiveState& exp) = 0;
+
+  // Refer to Zone status
+  virtual void visit(RBAIsOutputted& exp) = 0;
+  virtual void visit(RBAOutputtingSound& exp) = 0;
+  // allocatedContent　is common with Area
+  virtual void visit(RBAIsMuted& exp) = 0;
+  virtual void visit(RBAIsAttenuated& exp) = 0;
+  // contentValue is common with Area
+  // contentsList　is common with Area
+
+  // Refer to sound content status
+  // isActive is common with display content
+  virtual void visit(RBAIsSounding& exp) = 0;
+  // stateValue is common with display content
+  // hasComeEarlierThan is common with display content
+  // hasComeLaterThan is common with display content
+  // allocatables is common with display content
+  // activeState is common with display content
+
+  // Refer to Scene
+  virtual void visit(RBAIsOn& exp) = 0;
+  virtual void visit(RBAGetProperty& exp) = 0;
+
+  virtual void visit(RBAIsTypeOfOperator& exp) = 0;
+
+  // Operators
+  virtual void visit(RBAAndOperator& exp) = 0;
+  virtual void visit(RBAOrOperator& exp) = 0;
+  virtual void visit(RBANotOperator& exp) = 0;
+  virtual void visit(RBAImpliesOperator& exp) = 0;
+  virtual void visit(RBAIsEqualToOperator& exp) = 0;
+  virtual void visit(RBAObjectCompare& exp) = 0;
+  virtual void visit(RBAIsGreaterThanOperator& exp) = 0;
+  virtual void visit(RBAIsGreaterThanEqualOperator& exp) = 0;
+  virtual void visit(RBAIsLowerThanOperator& exp) = 0;
+  virtual void visit(RBAIsLowerThanEqualOperator& exp) = 0;
+
+  // Quantification symbol
+  virtual void visit(RBAForAllOperator& exp) = 0;
+  virtual void visit(RBAExistsOperator& exp) = 0;
+
+  // Built-in definition expression
+  virtual void visit(RBAAllInstanceOfArea& exp) = 0;
+  virtual void visit(RBAAllInstanceOfViewContent& exp) = 0;
+  virtual void visit(RBAAllInstanceOfZone& exp) = 0;
+  virtual void visit(RBAAllInstanceOfSoundContent& exp) = 0;
+
+  // Syntax
+  virtual void visit(RBAIfStatement& exp) = 0;
+  virtual void visit(RBALetStatement& exp) = 0;
+
+  // Modifier
+  virtual void visit(RBAPreviousModifier& exp) = 0;
+
+  // Set operator
+  virtual void visit(RBAMaxOperator& exp) = 0;
+  virtual void visit(RBAMinOperator& exp) = 0;
+  virtual void visit(RBASelectOperator& exp) = 0;
+  virtual void visit(RBASizeOperator& exp) = 0;
+
+  // Object references
+  virtual void visit(RBAObjectReference& exp) = 0;
+  virtual void visit(RBASetOfOperator& exp) = 0;
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAForAllOperator.cpp b/src/core/expression/RBAForAllOperator.cpp
new file mode 100644
index 0000000..93a2894
--- /dev/null
+++ b/src/core/expression/RBAForAllOperator.cpp
@@ -0,0 +1,173 @@
+/**
+ * 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.
+ */
+
+/**
+ * ForAll operator class
+ */
+
+#include "RBAForAllOperator.hpp"
+
+#include "RBAAllocatable.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALambdaExpression.hpp"
+#include "RBALogManager.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAForAllOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAForAllOperator::getModelElementType() const
+{
+  return RBAModelElementType::ForAllOperator;
+}
+
+bool
+RBAForAllOperator::executeCore(RBAConstraintInfo* info,
+				   RBAArbitrator * arb) const
+{
+  const RBAExpression* const setObj {getLhsOperand()};
+  RBALambdaExpression* const lambda {getLambda()};
+
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+
+  // get Rule object and loop
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+
+  std::vector<const RBARuleObject*> objs;
+  const RBARuleObject* const ruleObj {setObj->getReferenceObject(leftInfo, arb)};
+  const RBARuleObject* objset {nullptr};
+  if (ruleObj != nullptr) {
+    objset = ruleObj->getRawObject();
+  }
+
+  if(leftInfo->isExceptionBeforeArbitrate() || (objset == nullptr)) {
+    // Remove itself from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+
+    info->setExceptionBeforeArbitrate(true);
+    return false;
+  }
+  if (dynamic_cast<const RBAAllocatableSet*>(objset) != nullptr) {
+    objs.clear();
+    for(const RBAAllocatable* alloc
+	  : dynamic_cast<const RBAAllocatableSet*>(objset)->getLeafAllocatable()) {
+      objs.push_back(alloc);
+    }
+  }
+  else {
+    objs.clear();
+    for(const auto& cont : dynamic_cast<const RBAContentSet*>(objset)->getLeafContent() ){
+      objs.push_back(cont);
+    }
+  }
+
+  bool isTrue {true};
+  std::uint32_t i {0U};
+  for(const RBARuleObject* const obj : objs) {
+    // Add count to the constraint hierarchy for coverage
+    LOG_addHierarchy("#" + std::to_string(i));
+
+    RBAConstraintInfo* const childInfo {info->getChild(i)};
+    lambda->setRuleObj(obj);
+
+    const bool res {lambda->execute(childInfo, arb)};
+
+    // Remove count from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+
+    if(childInfo->isExceptionBeforeArbitrate()) {
+      info->setExceptionBeforeArbitrate(true);
+    } else {
+      isTrue = (isTrue && res);
+    }
+    i++;
+  }
+
+  if (isTrue == false) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+    // Remove count from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    info->setExceptionBeforeArbitrate(false);
+    return false;
+  } else if (info->isExceptionBeforeArbitrate()) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+    // Remove count from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    return false;
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+    // Remove count from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    return true;
+  }
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAForAllOperator::getSymbol() const
+{
+  return "For All";
+}
+
+const std::string
+RBAForAllOperator::getExpressionText() const
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  return getSymbol() + " "
+    + exprLhs->getExpressionText() + " "
+    + getLambda()->getExpressionText();
+}
+
+const std::string
+RBAForAllOperator::getCoverageExpressionText() const
+{
+  getLambda()->clearRuleObj();
+  RBAExpression* exprLhs = getLhsOperand();
+  return getSymbol() + " "
+    + exprLhs->getCoverageExpressionText() + " "
+    + getLambda()->getCoverageExpressionText();
+}
+
+RBAExpressionType
+RBAForAllOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAForAllOperator.hpp b/src/core/expression/RBAForAllOperator.hpp
new file mode 100644
index 0000000..7c0c7cc
--- /dev/null
+++ b/src/core/expression/RBAForAllOperator.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * ForAll operator class header file
+ */
+
+#ifndef RBAFORALLOPERATOR_HPP
+#define RBAFORALLOPERATOR_HPP
+
+#include "RBALambdaContext.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAForAllOperator : public RBALambdaContext
+{
+public:
+  RBAForAllOperator()=default;
+  RBAForAllOperator(const RBAForAllOperator&)=delete;
+  RBAForAllOperator(const RBAForAllOperator&&)=delete;
+  RBAForAllOperator& operator=(const RBAForAllOperator&)=delete;
+  RBAForAllOperator& operator=(const RBAForAllOperator&&)=delete;
+  virtual ~RBAForAllOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAForAllOperatorMaker.cpp b/src/core/expression/RBAForAllOperatorMaker.cpp
new file mode 100644
index 0000000..eb1068d
--- /dev/null
+++ b/src/core/expression/RBAForAllOperatorMaker.cpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAForAllOperatorMaker.cpp
+/// @brief ForAllOperator　object generation class
+
+#include "RBAForAllOperatorMaker.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAForAllOperator.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBAForAllOperatorMaker::RBAForAllOperatorMaker()
+  : RBALambdaContextMaker{"ForAllOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAForAllOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAForAllOperator>();
+}
+
+RBAModelElement*
+RBAForAllOperatorMaker::setProperty(RBAModelElement* element,
+                                    const RBAJsonElement* jsonElem,
+                                    RBAModelImpl* model,
+                                    RBAModelElement* owner)
+{
+  static_cast<void>(
+      RBALambdaContextMaker::setProperty(element, jsonElem, model, owner));
+
+  return element;
+}
+
+std::unique_ptr<RBALambdaContext>
+RBAForAllOperatorMaker::createLambdaContext()
+{
+  return std::make_unique<RBAForAllOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAForAllOperatorMaker.hpp b/src/core/expression/RBAForAllOperatorMaker.hpp
new file mode 100644
index 0000000..9c5de92
--- /dev/null
+++ b/src/core/expression/RBAForAllOperatorMaker.hpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAForAllOperatorMaker.hpp
+/// @brief ForAllOperator　object generation class header
+
+#ifndef RBAFORALLOPERATORMAKER_HPP
+#define RBAFORALLOPERATORMAKER_HPP
+
+#include "RBALambdaContextMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ForAllOperator　object generation class
+class RBAForAllOperatorMaker : public RBALambdaContextMaker
+{
+public:
+  RBAForAllOperatorMaker();
+  RBAForAllOperatorMaker(const RBAForAllOperatorMaker&)=delete;
+  RBAForAllOperatorMaker(const RBAForAllOperatorMaker&&)=delete;
+  RBAForAllOperatorMaker& operator=(const RBAForAllOperatorMaker&)=delete;
+  RBAForAllOperatorMaker& operator=(const RBAForAllOperatorMaker&&)=delete;
+  virtual ~RBAForAllOperatorMaker()=default;
+
+protected:
+  /// @brief  generate an empty instance
+  /// @details generate an empty instance of unique_ptr in a derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model M\model to store the generated object
+  /// @param[in,out] owner parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner=nullptr) override;
+
+  /// @brief generate an empty object of LambdaContext
+  /// @details generate an empty object of unique_ptr in a derived class
+  /// @return unique_ptr for LambdaContext object
+  std::unique_ptr<RBALambdaContext> createLambdaContext() override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAGetAllocatables.cpp b/src/core/expression/RBAGetAllocatables.cpp
new file mode 100644
index 0000000..8494a01
--- /dev/null
+++ b/src/core/expression/RBAGetAllocatables.cpp
@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+ /**
+ * GetAllocatables class definition file
+ */
+
+#include "RBAGetAllocatables.hpp"                                                       
+
+#include "RBAContent.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAGetAllocatables::accept(RBAExpressionVisitor& visitor)
+{
+  // This path is not used, because RBASceneAllocatableCollector, 
+  // the only existing visitor as of now, does not accept content.
+  // But, keep this because another visitor may accept, in the future.
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAGetAllocatables::getModelElementType() const
+{
+  return RBAModelElementType::GetAllocatables;
+}
+
+const RBARuleObject*
+RBAGetAllocatables::getReferenceObjectCore(RBAConstraintInfo* info,
+                                           RBAArbitrator* arb) const
+{
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+
+  const RBARuleObject* const ruleObj
+    {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+  const RBAContent* content {nullptr};
+  if (ruleObj != nullptr) {
+    content = dynamic_cast<const RBAContent*>(ruleObj->getRawObject());
+  }
+
+  if (content == nullptr) {
+    if (leftInfo->isExceptionBeforeArbitrate()) {
+      info->setExceptionBeforeArbitrate(true);
+    }
+    return nullptr;
+  }
+
+  return content->getAllocatableSet();
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAGetAllocatables::getSymbol() const
+{
+  return ".allocatables()";
+}
+
+const std::string
+RBAGetAllocatables::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+                                                    
+// At the moment, the arbitration FW cannot write a constraint expression 
+// to call createHierarchy() of GetAllocatables, 
+// so it does not go through this path. 
+// But, defined this for maintainability (especially expandability.
+void
+RBAGetAllocatables::createHierarchy()
+{
+  // No operation because　it does not affect structure.
+}
+
+#endif
+
+}
diff --git a/src/core/expression/RBAGetAllocatables.hpp b/src/core/expression/RBAGetAllocatables.hpp
new file mode 100644
index 0000000..d1c7167
--- /dev/null
+++ b/src/core/expression/RBAGetAllocatables.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * GetAllocatables class header file
+ */
+
+#ifndef RBAGETALLOCATABLES_HPP
+#define RBAGETALLOCATABLES_HPP
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAGetAllocatables : public RBAContentOperator
+{
+public:
+  RBAGetAllocatables()=default;
+  RBAGetAllocatables(const RBAGetAllocatables&)=delete;
+  RBAGetAllocatables(const RBAGetAllocatables&&)=delete;
+  RBAGetAllocatables& operator=(const RBAGetAllocatables&)=delete;
+  RBAGetAllocatables& operator=(const RBAGetAllocatables&&)=delete;
+  virtual ~RBAGetAllocatables()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  void createHierarchy() override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAGetAllocatablesMaker.cpp b/src/core/expression/RBAGetAllocatablesMaker.cpp
new file mode 100644
index 0000000..aac81a2
--- /dev/null
+++ b/src/core/expression/RBAGetAllocatablesMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAGetAllocatablesMaker.cpp
+/// @brief GetAllocatables object generation class definition
+
+#include "RBAGetAllocatablesMaker.hpp"
+#include "RBAGetAllocatables.hpp"
+
+namespace rba
+{
+
+RBAGetAllocatablesMaker::RBAGetAllocatablesMaker()
+  : RBAOperatorMaker{"GetAllocatables"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAGetAllocatablesMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAGetAllocatables>();
+}
+
+}
diff --git a/src/core/expression/RBAGetAllocatablesMaker.hpp b/src/core/expression/RBAGetAllocatablesMaker.hpp
new file mode 100644
index 0000000..722845f
--- /dev/null
+++ b/src/core/expression/RBAGetAllocatablesMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAGetAllocatablesMaker.hpp
+/// @brief GetAllocatables object generation class header file
+
+#ifndef RBAGETALLOCATABLESMAKER_HPP
+#define RBAGETALLOCATABLESMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief GetAllocatables object gneration class
+class RBAGetAllocatablesMaker : public RBAOperatorMaker
+{
+public:
+  RBAGetAllocatablesMaker();
+  RBAGetAllocatablesMaker(const RBAGetAllocatablesMaker&)=delete;
+  RBAGetAllocatablesMaker(const RBAGetAllocatablesMaker&&)=delete;
+  RBAGetAllocatablesMaker& operator=(const RBAGetAllocatablesMaker&)=delete;
+  RBAGetAllocatablesMaker& operator=(const RBAGetAllocatablesMaker&&)=delete;
+  virtual ~RBAGetAllocatablesMaker()=default;
+
+protected:
+  /// @brief Generate an empty instance
+  /// @details Generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAGetContentsList.cpp b/src/core/expression/RBAGetContentsList.cpp
new file mode 100644
index 0000000..5f14b33
--- /dev/null
+++ b/src/core/expression/RBAGetContentsList.cpp
@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */
+
+/**
+ * GetContentsList class definition file
+ */
+
+#include "RBAGetContentsList.hpp"
+
+#include "RBAAllocatable.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void RBAGetContentsList::accept(RBAExpressionVisitor& visitor)
+{
+  // This path is not used, because RBASceneAllocatableCollector, 
+  // the only existing visitor as of now, does not accept content.
+  // But, keep this because another visitor may accept, in the future.
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAGetContentsList::getModelElementType() const
+{
+  return RBAModelElementType::GetContentsList;
+}
+
+const RBARuleObject*
+RBAGetContentsList::getReferenceObjectCore(RBAConstraintInfo* info,
+                                           RBAArbitrator* arb) const
+{
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+
+  const RBARuleObject* const ruleObj
+    {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+  const RBAAllocatable* allocatable {nullptr};
+  if (ruleObj != nullptr) {
+    allocatable = dynamic_cast<const RBAAllocatable*>(ruleObj->getRawObject());
+  }
+  // Indicates whether the content referenced by this constraint expression 
+  // is the result of the previous arbitration result.
+
+  if (leftInfo->isExceptionBeforeArbitrate() || (allocatable == nullptr)) {
+    // As of now, this path is not used due to the following reasons.
+    //  - The expression below GetContentsList is before arbitration
+    //  - Constraint expression that returns null as allocatable 
+    //    can not be described(specified) 
+    // But, defined this for maintainability (especially expandability).
+    info->setExceptionBeforeArbitrate(true);
+    return nullptr;
+  }
+
+  return allocatable->getContentSet();
+}
+
+#ifdef RBA_USE_LOG
+// At the moment, the arbitration FW cannot write a constraint expression 
+// to call createHierarchy() of GetContentsList, 
+// so it does not go through this path. 
+// But, defined this for maintainability (especially expandability.
+void
+RBAGetContentsList::createHierarchy()
+{
+  // No operation because　it does not affect structure.
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAGetContentsList.hpp b/src/core/expression/RBAGetContentsList.hpp
new file mode 100644
index 0000000..240a50c
--- /dev/null
+++ b/src/core/expression/RBAGetContentsList.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/**
+ * GetContentsList class header file
+ */
+
+#ifndef RBAGETCONTENTSLIST_HPP
+#define RBAGETCONTENTSLIST_HPP
+
+#include "RBAAllocatableOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAGetContentsList : public RBAAllocatableOperator
+{
+public:
+  RBAGetContentsList()=default;
+  RBAGetContentsList(const RBAGetContentsList&)=delete;
+  RBAGetContentsList(const RBAGetContentsList&&)=delete;
+  RBAGetContentsList& operator=(const RBAGetContentsList&)=delete;
+  RBAGetContentsList& operator=(const RBAGetContentsList&&)=delete;
+  virtual ~RBAGetContentsList()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  void createHierarchy() override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAGetContentsListMaker.cpp b/src/core/expression/RBAGetContentsListMaker.cpp
new file mode 100644
index 0000000..2081e2d
--- /dev/null
+++ b/src/core/expression/RBAGetContentsListMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAGetContentsListMaker.cpp
+/// @brief GetContentsList object generation class definition file
+
+#include "RBAGetContentsListMaker.hpp"
+#include "RBAGetContentsList.hpp"
+
+namespace rba
+{
+
+RBAGetContentsListMaker::RBAGetContentsListMaker()
+  : RBAOperatorMaker{"GetContentsList"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAGetContentsListMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAGetContentsList>();
+}
+
+}
diff --git a/src/core/expression/RBAGetContentsListMaker.hpp b/src/core/expression/RBAGetContentsListMaker.hpp
new file mode 100644
index 0000000..c703f68
--- /dev/null
+++ b/src/core/expression/RBAGetContentsListMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAGetContentsListMaker.hpp
+/// @brief GetContentsList object generation class header file
+
+#ifndef RBAGETCONTENTSLISTMAKER_HPP
+#define RBAGETCONTENTSLISTMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief GetContentsList object generation class
+class RBAGetContentsListMaker : public RBAOperatorMaker
+{
+public:
+  RBAGetContentsListMaker();
+  RBAGetContentsListMaker(const RBAGetContentsListMaker&)=delete;
+  RBAGetContentsListMaker(const RBAGetContentsListMaker&&)=delete;
+  RBAGetContentsListMaker& operator=(const RBAGetContentsListMaker&)=delete;
+  RBAGetContentsListMaker& operator=(const RBAGetContentsListMaker&&)=delete;
+  virtual ~RBAGetContentsListMaker()=default;
+
+protected:
+  /// @brief Generate an empty instance
+  /// @details Generate an empty class of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAGetProperty.cpp b/src/core/expression/RBAGetProperty.cpp
new file mode 100644
index 0000000..3a774d8
--- /dev/null
+++ b/src/core/expression/RBAGetProperty.cpp
@@ -0,0 +1,101 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAGetProperty class defintino file
+ */
+
+#include "RBAGetProperty.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBALogManager.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAAbstractProperty.hpp"
+
+namespace rba
+{
+
+void
+RBAGetProperty::accept(RBAExpressionVisitor& visitor)
+{
+  // This path is not used, because RBASceneAllocatableCollector, 
+  // the only existing visitor as of now, does not accept content.
+  // But, keep this because another visitor may accept, in the future.
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAGetProperty::getModelElementType() const
+{
+  return RBAModelElementType::GetProperty;
+}
+
+std::int32_t
+RBAGetProperty::getValueCore(RBAConstraintInfo* info,
+				 RBAArbitrator* arb) const
+{
+  std::int32_t value{0};
+  const RBAAbstractProperty* prop{nullptr};
+  const RBARuleObject* const ruleObj {getLhsOperand()->getReferenceObject(info, arb)};
+  if(ruleObj->isPrevious()) {
+    prop = dynamic_cast<const RBAAbstractProperty*>(ruleObj->getRawObject());
+    value = arb->getResult()->getPreSceneProperty(prop);
+  }
+  else {
+    prop = dynamic_cast<const RBAAbstractProperty*>(ruleObj);
+    value = arb->getResult()->getSceneProperty(prop);
+  }
+  LOG_arbitrateConstraintLogicLogLine("      "
+				      + getPreMsg(ruleObj->isPrevious())
+				      + "Property["
+				      + prop->getScene()->getElementName()
+				      + "::"
+				      + prop->getElementName()
+				      + "] get["
+				      + std::to_string(value)
+				      + "]");
+  return value;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAGetProperty::getSymbol() const
+{
+  return ".get()";
+}
+
+const std::string
+RBAGetProperty::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+
+const std::string
+RBAGetProperty::getCoverageExpressionText() const
+{
+  return getExpressionText();
+}
+
+RBAExpressionType
+RBAGetProperty::getUnderlyingType() const
+{
+  return RBAExpressionType::VALUE;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAGetProperty.hpp b/src/core/expression/RBAGetProperty.hpp
new file mode 100644
index 0000000..eff3852
--- /dev/null
+++ b/src/core/expression/RBAGetProperty.hpp
@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAGetProperty Class
+ */
+
+#ifndef RBAGETPROPERTY_HPP
+#define RBAGETPROPERTY_HPP
+
+#include "RBAPropertyOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAGetProperty : public RBAPropertyOperator
+{
+public:
+  RBAGetProperty()=default;
+  RBAGetProperty(const RBAGetProperty&)=delete;
+  RBAGetProperty(const RBAGetProperty&&)=delete;
+  RBAGetProperty& operator=(const RBAGetProperty&)=delete;
+  RBAGetProperty& operator=(const RBAGetProperty&&)=delete;
+  virtual ~RBAGetProperty()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info,
+                                    RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAGetPropertyMaker.cpp b/src/core/expression/RBAGetPropertyMaker.cpp
new file mode 100644
index 0000000..f2588ad
--- /dev/null
+++ b/src/core/expression/RBAGetPropertyMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAGetPropertyMaker.cpp
+/// @brief GetProperty object generation class defintion file
+
+#include "RBAGetPropertyMaker.hpp"
+#include "RBAGetProperty.hpp"
+
+namespace rba
+{
+
+RBAGetPropertyMaker::RBAGetPropertyMaker()
+  : RBAOperatorMaker{"GetProperty"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAGetPropertyMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAGetProperty>();
+}
+
+}
diff --git a/src/core/expression/RBAGetPropertyMaker.hpp b/src/core/expression/RBAGetPropertyMaker.hpp
new file mode 100644
index 0000000..db20ce1
--- /dev/null
+++ b/src/core/expression/RBAGetPropertyMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAGetPropertyMaker.hpp
+/// @brief GetProperty object generation class heeader file
+
+#ifndef RBAGETPROPERTYMAKER_HPP
+#define RBAGETPROPERTYMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief GetProperty object generation class
+class RBAGetPropertyMaker : public RBAOperatorMaker
+{
+public:
+  RBAGetPropertyMaker();
+  RBAGetPropertyMaker(const RBAGetPropertyMaker&)=delete;
+  RBAGetPropertyMaker(const RBAGetPropertyMaker&&)=delete;
+  RBAGetPropertyMaker& operator=(const RBAGetPropertyMaker&)=delete;
+  RBAGetPropertyMaker& operator=(const RBAGetPropertyMaker&&)=delete;
+  virtual ~RBAGetPropertyMaker()=default;
+
+protected:
+  /// @brief Generate an empty instance
+  /// @details Generate an empty class of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAHasBeenDisplayed.cpp b/src/core/expression/RBAHasBeenDisplayed.cpp
new file mode 100644
index 0000000..72c1d40
--- /dev/null
+++ b/src/core/expression/RBAHasBeenDisplayed.cpp
@@ -0,0 +1,102 @@
+/**
+ * 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.
+ */
+
+/**
+ * .hasBeenDisplayed() definition
+ **/
+
+#include "RBAHasBeenDisplayed.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAContent.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+
+namespace rba
+{
+
+void RBAHasBeenDisplayed::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType RBAHasBeenDisplayed::getModelElementType() const
+{
+  return RBAModelElementType::HasBeenDisplayed;
+}
+
+bool RBAHasBeenDisplayed::executeCore(RBAConstraintInfo* info,
+                                      RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const ruleObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                     arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (ruleObj != nullptr) {
+    const RBAContent* const c {
+        dynamic_cast<const RBAContent*>(ruleObj->getRawObject())};
+    if (!ruleObj->isPrevious()) {
+      isPassed = arb->getResult()->hasBeenDisplayed(c);
+    } else {
+      isPassed = arb->getResult()->hasBeenPreDisplayed(c);
+    }
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  RBAExecuteResult r;
+  std::string cname;
+  std::string resultStr;
+  if (ruleObj != nullptr) {
+    cname = ruleObj->getRawObject()->getElementName();
+  } else {
+    cname = "NULL";
+  }
+  if (info->isExceptionBeforeArbitrate()) {
+    resultStr = " before arbitrate skip";
+    r = RBAExecuteResult::SKIP;
+  } else if (isPassed) {
+    resultStr = " true";
+    r = RBAExecuteResult::TRUE;
+  } else {
+    resultStr = " false";
+    r = RBAExecuteResult::FALSE;
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      Content[" + cname + "]" + getSymbol() + resultStr);
+  LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(), r);
+#endif
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+// Log
+#ifdef RBA_USE_LOG
+const std::string RBAHasBeenDisplayed::getSymbol() const
+{
+  return ".hasBeenDisplayed()";
+}
+RBAExpressionType RBAHasBeenDisplayed::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+} /* namespace rba */
diff --git a/src/core/expression/RBAHasBeenDisplayed.hpp b/src/core/expression/RBAHasBeenDisplayed.hpp
new file mode 100644
index 0000000..3e3ebde
--- /dev/null
+++ b/src/core/expression/RBAHasBeenDisplayed.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+//
+// .hasBeenDisplayed() header file
+//
+
+#ifndef RBAHASBEENDISPLAYED_HPP
+#define RBAHASBEENDISPLAYED_HPP
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAHasBeenDisplayed : public RBAContentOperator
+{
+ public:
+  RBAHasBeenDisplayed()=default;
+  RBAHasBeenDisplayed(const RBAHasBeenDisplayed&)=delete;
+  RBAHasBeenDisplayed(const RBAHasBeenDisplayed&&)=delete;
+  RBAHasBeenDisplayed& operator=(const RBAHasBeenDisplayed&)=delete;
+  RBAHasBeenDisplayed& operator=(const RBAHasBeenDisplayed&&)=delete;
+  virtual ~RBAHasBeenDisplayed()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+};
+
+} /* namespace rba */
+
+#endif /* RBAHASBEENDISPLAYED_HPP */
diff --git a/src/core/expression/RBAHasBeenDisplayedMaker.cpp b/src/core/expression/RBAHasBeenDisplayedMaker.cpp
new file mode 100644
index 0000000..36aeecc
--- /dev/null
+++ b/src/core/expression/RBAHasBeenDisplayedMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAHasBeenDisplayedMaker.cpp
+/// @brief HasBeenDisplayed object generation class defintion file
+
+#include "RBAHasBeenDisplayedMaker.hpp"
+#include "RBAHasBeenDisplayed.hpp"
+
+namespace rba
+{
+
+RBAHasBeenDisplayedMaker::RBAHasBeenDisplayedMaker()
+  : RBAOperatorMaker{"HasBeenDisplayed"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAHasBeenDisplayedMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAHasBeenDisplayed>();
+}
+
+}
diff --git a/src/core/expression/RBAHasBeenDisplayedMaker.hpp b/src/core/expression/RBAHasBeenDisplayedMaker.hpp
new file mode 100644
index 0000000..5e9bc10
--- /dev/null
+++ b/src/core/expression/RBAHasBeenDisplayedMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAHasBeenDisplayedMaker.hpp
+/// @brief HasBeenDisplayed object generation class header file
+
+#ifndef RBAHASBEENDISPLAYEDMAKER_HPP
+#define RBAHASBEENDISPLAYEDMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief HasBeenDisplayed object generation class
+class RBAHasBeenDisplayedMaker : public RBAOperatorMaker
+{
+public:
+  RBAHasBeenDisplayedMaker();
+  RBAHasBeenDisplayedMaker(const RBAHasBeenDisplayedMaker&)=delete;
+  RBAHasBeenDisplayedMaker(const RBAHasBeenDisplayedMaker&&)=delete;
+  RBAHasBeenDisplayedMaker& operator=(const RBAHasBeenDisplayedMaker&)=delete;
+  RBAHasBeenDisplayedMaker& operator=(const RBAHasBeenDisplayedMaker&&)=delete;
+  virtual ~RBAHasBeenDisplayedMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instancce of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAHasComeEarlierThan.cpp b/src/core/expression/RBAHasComeEarlierThan.cpp
new file mode 100644
index 0000000..4b5482a
--- /dev/null
+++ b/src/core/expression/RBAHasComeEarlierThan.cpp
@@ -0,0 +1,151 @@
+/**
+ * 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.
+ */
+
+/**
+ * HasComeEarlierThan class
+ */
+
+#include "RBAHasComeEarlierThan.hpp"
+#include "RBAContent.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+RBAModelElementType
+RBAHasComeEarlierThan::getModelElementType() const
+{
+  return RBAModelElementType::HasComeEarlier;
+}
+
+void RBAHasComeEarlierThan::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+bool
+RBAHasComeEarlierThan::executeCore(RBAConstraintInfo* info,
+				       RBAArbitrator* arb) const
+{
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+
+  bool isResult {false};
+  // Get content in left side　of the expression
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* ruleObj {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+  const RBAContent* contentLhs {nullptr};
+  if(ruleObj != nullptr) {
+    contentLhs = dynamic_cast<const RBAContent*>(ruleObj->getRawObject());
+  }
+
+  // Get content in right hand side　of the expression
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  ruleObj = getRhsOperand()->getReferenceObject(rightInfo, arb);
+  const RBAContent* contentRhs {nullptr};
+  if(ruleObj != nullptr) {
+    contentRhs = dynamic_cast<const RBAContent*>(ruleObj->getRawObject());
+  }
+
+  if((contentLhs == nullptr) || (contentRhs == nullptr)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (!((arb->getResult()->isActive(contentLhs))
+        && (arb->getResult()->isActive(contentRhs)))) {
+      info->setExceptionBeforeArbitrate(true);
+    }
+    else if(contentLhs == contentRhs) {
+      isResult = false;
+    }
+    else {
+      isResult = !arb->getResult()->isLater(contentLhs, contentRhs);
+    }
+  }
+#ifdef RBA_USE_LOG
+  std::string lhsName;
+  std::string rhsName;
+  std::string resultText;
+  if(contentLhs == nullptr) {
+    lhsName = "NULL";
+  } else {
+    lhsName = contentLhs->getElementName();
+  }
+  if (contentRhs == nullptr) {
+    rhsName = "NULL";
+  } else {
+    rhsName = contentRhs->getElementName();
+  }
+  if (info->isExceptionBeforeArbitrate() == true ) {
+    resultText = "is before arbitrate skip";
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+					RBAExecuteResult::SKIP);
+  } else {
+    resultText = RBALogManager::boolToString(isResult);
+    if(isResult) {
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+					  RBAExecuteResult::TRUE);
+    }
+    else {
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+					  RBAExecuteResult::FALSE);
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      Content[" + lhsName + "] has come earlier than Content[" + rhsName + "] " + resultText);
+#endif
+  // Remove itself from constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isResult;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAHasComeEarlierThan::getSymbol() const
+{
+  return ".hasComeEarlierThan";
+}
+
+const std::string
+RBAHasComeEarlierThan::getExpressionText() const
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  RBAExpression* exprRhs = getRhsOperand();
+  return exprLhs->getExpressionText() + getSymbol()
+    + "(" + exprRhs->getExpressionText() + ")";
+}
+
+const std::string
+RBAHasComeEarlierThan::getCoverageExpressionText() const
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  RBAExpression* exprRhs = getRhsOperand();
+  return exprLhs->getCoverageExpressionText() + getSymbol()
+    + "(" + exprRhs->getCoverageExpressionText() + ")";
+}
+
+RBAExpressionType
+RBAHasComeEarlierThan::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAHasComeEarlierThan.hpp b/src/core/expression/RBAHasComeEarlierThan.hpp
new file mode 100644
index 0000000..fd39782
--- /dev/null
+++ b/src/core/expression/RBAHasComeEarlierThan.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * HasComeEarlierThan class header file
+ */
+
+#ifndef RBAHASCOMEEARLIERTHAN_HPP
+#define RBAHASCOMEEARLIERTHAN_HPP
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAHasComeEarlierThan : public RBAContentOperator
+{
+public:
+  RBAHasComeEarlierThan()=default;
+  RBAHasComeEarlierThan(const RBAHasComeEarlierThan&)=delete;
+  RBAHasComeEarlierThan(const RBAHasComeEarlierThan&&)=delete;
+  RBAHasComeEarlierThan& operator=(const RBAHasComeEarlierThan&)=delete;
+  RBAHasComeEarlierThan& operator=(const RBAHasComeEarlierThan&&)=delete;
+  virtual ~RBAHasComeEarlierThan()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAHasComeEarlierThanMaker.cpp b/src/core/expression/RBAHasComeEarlierThanMaker.cpp
new file mode 100644
index 0000000..fb5eb08
--- /dev/null
+++ b/src/core/expression/RBAHasComeEarlierThanMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAHasComeEarlierThanMaker.cpp
+/// @brief HasComeEarlierThan object generation class definition file
+
+#include "RBAHasComeEarlierThanMaker.hpp"
+#include "RBAHasComeEarlierThan.hpp"
+
+namespace rba
+{
+
+RBAHasComeEarlierThanMaker::RBAHasComeEarlierThanMaker()
+  : RBAOperatorMaker{"HasComeEarlierThan"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAHasComeEarlierThanMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAHasComeEarlierThan>();
+}
+
+}
diff --git a/src/core/expression/RBAHasComeEarlierThanMaker.hpp b/src/core/expression/RBAHasComeEarlierThanMaker.hpp
new file mode 100644
index 0000000..256a4ea
--- /dev/null
+++ b/src/core/expression/RBAHasComeEarlierThanMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAHasComeEarlierThanMaker.hpp
+/// @brief HasComeEarlierThan object generation class header
+
+#ifndef RBAHASCOMEEARLIERTHANMAKER_HPP
+#define RBAHASCOMEEARLIERTHANMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief HasComeEarlierThan object generation class
+class RBAHasComeEarlierThanMaker : public RBAOperatorMaker
+{
+public:
+  RBAHasComeEarlierThanMaker();
+  RBAHasComeEarlierThanMaker(const RBAHasComeEarlierThanMaker&)=delete;
+  RBAHasComeEarlierThanMaker(const RBAHasComeEarlierThanMaker&&)=delete;
+  RBAHasComeEarlierThanMaker& operator=(const RBAHasComeEarlierThanMaker&)=delete;
+  RBAHasComeEarlierThanMaker& operator=(const RBAHasComeEarlierThanMaker&&)=delete;
+  virtual ~RBAHasComeEarlierThanMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAHasComeLaterThan.cpp b/src/core/expression/RBAHasComeLaterThan.cpp
new file mode 100644
index 0000000..341d164
--- /dev/null
+++ b/src/core/expression/RBAHasComeLaterThan.cpp
@@ -0,0 +1,153 @@
+/**
+ * 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.
+ */
+
+/**
+ * HasComeLaterThan class
+ */
+
+#include "RBAHasComeLaterThan.hpp"
+
+#include "RBAContent.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void RBAHasComeLaterThan::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAHasComeLaterThan::getModelElementType() const
+{
+  return RBAModelElementType::HasComeLater;
+}
+
+bool
+RBAHasComeLaterThan::executeCore(RBAConstraintInfo* info,
+				     RBAArbitrator* arb) const
+{
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+
+  bool isResult {false};
+  // pop the Content of left hand side expresion
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* ruleObj {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+  const RBAContent* contentLhs {nullptr};
+  if(ruleObj != nullptr) {
+    contentLhs = dynamic_cast<const RBAContent*>(ruleObj->getRawObject());
+  }
+
+  // pop the Content of left hand side expresion
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  ruleObj = getRhsOperand()->getReferenceObject(rightInfo, arb);
+  const RBAContent* contentRhs {nullptr};
+  if(ruleObj != nullptr) {
+    contentRhs = dynamic_cast<const RBAContent*>(ruleObj->getRawObject());
+  }
+
+  if((contentLhs == nullptr) || (contentRhs == nullptr)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (!((arb->getResult()->isActive(contentLhs))
+        && (arb->getResult()->isActive(contentRhs)))) {
+      info->setExceptionBeforeArbitrate(true);
+    }
+    else if(contentLhs == contentRhs) {
+      isResult = false;
+    }
+    else {
+      isResult = arb->getResult()->isLater(contentLhs, contentRhs);
+    }
+  }
+#ifdef RBA_USE_LOG
+  std::string lhsName;
+  std::string rhsName;
+  std::string resultText;
+  if(contentLhs == nullptr) {
+    lhsName = "NULL";
+  } else {
+    lhsName = contentLhs->getElementName();
+  }
+  if (contentRhs == nullptr) {
+    rhsName = "NULL";
+  } else {
+    rhsName = contentRhs->getElementName();
+  }
+  if (info->isExceptionBeforeArbitrate() == true ) {
+    resultText = "is before arbitrate skip";
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+					RBAExecuteResult::SKIP);
+  } else {
+    resultText = RBALogManager::boolToString(isResult);
+    if(isResult) {
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+					  RBAExecuteResult::TRUE);
+    }
+    else {
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+					  RBAExecuteResult::FALSE);
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      Content[" + lhsName + "] has come later than Content[" + rhsName + "] " + resultText);
+#endif
+  // Remove itself from the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  return isResult;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAHasComeLaterThan::getSymbol() const
+{
+  return ".hasComeLaterThan";
+}
+
+const std::string
+RBAHasComeLaterThan::getExpressionText() const
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  RBAExpression* exprRhs = getRhsOperand();
+  return exprLhs->getExpressionText() + getSymbol()
+    + "(" + exprRhs->getExpressionText() + ")";
+}
+
+const std::string
+RBAHasComeLaterThan::getCoverageExpressionText() const
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  RBAExpression* exprRhs = getRhsOperand();
+  return exprLhs->getCoverageExpressionText() + getSymbol()
+    + "(" + exprRhs->getCoverageExpressionText() + ")";
+}
+
+RBAExpressionType
+RBAHasComeLaterThan::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAHasComeLaterThan.hpp b/src/core/expression/RBAHasComeLaterThan.hpp
new file mode 100644
index 0000000..659068f
--- /dev/null
+++ b/src/core/expression/RBAHasComeLaterThan.hpp
@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+/**
+ * HasComeLaterThan class
+ */
+
+#ifndef RBAHASCOMELATERTHAN_HPP
+#define RBAHASCOMELATERTHAN_HPP
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAHasComeLaterThan : public RBAContentOperator
+{
+public:
+  RBAHasComeLaterThan()=default;
+  RBAHasComeLaterThan(const RBAHasComeLaterThan&)=delete;
+  RBAHasComeLaterThan(const RBAHasComeLaterThan&&)=delete;
+  RBAHasComeLaterThan& operator=(const RBAHasComeLaterThan&)=delete;
+  RBAHasComeLaterThan& operator=(const RBAHasComeLaterThan&&)=delete;
+  virtual ~RBAHasComeLaterThan()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAHasComeLaterThanMaker.cpp b/src/core/expression/RBAHasComeLaterThanMaker.cpp
new file mode 100644
index 0000000..2b49835
--- /dev/null
+++ b/src/core/expression/RBAHasComeLaterThanMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAHasComeLaterThanMaker.cpp
+/// @brief HasComeLaterThan object generation class definitino file
+
+#include "RBAHasComeLaterThanMaker.hpp"
+#include "RBAHasComeLaterThan.hpp"
+
+namespace rba
+{
+
+RBAHasComeLaterThanMaker::RBAHasComeLaterThanMaker()
+  : RBAOperatorMaker{"HasComeLaterThan"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAHasComeLaterThanMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAHasComeLaterThan>();
+}
+
+}
diff --git a/src/core/expression/RBAHasComeLaterThanMaker.hpp b/src/core/expression/RBAHasComeLaterThanMaker.hpp
new file mode 100644
index 0000000..16a42c3
--- /dev/null
+++ b/src/core/expression/RBAHasComeLaterThanMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAHasComeLaterThanMaker.hpp
+/// @brief HasComeLaterThan object generation class header file
+
+#ifndef RBAHASCOMELATERTHANMAKER_HPP
+#define RBAHASCOMELATERTHANMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief HasComeLaterThan object generation class
+class RBAHasComeLaterThanMaker : public RBAOperatorMaker
+{
+public:
+  RBAHasComeLaterThanMaker();
+  RBAHasComeLaterThanMaker(const RBAHasComeLaterThanMaker&)=delete;
+  RBAHasComeLaterThanMaker(const RBAHasComeLaterThanMaker&&)=delete;
+  RBAHasComeLaterThanMaker& operator=(const RBAHasComeLaterThanMaker&)=delete;
+  RBAHasComeLaterThanMaker& operator=(const RBAHasComeLaterThanMaker&&)=delete;
+  virtual ~RBAHasComeLaterThanMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIfStatement.cpp b/src/core/expression/RBAIfStatement.cpp
new file mode 100644
index 0000000..d776bf7
--- /dev/null
+++ b/src/core/expression/RBAIfStatement.cpp
@@ -0,0 +1,268 @@
+/**
+ * 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.
+ */
+
+/**
+ * If statement class defintion file
+ */
+
+#include <sstream>
+#include "RBAIfStatement.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAIfStatement::setCondition(RBAExpression* const expr)
+{
+  condition_ = expr;
+}
+
+void
+RBAIfStatement::setThenExpression(RBAExpression* const expr)
+{
+  thenExpression_ = expr;
+}
+
+void
+RBAIfStatement::setElseExpression(RBAExpression* const expr)
+{
+  elseExpression_ = expr;
+}
+
+RBAExpression* const
+RBAIfStatement::getCondition() const
+{
+  return condition_;
+}
+
+RBAExpression* const
+RBAIfStatement::getThenExpression() const
+{
+  return thenExpression_;
+}
+
+RBAExpression* const
+RBAIfStatement::getElseExpression() const
+{
+  return elseExpression_;
+}
+
+void
+RBAIfStatement::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIfStatement::getModelElementType() const
+{
+  return RBAModelElementType::IfStatement;
+}
+
+bool
+RBAIfStatement::executeCore(RBAConstraintInfo* info,
+                            RBAArbitrator* arb) const
+{
+  LOG_addHierarchy("IF");
+  bool isPassed;
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  LOG_addHierarchy("#condition:");
+  const bool cond {getCondition()->execute(leftInfo, arb)};
+  LOG_removeHierarchy();
+  if (cond == true) {
+    LOG_addHierarchy("#then:");
+    isPassed = getThenExpression()->execute(rightInfo, arb);
+    LOG_removeHierarchy();
+  } else {
+    LOG_addHierarchy("#else:");
+    isPassed = getElseExpression()->execute(rightInfo, arb);
+    LOG_removeHierarchy();
+  }
+  if ((leftInfo->isExceptionBeforeArbitrate() == true)
+      || (rightInfo->isExceptionBeforeArbitrate() == true)) {
+    info->setExceptionBeforeArbitrate(true);
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+#ifdef RBA_USE_LOG
+  } else if (isPassed == true) {
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+#endif
+  }
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+const RBARuleObject*
+RBAIfStatement::getReferenceObjectCore(RBAConstraintInfo* info,
+                                       RBAArbitrator* arb) const
+{
+  LOG_addHierarchy("IF");
+  const RBARuleObject* object {nullptr};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  LOG_addHierarchy("#condition:");
+  const bool cond {getCondition()->execute(leftInfo, arb)};
+  LOG_removeHierarchy();
+  if (cond == true) {
+    LOG_addHierarchy("#then:");
+    object = getThenExpression()->getReferenceObject(rightInfo, arb);
+    LOG_removeHierarchy();
+  } else {
+    LOG_addHierarchy("#else:");
+    object = getElseExpression()->getReferenceObject(rightInfo, arb);
+    LOG_removeHierarchy();
+    if ((leftInfo->isExceptionBeforeArbitrate() == true)
+        || (rightInfo->isExceptionBeforeArbitrate() == true)) {
+      info->setExceptionBeforeArbitrate(true);
+    }
+  }
+  LOG_removeHierarchy();
+  return object;
+}
+
+std::int32_t
+RBAIfStatement::getValueCore(RBAConstraintInfo* info,
+                             RBAArbitrator* arb) const
+{
+  LOG_addHierarchy("IF");
+  std::int32_t value;
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  LOG_addHierarchy("#condition:");
+  const bool cond {getCondition()->execute(leftInfo, arb)};
+  LOG_removeHierarchy();
+  if (cond == true) {
+    LOG_addHierarchy("#then:");
+    value = getThenExpression()->getValue(rightInfo, arb);
+    LOG_removeHierarchy();
+  } else {
+    LOG_addHierarchy("#else:");
+    value = getElseExpression()->getValue(rightInfo, arb);
+    LOG_removeHierarchy();
+    if ((leftInfo->isExceptionBeforeArbitrate() == true)
+        || (rightInfo->isExceptionBeforeArbitrate() == true)) {
+      info->setExceptionBeforeArbitrate(true);
+    }
+  }
+  LOG_removeHierarchy();
+  return value;
+}
+
+void
+RBAIfStatement::doActionCore(RBAConstraintInfo* info,
+                             RBAArbitrator* arb)
+{
+  LOG_addHierarchy("IF");
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  LOG_addHierarchy("#condition:");
+  const bool cond {getCondition()->execute(leftInfo, arb)};
+  LOG_removeHierarchy();
+  if (cond == true) {
+    LOG_addHierarchy("#then:");
+    getThenExpression()->doAction(rightInfo, arb);
+    LOG_removeHierarchy();
+  } else {
+    LOG_addHierarchy("#else:");
+    getElseExpression()->doAction(rightInfo, arb);
+    LOG_removeHierarchy();
+  }
+#ifdef RBA_USE_LOG
+  LOG_coverageConstraintExpressionLog2(LOG_getCoverageExpressionText());
+#endif
+  LOG_removeHierarchy();
+  return;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIfStatement::getExpressionText() const
+{
+  std::ostringstream oss;
+  oss << "IF(";
+  oss << condition_->getExpressionText();
+  oss << ") THEN ";
+  oss << thenExpression_->getExpressionText();
+  oss << " ELSE ";
+  oss << elseExpression_->getExpressionText();
+
+  return oss.str();
+}
+
+const std::string
+RBAIfStatement::getCoverageExpressionText() const
+{
+  std::ostringstream oss;
+  oss << "IF(";
+  oss << condition_->getCoverageExpressionText();
+  oss << ") THEN ";
+  oss << thenExpression_->getCoverageExpressionText();
+  oss << " ELSE ";
+  oss << elseExpression_->getCoverageExpressionText();
+
+  return oss.str();
+}
+
+void
+RBAIfStatement::createHierarchy()
+{
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy("IF");
+  RBALogManager::coverageHierarchyOfConstraintExpressionLog(getCoverageExpressionText(),
+						 this);
+
+  // Add condition to the constraint hierarchy for coverage
+  LOG_addHierarchy("#condition:");
+  condition_->createHierarchy();
+  // Remove condtion from to the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  if(thenExpression_) {
+    // Add "then" to the constraint hierarchy for coverage
+    LOG_addHierarchy("#then:");
+    thenExpression_->createHierarchy();
+    // Remove "then" from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+  }
+
+  if(elseExpression_) {
+    // Add "else" to the constraint hierarchy for coverage
+    LOG_addHierarchy("#else:");
+    elseExpression_->createHierarchy();
+    // Remove "else" from the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+  }
+
+  // Remove itself from the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+}
+
+RBAExpressionType
+RBAIfStatement::getUnderlyingType() const
+{
+  return thenExpression_->getUnderlyingType();
+}
+#endif
+}
diff --git a/src/core/expression/RBAIfStatement.hpp b/src/core/expression/RBAIfStatement.hpp
new file mode 100644
index 0000000..7059583
--- /dev/null
+++ b/src/core/expression/RBAIfStatement.hpp
@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+
+/**
+ * If statement class header file
+ */
+
+#ifndef RBAIFSTATEMENT_HPP
+#define RBAIFSTATEMENT_HPP
+
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIfStatement : public RBAExpression
+{
+public:
+  RBAIfStatement()=default;
+  RBAIfStatement(const RBAIfStatement&)=delete;
+  RBAIfStatement(const RBAIfStatement&&)=delete;
+  RBAIfStatement& operator=(const RBAIfStatement&)=delete;
+  RBAIfStatement& operator=(const RBAIfStatement&&)=delete;
+  virtual ~RBAIfStatement()=default;
+
+public:
+  void setCondition(RBAExpression* const expr);
+  void setThenExpression(RBAExpression* const expr);
+  void setElseExpression(RBAExpression* const expr);
+  RBAExpression* const getCondition() const;
+  RBAExpression* const getThenExpression() const;
+  RBAExpression* const getElseExpression() const;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info,
+                                    RBAArbitrator* arb) const override;
+  void doActionCore(RBAConstraintInfo* info, RBAArbitrator* arb) override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  void createHierarchy() override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+ private:
+  RBAExpression* condition_ {nullptr};
+  RBAExpression* thenExpression_ {nullptr};
+  RBAExpression* elseExpression_ {nullptr};
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIfStatementMaker.cpp b/src/core/expression/RBAIfStatementMaker.cpp
new file mode 100644
index 0000000..b878ada
--- /dev/null
+++ b/src/core/expression/RBAIfStatementMaker.cpp
@@ -0,0 +1,78 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIfStatementMaker.cpp
+/// @brief IfStatement object generation class definition file
+
+#include "RBAIfStatementMaker.hpp"
+#include "RBAIfStatement.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAIfStatementMaker::RBAIfStatementMaker()
+  : RBAExpressionMaker{"IfStatement"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIfStatementMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIfStatement>();
+}
+
+RBAModelElement*
+RBAIfStatementMaker::setProperty(RBAModelElement* element,
+                                 const RBAJsonElement* jsonElem,
+                                 RBAModelImpl* model,
+                                 RBAModelElement* owner)
+{
+  RBAIfStatement* const ifstmt {dynamic_cast<RBAIfStatement*>(element)};
+
+  // Set LetStatement
+  const std::int32_t pop_num {setLetStatement(model, ifstmt, jsonElem)};
+
+  // Set condition
+  const RBAJsonElement* const condElem {jsonElem->findChildren("condition")};
+  RBAModelElement* const condExpr
+    {getFactory()->createElement(condElem->getClassName(), condElem)};
+  ifstmt->setCondition(dynamic_cast<RBAExpression*>(condExpr));
+  // Set "then"
+  const RBAJsonElement* const thenElem {jsonElem->findChildren("thenExpression")};
+  RBAModelElement* thenExpr {nullptr};
+  if(thenElem != nullptr) {
+    thenExpr = getFactory()->createElement(thenElem->getClassName(), thenElem);
+  }
+  ifstmt->setThenExpression(dynamic_cast<RBAExpression*>(thenExpr));
+  // Set "else"
+  const RBAJsonElement* const elseElem {jsonElem->findChildren("elseExpression")};
+  RBAModelElement* elseExpr {nullptr};
+  if(elseElem != nullptr) {
+    elseExpr = getFactory()->createElement(elseElem->getClassName(), elseElem);
+  }
+  ifstmt->setElseExpression(dynamic_cast<RBAExpression*>(elseExpr));
+
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+
+  return ifstmt;
+}
+
+}
diff --git a/src/core/expression/RBAIfStatementMaker.hpp b/src/core/expression/RBAIfStatementMaker.hpp
new file mode 100644
index 0000000..57a4133
--- /dev/null
+++ b/src/core/expression/RBAIfStatementMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIfStatementMaker.hpp
+/// @brief IfStatement object generation class header file
+
+#ifndef RBAIFSTATEMENTMAKER_HPP
+#define RBAIFSTATEMENTMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IfStatement object generation class
+class RBAIfStatementMaker : public RBAExpressionMaker
+{
+public:
+  RBAIfStatementMaker();
+  RBAIfStatementMaker(const RBAIfStatementMaker&)=delete;
+  RBAIfStatementMaker(const RBAIfStatementMaker&&)=delete;
+  RBAIfStatementMaker& operator=(const RBAIfStatementMaker&)=delete;
+  RBAIfStatementMaker& operator=(const RBAIfStatementMaker&&)=delete;
+  virtual ~RBAIfStatementMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief set property of Model Element for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model Model for storing generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAImpliesOperator.cpp b/src/core/expression/RBAImpliesOperator.cpp
new file mode 100644
index 0000000..ab95dc7
--- /dev/null
+++ b/src/core/expression/RBAImpliesOperator.cpp
@@ -0,0 +1,145 @@
+/**
+ * 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.
+ */
+
+ /**
+ * implication operator class defintion file
+ */
+
+#include "RBAImpliesOperator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAImpliesOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAImpliesOperator::getModelElementType() const
+{
+  return RBAModelElementType::ImpliesOperator;
+}
+
+bool
+RBAImpliesOperator::executeCore(RBAConstraintInfo* info,
+                                RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  // Add "left-hand side formula" to the constraint hierarchy for coverage
+  LOG_addHierarchy("#left"); 
+  const bool lhsRes {getLhsOperand()->execute(leftInfo, arb)};
+  // Remove "left-hand side formula" from the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  if (leftInfo->isExceptionBeforeArbitrate() == false) {
+    if (lhsRes == false) {
+      isPassed = true;
+    } else {
+      RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+      // Add "right-hand side formula" to the constraint hierarchy for coverage
+      LOG_addHierarchy("#right");
+      const bool rhsRes {getRhsOperand()->execute(rightInfo, arb)};
+      // Remove "right-hand side formula"
+      // from the constraint hierarchy for coverage
+      LOG_removeHierarchy();
+      if (rightInfo->isExceptionBeforeArbitrate() == true) {
+        info->setExceptionBeforeArbitrate(true);
+      } else if (rhsRes == true) {
+        isPassed = true;
+      } else {
+        ;
+      }
+    }
+  } else {
+    info->setExceptionBeforeArbitrate(true);
+    // Evaluate the right-hand side fromula
+    // to get the right side allocatable of arbitration target
+    RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+    // Add "right-hand side formula" to the constraint hierarchy for coverage
+    LOG_addHierarchy("#right");
+    static_cast<void>(getRhsOperand()->execute(rightInfo, arb));
+    // Remove "right-hand side formula" to the constraint hierarchy for coverage
+    LOG_removeHierarchy();
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate()) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAImpliesOperator::getSymbol() const
+{
+  return "->";
+}
+
+void
+RBAImpliesOperator::createHierarchy()
+{
+  RBAExpression* exprLhs = getLhsOperand();
+  RBAExpression* exprRhs = getRhsOperand();
+
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(getSymbol());
+  RBALogManager::coverageHierarchyOfConstraintExpressionLog(getCoverageExpressionText(), this);
+
+  // Add "left-hand side formula" to the constraint hierarchy for coverage
+  LOG_addHierarchy("#left");
+  exprLhs->createHierarchy();
+  // Remove "left-hand side formula" from
+  //  the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  // Add "right-hand side formula" to the constraint hierarchy for coverage
+  LOG_addHierarchy("#right");
+  exprRhs->createHierarchy();
+  // Remove "right-hand side formula" from
+  //  the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  // Remove itself from the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAImpliesOperator.hpp b/src/core/expression/RBAImpliesOperator.hpp
new file mode 100644
index 0000000..cc1cb33
--- /dev/null
+++ b/src/core/expression/RBAImpliesOperator.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/**
+ * implication operator class defintion file
+ */
+
+#ifndef RBAIMPLIESOPERATOR_HPP
+#define RBAIMPLIESOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAImpliesOperator: public RBALogicalOperator
+{
+public:
+  RBAImpliesOperator()=default;
+  RBAImpliesOperator(const RBAImpliesOperator&)=delete;
+  RBAImpliesOperator(const RBAImpliesOperator&&)=delete;
+  RBAImpliesOperator& operator=(const RBAImpliesOperator&)=delete;
+  RBAImpliesOperator& operator=(const RBAImpliesOperator&&)=delete;
+  virtual ~RBAImpliesOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  void createHierarchy() override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAImpliesOperatorMaker.cpp b/src/core/expression/RBAImpliesOperatorMaker.cpp
new file mode 100644
index 0000000..00b35fa
--- /dev/null
+++ b/src/core/expression/RBAImpliesOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAImpliesOperatorMaker.cpp
+/// @brief ImpliesOperator object generation class definition file
+
+#include "RBAImpliesOperatorMaker.hpp"
+#include "RBAImpliesOperator.hpp"
+
+namespace rba
+{
+
+RBAImpliesOperatorMaker::RBAImpliesOperatorMaker()
+  : RBAOperatorMaker{"ImpliesOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAImpliesOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAImpliesOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAImpliesOperatorMaker.hpp b/src/core/expression/RBAImpliesOperatorMaker.hpp
new file mode 100644
index 0000000..466d36a
--- /dev/null
+++ b/src/core/expression/RBAImpliesOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAImpliesOperatorMaker.hpp
+/// @brief ImpliesOperator object generation class header file
+
+#ifndef RBAIMPLIEDOPERATORMAKER_HPP
+#define RBAIMPLIEDOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ImpliesOperator object generation class
+class RBAImpliesOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAImpliesOperatorMaker();
+  RBAImpliesOperatorMaker(const RBAImpliesOperatorMaker&)=delete;
+  RBAImpliesOperatorMaker(const RBAImpliesOperatorMaker&&)=delete;
+  RBAImpliesOperatorMaker& operator=(const RBAImpliesOperatorMaker&)=delete;
+  RBAImpliesOperatorMaker& operator=(const RBAImpliesOperatorMaker&&)=delete;
+  virtual ~RBAImpliesOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIntegerValue.cpp b/src/core/expression/RBAIntegerValue.cpp
new file mode 100644
index 0000000..aadffb0
--- /dev/null
+++ b/src/core/expression/RBAIntegerValue.cpp
@@ -0,0 +1,79 @@
+/**
+ * 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.
+ */
+
+/**
+ * Integer value class definition file
+ */
+
+#include "RBAIntegerValue.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+
+namespace rba
+{
+
+void
+RBAIntegerValue::setValue(const std::int32_t value)
+{
+  value_ = value;
+}
+
+std::int32_t
+RBAIntegerValue::getValue() const
+{
+  return value_;
+}
+
+RBAModelElementType
+RBAIntegerValue::getModelElementType() const
+{
+  return RBAModelElementType::IntegerValue;
+}
+
+std::int32_t
+RBAIntegerValue::getValueCore(RBAConstraintInfo* info, RBAArbitrator * arb) const
+{
+  return getValue();
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIntegerValue::getExpressionText() const
+{
+  return std::to_string(value_);
+}
+
+const std::string
+RBAIntegerValue::getCoverageExpressionText() const
+{
+  return getExpressionText();
+}
+
+void
+RBAIntegerValue::createHierarchy()
+{
+  // No opration
+  // because there is no hierarchy below this expression
+}
+
+RBAExpressionType
+RBAIntegerValue::getUnderlyingType() const
+{
+  return RBAExpressionType::VALUE;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIntegerValue.hpp b/src/core/expression/RBAIntegerValue.hpp
new file mode 100644
index 0000000..44cf8cb
--- /dev/null
+++ b/src/core/expression/RBAIntegerValue.hpp
@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+
+/**
+ * Integer value class
+ */
+
+#ifndef RBAINTEGERVALUE_HPP
+#define RBAINTEGERVALUE_HPP
+
+#include "RBAValueExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIntegerValue : public RBAValueExpression
+{
+public:
+  RBAIntegerValue()=default;
+  RBAIntegerValue(const RBAIntegerValue&)=delete;
+  RBAIntegerValue(const RBAIntegerValue&&)=delete;
+  RBAIntegerValue& operator=(const RBAIntegerValue&)=delete;
+  RBAIntegerValue& operator=(const RBAIntegerValue&&)=delete;
+  virtual ~RBAIntegerValue()=default;
+
+public:
+  void setValue(const std::int32_t value);
+
+  std::int32_t getValue() const;
+  RBAModelElementType getModelElementType() const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info,
+                                    RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  void createHierarchy() override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+ private:
+  std::int32_t value_ {0};
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIntegerValueMaker.cpp b/src/core/expression/RBAIntegerValueMaker.cpp
new file mode 100644
index 0000000..19a21eb
--- /dev/null
+++ b/src/core/expression/RBAIntegerValueMaker.cpp
@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIntegerValueMaker.cpp
+/// @brief IntegerValue object generation class definition file
+
+#include "RBAIntegerValueMaker.hpp"
+#include "RBAIntegerValue.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAIntegerValueMaker::RBAIntegerValueMaker()
+  : RBAExpressionMaker{"IntegerValue"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIntegerValueMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIntegerValue>();
+}
+
+RBAModelElement*
+RBAIntegerValueMaker::setProperty(RBAModelElement* element,
+                                  const RBAJsonElement* jsonElem,
+                                  RBAModelImpl* model,
+                                  RBAModelElement* owner)
+{
+  RBAIntegerValue* const intVal {dynamic_cast<RBAIntegerValue*>(element)};
+
+  // Set LetStatement
+  const std::int32_t pop_num {setLetStatement(model, intVal, jsonElem)};
+
+  // Set value
+  const RBAJsonElement* const valueElem {jsonElem->findChildren("value")};
+  intVal->setValue(stoi(valueElem->getString()));
+
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+
+  return intVal;
+}
+
+}
diff --git a/src/core/expression/RBAIntegerValueMaker.hpp b/src/core/expression/RBAIntegerValueMaker.hpp
new file mode 100644
index 0000000..0f637df
--- /dev/null
+++ b/src/core/expression/RBAIntegerValueMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIntegerValueMaker.hpp
+/// @brief IntegerValue object generation class header file
+
+#ifndef RBAINTEGERVALUEMAKER_HPP
+#define RBAINTEGERVALUEMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IntegerValue object generation class
+class RBAIntegerValueMaker : public RBAExpressionMaker
+{
+public:
+  RBAIntegerValueMaker();
+  RBAIntegerValueMaker(const RBAIntegerValueMaker&)=delete;
+  RBAIntegerValueMaker(const RBAIntegerValueMaker&&)=delete;
+  RBAIntegerValueMaker& operator=(const RBAIntegerValueMaker&)=delete;
+  RBAIntegerValueMaker& operator=(const RBAIntegerValueMaker&&)=delete;
+  virtual ~RBAIntegerValueMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief set property of Model Element for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model Model for storing generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsActive.cpp b/src/core/expression/RBAIsActive.cpp
new file mode 100644
index 0000000..a89745f
--- /dev/null
+++ b/src/core/expression/RBAIsActive.cpp
@@ -0,0 +1,113 @@
+/**
+ * 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.
+ */
+
+/**
+ * IsActive class definition
+ */
+
+#include "RBAIsActive.hpp"
+#include "RBAContent.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void RBAIsActive::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIsActive::getModelElementType() const
+{
+  return RBAModelElementType::IsActive;
+}
+
+bool
+RBAIsActive::executeCore(RBAConstraintInfo* info,
+                             RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to the constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const ruleObj
+    {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+  if (leftInfo->isExceptionBeforeArbitrate() == true) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (ruleObj != nullptr) {
+    const RBAContent* const content {dynamic_cast<const RBAContent*>(ruleObj->getRawObject())};
+    if (ruleObj->isPrevious()) {
+      isPassed = arb->getResult()->isPreActive(content);
+    } else {
+      isPassed = arb->getResult()->isActive(content);
+    }
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      Content[NULL] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (ruleObj != nullptr) {
+    const RBAContent* content = dynamic_cast<const RBAContent*>(ruleObj
+        ->getRawObject());
+    if (isPassed == true) {
+      LOG_arbitrateConstraintLogicLogLine(
+          "      " + getPreMsg(ruleObj->isPrevious()) + "Content["
+              + content->getElementName() + "] is Active");
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                          RBAExecuteResult::TRUE);
+    } else {
+      LOG_arbitrateConstraintLogicLogLine(
+          "      " + getPreMsg(ruleObj->isPrevious()) + "Content["
+              + content->getElementName() + "] is not Active");
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                          RBAExecuteResult::FALSE);
+    }
+  } else {
+    LOG_arbitrateConstraintLogicLogLine("      Content[NULL] is not Active");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from the constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsActive::getSymbol() const
+{
+  return ".isActive()";
+}
+
+RBAExpressionType
+RBAIsActive::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsActive.hpp b/src/core/expression/RBAIsActive.hpp
new file mode 100644
index 0000000..73ab055
--- /dev/null
+++ b/src/core/expression/RBAIsActive.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/**
+ * IsActive class header file
+ */
+
+#ifndef RBAISACTIVE_HPP
+#define RBAISACTIVE_HPP
+
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsActive : public RBAContentOperator
+{
+public:
+  RBAIsActive()=default;
+  RBAIsActive(const RBAIsActive&)=delete;
+  RBAIsActive(const RBAIsActive&&)=delete;
+  RBAIsActive& operator=(const RBAIsActive&)=delete;
+  RBAIsActive& operator=(const RBAIsActive&&)=delete;
+  virtual ~RBAIsActive()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsActiveMaker.cpp b/src/core/expression/RBAIsActiveMaker.cpp
new file mode 100644
index 0000000..6b2e7ee
--- /dev/null
+++ b/src/core/expression/RBAIsActiveMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsActiveMaker.cpp
+/// @brief IsActive object generation class defintion file
+
+#include "RBAIsActiveMaker.hpp"
+#include "RBAIsActive.hpp"
+
+namespace rba
+{
+
+RBAIsActiveMaker::RBAIsActiveMaker()
+  : RBAOperatorMaker{"IsActive"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsActiveMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsActive>();
+}
+
+}
diff --git a/src/core/expression/RBAIsActiveMaker.hpp b/src/core/expression/RBAIsActiveMaker.hpp
new file mode 100644
index 0000000..15011fb
--- /dev/null
+++ b/src/core/expression/RBAIsActiveMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsActiveMaker.hpp
+/// @brief IsActive object generation class heaer file
+
+#ifndef RBAISACTIVEMAKER_HPP
+#define RBAISACTIVEMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsActive object generation class
+class RBAIsActiveMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsActiveMaker();
+  RBAIsActiveMaker(const RBAIsActiveMaker&)=delete;
+  RBAIsActiveMaker(const RBAIsActiveMaker&&)=delete;
+  RBAIsActiveMaker& operator=(const RBAIsActiveMaker&)=delete;
+  RBAIsActiveMaker& operator=(const RBAIsActiveMaker&&)=delete;
+  virtual ~RBAIsActiveMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsEqualToOperator.cpp b/src/core/expression/RBAIsEqualToOperator.cpp
new file mode 100644
index 0000000..5dfa929
--- /dev/null
+++ b/src/core/expression/RBAIsEqualToOperator.cpp
@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+
+/// IsEqualToOperator class definitino file
+
+#include "RBAIsEqualToOperator.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAIsEqualToOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIsEqualToOperator::getModelElementType() const
+{
+  return RBAModelElementType::IsEqualToOperator;
+}
+
+bool
+RBAIsEqualToOperator::executeCore(RBAConstraintInfo* info,
+                                  RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  const std::int32_t lhsVal {getLhsOperand()->getValue(leftInfo, arb)};
+  const std::int32_t rhsVal {getRhsOperand()->getValue(rightInfo, arb)};
+  if ((leftInfo->isExceptionBeforeArbitrate() == true)
+      || (rightInfo->isExceptionBeforeArbitrate() == true)
+      || (lhsVal == -99)
+      || (rhsVal == -99)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsVal == rhsVal) {
+      isPassed = true;
+      info->addTrueAllocatableFromOperand();
+    } else {
+      info->addFalseAllocatableFromOperand();
+    }
+  }
+
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (lhsVal == rhsVal) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsEqualToOperator::getSymbol() const
+{
+  return "=";
+}
+
+RBAExpressionType
+RBAIsEqualToOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsEqualToOperator.hpp b/src/core/expression/RBAIsEqualToOperator.hpp
new file mode 100644
index 0000000..d66efed
--- /dev/null
+++ b/src/core/expression/RBAIsEqualToOperator.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// IsEqualToOperator class header file
+
+#ifndef RBAISEQUALTOOPERATOR_HPP
+#define RBAISEQUALTOOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsEqualToOperator : public RBALogicalOperator
+{
+public:
+  RBAIsEqualToOperator()=default;
+  RBAIsEqualToOperator(const RBAIsEqualToOperator&)=delete;
+  RBAIsEqualToOperator(RBAIsEqualToOperator&&)=delete;
+  RBAIsEqualToOperator& operator=(const RBAIsEqualToOperator&)=delete;
+  RBAIsEqualToOperator& operator=(RBAIsEqualToOperator&&)=delete;
+  virtual ~RBAIsEqualToOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsEqualToOperatorMaker.cpp b/src/core/expression/RBAIsEqualToOperatorMaker.cpp
new file mode 100644
index 0000000..32717ce
--- /dev/null
+++ b/src/core/expression/RBAIsEqualToOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsEqualToOperatorMaker.cpp
+/// @brief IsEqualToOperator object generation file
+
+#include "RBAIsEqualToOperatorMaker.hpp"
+#include "RBAIsEqualToOperator.hpp"
+
+namespace rba
+{
+
+RBAIsEqualToOperatorMaker::RBAIsEqualToOperatorMaker()
+  : RBAOperatorMaker{"IsEqualToOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsEqualToOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsEqualToOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAIsEqualToOperatorMaker.hpp b/src/core/expression/RBAIsEqualToOperatorMaker.hpp
new file mode 100644
index 0000000..9d0fa30
--- /dev/null
+++ b/src/core/expression/RBAIsEqualToOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsEqualToOperatorMaker.hpp
+/// @brief IsEqualToOperator object generation file
+
+#ifndef RBAISEQUALTOOPERATORMAKER_HPP
+#define RBAISEQUALTOOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsEqualToOperator object generation class
+class RBAIsEqualToOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsEqualToOperatorMaker();
+  RBAIsEqualToOperatorMaker(const RBAIsEqualToOperatorMaker&)=delete;
+  RBAIsEqualToOperatorMaker(const RBAIsEqualToOperatorMaker&&)=delete;
+  RBAIsEqualToOperatorMaker& operator=(const RBAIsEqualToOperatorMaker&)=delete;
+  RBAIsEqualToOperatorMaker& operator=(const RBAIsEqualToOperatorMaker&&)=delete;
+  virtual ~RBAIsEqualToOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsGreaterThanEqualOperator.cpp b/src/core/expression/RBAIsGreaterThanEqualOperator.cpp
new file mode 100644
index 0000000..368bb3b
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanEqualOperator.cpp
@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+
+/// IsGreaterThanEqualOperator class definition file
+
+#include "RBAIsGreaterThanEqualOperator.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAIsGreaterThanEqualOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIsGreaterThanEqualOperator::getModelElementType() const
+{
+  return RBAModelElementType::IsGreaterThanEqualOperator;
+}
+
+bool
+RBAIsGreaterThanEqualOperator::executeCore(RBAConstraintInfo* info,
+                                           RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  const std::int32_t lhsVal {getLhsOperand()->getValue(leftInfo, arb)};
+  const std::int32_t rhsVal {getRhsOperand()->getValue(rightInfo, arb)};
+  // If a pre-arbitration exception occurs on either the left side 
+  // or the right side in the reference, throw it higher
+  if ((leftInfo->isExceptionBeforeArbitrate() == true)
+      || (rightInfo->isExceptionBeforeArbitrate() == true)
+      || (lhsVal == -99)
+      || (rhsVal == -99)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsVal >= rhsVal) {
+      isPassed = true;
+      info->addTrueAllocatableFromOperand();
+    } else {
+      info->addFalseAllocatableFromOperand();
+    }
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsGreaterThanEqualOperator::getSymbol() const
+{
+  return ">=";
+}
+
+RBAExpressionType
+RBAIsGreaterThanEqualOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsGreaterThanEqualOperator.hpp b/src/core/expression/RBAIsGreaterThanEqualOperator.hpp
new file mode 100644
index 0000000..0d5db61
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanEqualOperator.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// IsGreaterThanEqualOperator class header file
+
+#ifndef RBAISGREATERTHANEQUALOPERATOR_HPP
+#define RBAISGREATERTHANEQUALOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsGreaterThanEqualOperator : public RBALogicalOperator
+{
+public:
+  RBAIsGreaterThanEqualOperator()=default;
+  RBAIsGreaterThanEqualOperator(const RBAIsGreaterThanEqualOperator&)=delete;
+  RBAIsGreaterThanEqualOperator(RBAIsGreaterThanEqualOperator&&)=delete;
+  RBAIsGreaterThanEqualOperator& operator=(const RBAIsGreaterThanEqualOperator&)=delete;
+  RBAIsGreaterThanEqualOperator& operator=(RBAIsGreaterThanEqualOperator&&)=delete;
+  virtual ~RBAIsGreaterThanEqualOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsGreaterThanEqualOperatorMaker.cpp b/src/core/expression/RBAIsGreaterThanEqualOperatorMaker.cpp
new file mode 100644
index 0000000..e9e23a9
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanEqualOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsGreaterThanEqualOperatorMaker.cpp
+/// @brief IsGreaterThanEqualOperator object generation class
+
+#include "RBAIsGreaterThanEqualOperatorMaker.hpp"
+#include "RBAIsGreaterThanEqualOperator.hpp"
+
+namespace rba
+{
+
+RBAIsGreaterThanEqualOperatorMaker::RBAIsGreaterThanEqualOperatorMaker()
+  : RBAOperatorMaker{"IsGreaterThanEqualOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsGreaterThanEqualOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsGreaterThanEqualOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAIsGreaterThanEqualOperatorMaker.hpp b/src/core/expression/RBAIsGreaterThanEqualOperatorMaker.hpp
new file mode 100644
index 0000000..e7f470f
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanEqualOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsGreaterThanEqualOperatorMaker.hpp
+/// @brief IsGreaterThanEqualOperator object generation class header file
+
+#ifndef RBAISGREATERTHANEQUALOPERATORMAKER_HPP
+#define RBAISGREATERTHANEQUALOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsGreaterThanEqualOperator object generation class
+class RBAIsGreaterThanEqualOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsGreaterThanEqualOperatorMaker();
+  RBAIsGreaterThanEqualOperatorMaker(const RBAIsGreaterThanEqualOperatorMaker&)=delete;
+  RBAIsGreaterThanEqualOperatorMaker(const RBAIsGreaterThanEqualOperatorMaker&&)=delete;
+  RBAIsGreaterThanEqualOperatorMaker& operator=(const RBAIsGreaterThanEqualOperatorMaker&)=delete;
+  RBAIsGreaterThanEqualOperatorMaker& operator=(const RBAIsGreaterThanEqualOperatorMaker&&)=delete;
+  virtual ~RBAIsGreaterThanEqualOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsGreaterThanOperator.cpp b/src/core/expression/RBAIsGreaterThanOperator.cpp
new file mode 100644
index 0000000..d9153f1
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanOperator.cpp
@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+
+/// IsGreaterThanOperator class definition file
+
+#include "RBAIsGreaterThanOperator.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+RBAModelElementType
+RBAIsGreaterThanOperator::getModelElementType() const
+{
+  return RBAModelElementType::IsGreaterThanOperator;
+}
+
+void
+RBAIsGreaterThanOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+bool
+RBAIsGreaterThanOperator::executeCore(RBAConstraintInfo* info,
+                                      RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  const std::int32_t lhsVal {getLhsOperand()->getValue(leftInfo, arb)};
+  const std::int32_t rhsVal {getRhsOperand()->getValue(rightInfo, arb)};
+  // If a pre-arbitration exception occurs on either the left side 
+  // or the right side in the reference, throw it higher
+  if ((leftInfo->isExceptionBeforeArbitrate() == true)
+      || (rightInfo->isExceptionBeforeArbitrate() == true)
+      || (lhsVal == -99)
+      || (rhsVal == -99)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsVal > rhsVal) {
+      isPassed = true;
+      info->addTrueAllocatableFromOperand();
+    } else {
+      info->addFalseAllocatableFromOperand();
+    }
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsGreaterThanOperator::getSymbol() const
+{
+  return ">";
+}
+
+RBAExpressionType
+RBAIsGreaterThanOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsGreaterThanOperator.hpp b/src/core/expression/RBAIsGreaterThanOperator.hpp
new file mode 100644
index 0000000..9e0938b
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanOperator.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// IsGreaterThanOperator class header file
+
+#ifndef RBAISGREATERTHANOPERATOR_HPP
+#define RBAISGREATERTHANOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsGreaterThanOperator : public RBALogicalOperator
+{
+public:
+  RBAIsGreaterThanOperator()=default;
+  RBAIsGreaterThanOperator(const RBAIsGreaterThanOperator&)=delete;
+  RBAIsGreaterThanOperator(RBAIsGreaterThanOperator&&)=delete;
+  RBAIsGreaterThanOperator& operator=(const RBAIsGreaterThanOperator&)=delete;
+  RBAIsGreaterThanOperator& operator=(RBAIsGreaterThanOperator&&)=delete;
+  virtual ~RBAIsGreaterThanOperator()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsGreaterThanOperatorMaker.cpp b/src/core/expression/RBAIsGreaterThanOperatorMaker.cpp
new file mode 100644
index 0000000..37a2888
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsGreaterThanEqualOperatorMaker.cpp
+/// @brief IsGreaterThanEqualOperator object generation class definition file
+
+#include "RBAIsGreaterThanOperatorMaker.hpp"
+#include "RBAIsGreaterThanOperator.hpp"
+
+namespace rba
+{
+
+RBAIsGreaterThanOperatorMaker::RBAIsGreaterThanOperatorMaker()
+  : RBAOperatorMaker{"IsGreaterThanOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsGreaterThanOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsGreaterThanOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAIsGreaterThanOperatorMaker.hpp b/src/core/expression/RBAIsGreaterThanOperatorMaker.hpp
new file mode 100644
index 0000000..40bfc17
--- /dev/null
+++ b/src/core/expression/RBAIsGreaterThanOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsGreaterThanEqualOperatorMaker.hpp
+/// @brief IsGreaterThanEqualOperator object generation class header file
+
+#ifndef RBAISGREATERTHANOPERATORMAKER_HPP
+#define RBAISGREATERTHANOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsGreaterThanEqualOperator object generation class
+class RBAIsGreaterThanOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsGreaterThanOperatorMaker();
+  RBAIsGreaterThanOperatorMaker(const RBAIsGreaterThanOperatorMaker&)=delete;
+  RBAIsGreaterThanOperatorMaker(const RBAIsGreaterThanOperatorMaker&&)=delete;
+  RBAIsGreaterThanOperatorMaker& operator=(const RBAIsGreaterThanOperatorMaker&)=delete;
+  RBAIsGreaterThanOperatorMaker& operator=(const RBAIsGreaterThanOperatorMaker&&)=delete;
+  virtual ~RBAIsGreaterThanOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsLowerThanEqualOperator.cpp b/src/core/expression/RBAIsLowerThanEqualOperator.cpp
new file mode 100644
index 0000000..811b34d
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanEqualOperator.cpp
@@ -0,0 +1,106 @@
+/**
+ * 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.
+ */
+
+/// IsLowerThanEqualOperator class definition file
+
+#include "RBAIsLowerThanEqualOperator.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+
+namespace rba
+{
+
+void
+RBAIsLowerThanEqualOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIsLowerThanEqualOperator::getModelElementType() const
+{
+  return RBAModelElementType::IsLowerThanEqualOperator;
+}
+
+bool
+RBAIsLowerThanEqualOperator::executeCore(RBAConstraintInfo* info,
+                                         RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  const std::int32_t lhsVal {getLhsOperand()->getValue(leftInfo, arb)};
+  const std::int32_t rhsVal {getRhsOperand()->getValue(rightInfo, arb)};
+  // If a pre-arbitration exception occurs on either the left side 
+  // or the right side in the reference, throw it higher
+  if ((leftInfo->isExceptionBeforeArbitrate() == true)
+      || (rightInfo->isExceptionBeforeArbitrate() == true)
+      || (lhsVal == -99)
+      || (rhsVal == -99)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsVal <= rhsVal) {
+      isPassed = true;
+      info->addTrueAllocatableFromOperand();
+    } else {
+      info->addFalseAllocatableFromOperand();
+    }
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsLowerThanEqualOperator::getSymbol() const
+{
+  return "<=";
+}
+
+RBAExpressionType
+RBAIsLowerThanEqualOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsLowerThanEqualOperator.hpp b/src/core/expression/RBAIsLowerThanEqualOperator.hpp
new file mode 100644
index 0000000..3459110
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanEqualOperator.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// IsLowerThanEqualOperator class header file
+
+#ifndef RBAISLOWERTHANEQUALOPERATOR_HPP
+#define RBAISLOWERTHANEQUALOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsLowerThanEqualOperator : public RBALogicalOperator
+{
+public:
+  RBAIsLowerThanEqualOperator()=default;
+  RBAIsLowerThanEqualOperator(const RBAIsLowerThanEqualOperator&)=delete;
+  RBAIsLowerThanEqualOperator(RBAIsLowerThanEqualOperator&&)=delete;
+  RBAIsLowerThanEqualOperator& operator=(const RBAIsLowerThanEqualOperator&)=delete;
+  RBAIsLowerThanEqualOperator& operator=(RBAIsLowerThanEqualOperator&&)=delete;
+  virtual ~RBAIsLowerThanEqualOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsLowerThanEqualOperatorMaker.cpp b/src/core/expression/RBAIsLowerThanEqualOperatorMaker.cpp
new file mode 100644
index 0000000..a04a52b
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanEqualOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsLowerThanEqualOperatorMaker.cpp
+/// @brief IsLowerThanEqualOperator object geneation class defintion file
+
+#include "RBAIsLowerThanEqualOperatorMaker.hpp"
+#include "RBAIsLowerThanEqualOperator.hpp"
+
+namespace rba
+{
+
+RBAIsLowerThanEqualOperatorMaker::RBAIsLowerThanEqualOperatorMaker()
+  : RBAOperatorMaker{"IsLowerThanEqualOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsLowerThanEqualOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsLowerThanEqualOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAIsLowerThanEqualOperatorMaker.hpp b/src/core/expression/RBAIsLowerThanEqualOperatorMaker.hpp
new file mode 100644
index 0000000..10cf469
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanEqualOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsLowerThanEqualOperatorMaker.hpp
+/// @brief IsLowerThanEqualOperator object geneation class header file
+
+#ifndef RBAISLOWERTHANEQUALOPERATORMAKER_HPP
+#define RBAISLOWERTHANEQUALOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsLowerThanEqualOperator object generation class
+class RBAIsLowerThanEqualOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsLowerThanEqualOperatorMaker();
+  RBAIsLowerThanEqualOperatorMaker(const RBAIsLowerThanEqualOperatorMaker&)=delete;
+  RBAIsLowerThanEqualOperatorMaker(const RBAIsLowerThanEqualOperatorMaker&&)=delete;
+  RBAIsLowerThanEqualOperatorMaker& operator=(const RBAIsLowerThanEqualOperatorMaker&)=delete;
+  RBAIsLowerThanEqualOperatorMaker& operator=(const RBAIsLowerThanEqualOperatorMaker&&)=delete;
+  virtual ~RBAIsLowerThanEqualOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsLowerThanOperator.cpp b/src/core/expression/RBAIsLowerThanOperator.cpp
new file mode 100644
index 0000000..99a7860
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanOperator.cpp
@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+
+/// IsLowerThanOperator class definition file
+
+#include "RBAIsLowerThanOperator.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAIsLowerThanOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIsLowerThanOperator::getModelElementType() const
+{
+  return RBAModelElementType::IsLowerThanOperator;
+}
+
+bool
+RBAIsLowerThanOperator::executeCore(RBAConstraintInfo* info,
+                                    RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+  const std::int32_t lhsVal {getLhsOperand()->getValue(leftInfo, arb)};
+  const std::int32_t rhsVal {getRhsOperand()->getValue(rightInfo, arb)};
+  // If a pre-arbitration exception occurs on either the left side 
+  // or the right side in the reference, throw it higher
+  if ((leftInfo->isExceptionBeforeArbitrate() == true)
+      || (rightInfo->isExceptionBeforeArbitrate() == true)
+      || (lhsVal == -99)
+      || (rhsVal == -99)) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsVal < rhsVal) {
+      isPassed = true;
+      info->addTrueAllocatableFromOperand();
+    } else {
+      info->addFalseAllocatableFromOperand();
+    }
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsLowerThanOperator::getSymbol() const
+{
+  return "<";
+}
+
+RBAExpressionType
+RBAIsLowerThanOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsLowerThanOperator.hpp b/src/core/expression/RBAIsLowerThanOperator.hpp
new file mode 100644
index 0000000..3a23e45
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanOperator.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// IsLowerThanOperator class header file
+
+#ifndef RBAISLOWERTHANOPERATOR_HPP
+#define RBAISLOWERTHANOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsLowerThanOperator : public RBALogicalOperator
+{
+public:
+  RBAIsLowerThanOperator()=default;
+  RBAIsLowerThanOperator(const RBAIsLowerThanOperator&)=delete;
+  RBAIsLowerThanOperator(RBAIsLowerThanOperator&&)=delete;
+  RBAIsLowerThanOperator& operator=(const RBAIsLowerThanOperator&)=delete;
+  RBAIsLowerThanOperator& operator=(RBAIsLowerThanOperator&&)=delete;
+  virtual ~RBAIsLowerThanOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsLowerThanOperatorMaker.cpp b/src/core/expression/RBAIsLowerThanOperatorMaker.cpp
new file mode 100644
index 0000000..f6ddf53
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanOperatorMaker.cpp
@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+/// @file  RBAIsLowerThanOperatorMaker.cpp
+/// @brief IsLowerThanOperator object gerneation class
+
+#include "RBAIsLowerThanOperatorMaker.hpp"
+#include "RBAIsLowerThanOperator.hpp"
+
+namespace rba
+{
+
+RBAIsLowerThanOperatorMaker::RBAIsLowerThanOperatorMaker()
+  : RBAOperatorMaker{"IsLowerThanOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsLowerThanOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsLowerThanOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAIsLowerThanOperatorMaker.hpp b/src/core/expression/RBAIsLowerThanOperatorMaker.hpp
new file mode 100644
index 0000000..d2c6870
--- /dev/null
+++ b/src/core/expression/RBAIsLowerThanOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsLowerThanOperatorMaker.hpp
+/// @brief IsLowerThanOperator object gerneation class header file
+
+#ifndef RBAISLOWERTHANOPERATORMAKER_HPP
+#define RBAISLOWERTHANOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief sLowerThanOperator object gerneation class
+class RBAIsLowerThanOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsLowerThanOperatorMaker();
+  RBAIsLowerThanOperatorMaker(const RBAIsLowerThanOperatorMaker&)=delete;
+  RBAIsLowerThanOperatorMaker(const RBAIsLowerThanOperatorMaker&&)=delete;
+  RBAIsLowerThanOperatorMaker& operator=(const RBAIsLowerThanOperatorMaker&)=delete;
+  RBAIsLowerThanOperatorMaker& operator=(const RBAIsLowerThanOperatorMaker&&)=delete;
+  virtual ~RBAIsLowerThanOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsOn.cpp b/src/core/expression/RBAIsOn.cpp
new file mode 100644
index 0000000..f8dd769
--- /dev/null
+++ b/src/core/expression/RBAIsOn.cpp
@@ -0,0 +1,132 @@
+/**
+ * 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.
+ */
+
+/**
+ * IsOn class (to judge if a Scene is active) definition file
+ */
+
+#include "RBAIsOn.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBALogManager.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void
+RBAIsOn::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAIsOn::getModelElementType() const
+{
+  return RBAModelElementType::IsOn;
+}
+
+bool
+RBAIsOn::executeCore(RBAConstraintInfo* info,
+                     RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const ruleObj
+    {getLhsOperand()->getReferenceObject(leftInfo, arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (ruleObj != nullptr){
+    const RBASceneImpl* const scene {dynamic_cast<const RBASceneImpl*>(ruleObj->getRawObject())};
+    if (ruleObj->isPrevious() == false) {
+      isPassed = arb->getResult()->isActive(scene);
+    } else {
+      isPassed = arb->getResult()->isPreActive(scene);
+    }
+  } else {
+    // Currently, there is no expression that returns null as "Scene", 
+    // so it does not go through this path. But an expression　that returns null
+    // may be added　in the future, so it is described as it is.
+    ;
+  }
+#ifdef RBA_USE_LOG
+  if (ruleObj != nullptr) {
+    const RBASceneImpl* scene = dynamic_cast<const RBASceneImpl*>(ruleObj
+        ->getRawObject());
+    if (info->isExceptionBeforeArbitrate() == true) {
+      LOG_arbitrateConstraintLogicLogLine(
+          "      Scene[" + scene->getName() + "] before arbitrate skip");
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                          RBAExecuteResult::SKIP);
+    } else if (isPassed == true) {
+      LOG_arbitrateConstraintLogicLogLine(
+          "      " + getPreMsg(ruleObj->isPrevious()) + "Scene["
+              + scene->getName() + "] is On");
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                          RBAExecuteResult::TRUE);
+    } else {
+      LOG_arbitrateConstraintLogicLogLine(
+          "      " + getPreMsg(ruleObj->isPrevious()) + "Scene["
+              + scene->getName() + "] is not On");
+      LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                          RBAExecuteResult::FALSE);
+    }
+  } else {
+    // Currently, there is no expression that returns null as "Scene", 
+    // so it does not go through this path. But an expression　that returns null
+    // may be added　in the future, so it is described as it is.
+    LOG_arbitrateConstraintLogicLogLine(
+        "      " + getPreMsg(ruleObj->isPrevious()) + "Scene[NULL] is not On");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIsOn::getSymbol() const
+{
+  return ".isOn()";
+}
+
+const std::string
+RBAIsOn::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+
+const std::string RBAIsOn::getCoverageExpressionText() const
+{
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol();
+}
+
+RBAExpressionType
+RBAIsOn::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAIsOn.hpp b/src/core/expression/RBAIsOn.hpp
new file mode 100644
index 0000000..9f3f778
--- /dev/null
+++ b/src/core/expression/RBAIsOn.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * IsOn class (to judge if a Scene is active) header
+ */
+
+#ifndef RBAISON_HPP
+#define RBAISON_HPP
+
+#include "RBASceneOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsOn : public RBASceneOperator
+{
+public:
+  RBAIsOn()=default;
+  RBAIsOn(const RBAIsOn&)=delete;
+  RBAIsOn(const RBAIsOn&&)=delete;
+  RBAIsOn& operator=(const RBAIsOn&)=delete;
+  RBAIsOn& operator=(const RBAIsOn&&)=delete;
+  virtual ~RBAIsOn()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsOnMaker.cpp b/src/core/expression/RBAIsOnMaker.cpp
new file mode 100644
index 0000000..79a4e16
--- /dev/null
+++ b/src/core/expression/RBAIsOnMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsOnMaker.cpp
+/// @brief IsOn (to judge if a Scene is active) class generation definition
+
+#include "RBAIsOnMaker.hpp"
+#include "RBAIsOn.hpp"
+
+namespace rba
+{
+
+RBAIsOnMaker::RBAIsOnMaker()
+  : RBAOperatorMaker{"IsOn"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsOnMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsOn>();
+}
+
+}
diff --git a/src/core/expression/RBAIsOnMaker.hpp b/src/core/expression/RBAIsOnMaker.hpp
new file mode 100644
index 0000000..824d091
--- /dev/null
+++ b/src/core/expression/RBAIsOnMaker.hpp
@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsOnMaker.hpp
+/// @brief IsOn object generation class header file
+///        IsOn is class to judge if a Scene is active
+
+#ifndef RBAISONMAKER_HPP
+#define RBAISONMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsOn object generation class
+class RBAIsOnMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsOnMaker();
+  RBAIsOnMaker(const RBAIsOnMaker&)=delete;
+  RBAIsOnMaker(const RBAIsOnMaker&&)=delete;
+  RBAIsOnMaker& operator=(const RBAIsOnMaker&)=delete;
+  RBAIsOnMaker& operator=(const RBAIsOnMaker&&)=delete;
+  virtual ~RBAIsOnMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAIsTypeOfOperator.cpp b/src/core/expression/RBAIsTypeOfOperator.cpp
new file mode 100644
index 0000000..2104f43
--- /dev/null
+++ b/src/core/expression/RBAIsTypeOfOperator.cpp
@@ -0,0 +1,102 @@
+/**
+ * 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.
+ */
+
+//
+// IsTypeOf class defintion file
+//
+
+#include "RBAIsTypeOfOperator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBALogManager.hpp"
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+void RBAIsTypeOfOperator::setTag(const std::string& tag)
+{
+  tagId_ = tag;
+}
+
+void RBAIsTypeOfOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+RBAModelElementType RBAIsTypeOfOperator::getModelElementType() const
+{
+  return RBAModelElementType::IsTypeOfOperator;
+}
+bool RBAIsTypeOfOperator::executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo * const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const ruleObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                     arb)};
+  if (leftInfo->isExceptionBeforeArbitrate() == true) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (ruleObj != nullptr) {
+    isPassed = ruleObj->containsTag(tagId_);
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate()) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      " + getExpressionText() + " before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if ((ruleObj == nullptr) || (!isPassed)) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      " + getExpressionText() + " false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      " + getExpressionText() + " true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  }
+#endif
+  LOG_removeHierarchy();
+  return isPassed;
+}
+#ifdef RBA_USE_LOG
+const std::string RBAIsTypeOfOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+
+const std::string RBAIsTypeOfOperator::getCoverageExpressionText() const
+{
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol();
+}
+
+const std::string RBAIsTypeOfOperator::getSymbol() const
+{
+  return ".isTypeOf(" + tagId_ + ")";
+}
+
+RBAExpressionType RBAIsTypeOfOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+}
+/* namespace rba */
diff --git a/src/core/expression/RBAIsTypeOfOperator.hpp b/src/core/expression/RBAIsTypeOfOperator.hpp
new file mode 100644
index 0000000..ce4d213
--- /dev/null
+++ b/src/core/expression/RBAIsTypeOfOperator.hpp
@@ -0,0 +1,66 @@
+/**
+ * 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.
+ */
+
+//
+// IsTypeOfクラスヘッダファイル
+//
+
+#ifndef RBAISTYPEOFOPERATOR_HPP
+#define RBAISTYPEOFOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAIsTypeOfOperator : public RBAOperator
+{
+ public:
+  RBAIsTypeOfOperator()=default;
+  RBAIsTypeOfOperator(const RBAIsTypeOfOperator&)=delete;
+  RBAIsTypeOfOperator(const RBAIsTypeOfOperator&&)=delete;
+  RBAIsTypeOfOperator& operator=(const RBAIsTypeOfOperator&)=delete;
+  RBAIsTypeOfOperator& operator=(const RBAIsTypeOfOperator&&)=delete;
+  virtual ~RBAIsTypeOfOperator()=default;
+
+ public:
+  void setTag(const std::string& tag);
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  const std::string getSymbol() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+ private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::string tagId_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+} /* namespace rba */
+
+#endif /* RBAISTYPEOFOPERATOR_HPP */
diff --git a/src/core/expression/RBAIsTypeOfOperatorMaker.cpp b/src/core/expression/RBAIsTypeOfOperatorMaker.cpp
new file mode 100644
index 0000000..cabd83c
--- /dev/null
+++ b/src/core/expression/RBAIsTypeOfOperatorMaker.cpp
@@ -0,0 +1,70 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsTypeOfOperatorMaker.cpp
+/// @brief IsTypeOf object generation class
+
+#include "RBAIsTypeOfOperatorMaker.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAIsTypeOfOperator.hpp"
+
+namespace rba
+{
+
+RBAIsTypeOfOperatorMaker::RBAIsTypeOfOperatorMaker()
+  : RBAOperatorMaker{"IsTypeOf"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAIsTypeOfOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAIsTypeOfOperator>();
+}
+
+RBAModelElement*
+RBAIsTypeOfOperatorMaker::setProperty(RBAModelElement* element,
+                                      const RBAJsonElement* jsonElem,
+                                      RBAModelImpl* model,
+                                      RBAModelElement* owner)
+{
+  RBAIsTypeOfOperator* const isTypeOfOpe
+    {dynamic_cast<RBAIsTypeOfOperator*>(element)};
+
+  // Set LetStatement
+  const std::int32_t pop_num {setLetStatement(model, isTypeOfOpe, jsonElem)};
+
+  // Set operand
+  const RBAJsonElement* const operand {jsonElem->findChildren("operand")};
+  const RBAJsonElement* const param {operand->getChild()};
+  RBAModelElement* const expr {getFactory()->createElement(param->getClassName(), param)};
+  isTypeOfOpe->addOperand(dynamic_cast<RBAExpression*>(expr));
+  // Set Tag
+  const RBAJsonElement* const tagElem {jsonElem->findChildren("tagName")};
+  isTypeOfOpe->setTag(tagElem->getString());
+
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+
+  return isTypeOfOpe;
+}
+
+}
diff --git a/src/core/expression/RBAIsTypeOfOperatorMaker.hpp b/src/core/expression/RBAIsTypeOfOperatorMaker.hpp
new file mode 100644
index 0000000..5877267
--- /dev/null
+++ b/src/core/expression/RBAIsTypeOfOperatorMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAIsTypeOfOperatorMaker.hpp
+/// @brief IsTypeOf object geneation class header file
+
+#ifndef RBAISTYPEOFOPERATORMAKER_HPP
+#define RBAISTYPEOFOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief IsTypeOf object geneation class
+class RBAIsTypeOfOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAIsTypeOfOperatorMaker();
+  RBAIsTypeOfOperatorMaker(const RBAIsTypeOfOperatorMaker&)=delete;
+  RBAIsTypeOfOperatorMaker(const RBAIsTypeOfOperatorMaker&&)=delete;
+  RBAIsTypeOfOperatorMaker& operator=(const RBAIsTypeOfOperatorMaker&)=delete;
+  RBAIsTypeOfOperatorMaker& operator=(const RBAIsTypeOfOperatorMaker&&)=delete;
+  virtual ~RBAIsTypeOfOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALambdaContext.cpp b/src/core/expression/RBALambdaContext.cpp
new file mode 100644
index 0000000..7d68513
--- /dev/null
+++ b/src/core/expression/RBALambdaContext.cpp
@@ -0,0 +1,92 @@
+/**
+ * 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.
+ */
+
+/**
+ * LambdaContext class definition file
+ */
+
+#include "RBALambdaContext.hpp"
+#include "RBALogManager.hpp"
+#include "RBAVariable.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentSet.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBALambdaExpression* const
+RBALambdaContext::getLambda() const
+{
+  return lambda_;
+}
+
+void
+RBALambdaContext::setLambda(RBALambdaExpression* const newLambda)
+{
+  lambda_ = newLambda;
+}
+
+#ifdef RBA_USE_LOG
+void
+RBALambdaContext::createHierarchy()
+{
+  lambda_->getX()->clearRuleObj();
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(getSymbol());
+  RBALogManager::coverageHierarchyOfConstraintExpressionLog(getCoverageExpressionText(), this);
+
+  // Get rule object and loop
+  RBAExpression* setObj = getLhsOperand();
+  RBAConstraintInfo dummyInfo;
+  // Since it is not referenced by "AllInstanceOf..." or "SetOfOperator" 
+  // used for the set of "For-All" or "Exists", nullptr is no problem
+  RBAArbitrator* dummyArb = nullptr;
+  const RBARuleObject* objset = setObj->getReferenceObject(&dummyInfo, dummyArb);
+  std::vector<const RBARuleObject*> objs;
+  if(objset) {
+    if(dynamic_cast<const RBAAllocatableSet*>(objset) != nullptr) {
+      const RBAAllocatableSet* aSet
+	= dynamic_cast<const RBAAllocatableSet*>(objset);
+      for(const auto& alloc : aSet->getLeafAllocatable()) {
+	objs.push_back(alloc);
+      }
+    }
+    else if(dynamic_cast<const RBAContentSet*>(objset) != nullptr) {
+      const RBAContentSet* cSet = dynamic_cast<const RBAContentSet*>(objset);
+      for(const auto& cont : cSet->getLeafContent() ){
+	objs.push_back(cont);
+      }
+    }
+  }
+
+  // Enable expansion of own variables in the coverage log
+  std::int32_t idx=0;
+  for(const RBARuleObject* obj : objs) {
+    LOG_addHierarchy("#" + std::to_string(idx++));
+    lambda_->getX()->setRuleObj(obj);
+    lambda_->createHierarchy();
+    LOG_removeHierarchy();
+  }
+
+  // Remove own to Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBALambdaContext.hpp b/src/core/expression/RBALambdaContext.hpp
new file mode 100644
index 0000000..219be71
--- /dev/null
+++ b/src/core/expression/RBALambdaContext.hpp
@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+/**
+ * LambdaContext class header file
+ */
+
+#ifndef RBALAMBDACONTEXT_HPP
+#define RBALAMBDACONTEXT_HPP
+
+#include "RBASetOperator.hpp"
+
+namespace rba
+{
+
+class RBALambdaExpression;
+
+class DLL_EXPORT RBALambdaContext : public RBASetOperator
+{
+protected:
+  RBALambdaContext()=default;
+  RBALambdaContext(const RBALambdaContext&)=delete;
+  RBALambdaContext(const RBALambdaContext&&)=delete;
+  RBALambdaContext& operator=(const RBALambdaContext&)=delete;
+  RBALambdaContext& operator=(const RBALambdaContext&&)=delete;
+public:
+  virtual ~RBALambdaContext()=default;
+
+public:
+  RBALambdaExpression* const getLambda() const;
+  void setLambda(RBALambdaExpression* const newLambda);
+
+#ifdef RBA_USE_LOG
+  void createHierarchy() override;
+#endif
+
+private:
+  RBALambdaExpression* lambda_ {nullptr};
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALambdaContextMaker.cpp b/src/core/expression/RBALambdaContextMaker.cpp
new file mode 100644
index 0000000..f0e7e4d
--- /dev/null
+++ b/src/core/expression/RBALambdaContextMaker.cpp
@@ -0,0 +1,65 @@
+/**
+ * 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.
+ */
+
+/// @file  RBALambdaContextMaker.cpp
+/// @brief LambdaContext object generation abstract class definition
+
+#include "RBALambdaContextMaker.hpp"
+#include "RBALambdaContext.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBALambdaContextMaker::RBALambdaContextMaker(const std::string& label)
+  : RBAOperatorMaker{label}
+{
+}
+
+RBAModelElement*
+RBALambdaContextMaker::setProperty(RBAModelElement* element,
+                                   const RBAJsonElement* jsonElem,
+                                   RBAModelImpl* model,
+                                   RBAModelElement* owner)
+{
+  RBALambdaContext* const lambdaContext
+    {dynamic_cast<RBALambdaContext*>(element)};
+
+  // Set LetStatement
+  const std::int32_t pop_num {setLetStatement(model, lambdaContext, jsonElem)};
+  // Set lambda
+  const RBAJsonElement* const lambdaElement {jsonElem->findChildren("lambda")};
+  RBAModelElement* const lambdaExpr
+    {getFactory()->createElement(lambdaElement->getClassName(), lambdaElement)};
+  lambdaContext->setLambda(dynamic_cast<RBALambdaExpression*>(lambdaExpr));
+  // Set operand
+  const RBAJsonElement* const param {jsonElem->findChildren("operand")->getChild()};
+  RBAModelElement* const expr
+    {getFactory()->createElement(param->getClassName(), param)};
+  lambdaContext->addOperand(dynamic_cast<RBAExpression*>(expr));
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+
+  return lambdaContext;
+}
+
+}
diff --git a/src/core/expression/RBALambdaContextMaker.hpp b/src/core/expression/RBALambdaContextMaker.hpp
new file mode 100644
index 0000000..6df7001
--- /dev/null
+++ b/src/core/expression/RBALambdaContextMaker.hpp
@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+
+/// @file  RBALambdaContextMaker.cpp
+/// @brief LambdaContext object generation abstract class header file
+
+#ifndef RBASETOPERATORMAKER_HPP
+#define RBASETOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+class RBALambdaContext;
+
+/// @brief LambdaContext object generation abstract class
+class RBALambdaContextMaker : public RBAOperatorMaker
+{
+public:
+  explicit RBALambdaContextMaker(const std::string& label="");
+  RBALambdaContextMaker(const RBALambdaContextMaker&)=delete;
+  RBALambdaContextMaker(const RBALambdaContextMaker&&)=delete;
+  RBALambdaContextMaker& operator=(const RBALambdaContextMaker&)=delete;
+  RBALambdaContextMaker& operator=(const RBALambdaContextMaker&&)=delete;
+  virtual ~RBALambdaContextMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner=nullptr) override;
+
+  /// @brief generate an empty object of LambdaContext
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for LambdaContext object
+  virtual std::unique_ptr<RBALambdaContext> createLambdaContext()=0;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALambdaExpression.cpp b/src/core/expression/RBALambdaExpression.cpp
new file mode 100644
index 0000000..7638faa
--- /dev/null
+++ b/src/core/expression/RBALambdaExpression.cpp
@@ -0,0 +1,139 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBALambdaExpression class defnition
+ */
+
+#include "RBALambdaExpression.hpp"
+#include "RBAVariable.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void
+RBALambdaExpression::setX(RBAVariable* const x)
+{
+  variable_ = x;
+}
+
+void
+RBALambdaExpression::setBodyText(RBAExpression* const expr)
+{
+  bodyText_ = expr;
+}
+
+RBAVariable* const
+RBALambdaExpression::getX() const
+{
+  return variable_;
+}
+
+RBAExpression* const
+RBALambdaExpression::getBodyText() const
+{
+  return bodyText_;
+}
+
+RBAModelElementType
+RBALambdaExpression::getModelElementType() const
+{
+  return RBAModelElementType::LambdaExpression;
+}
+
+bool
+RBALambdaExpression::executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const
+{
+  getX()->setRuleObj(ruleObj_);
+
+  RBAConstraintInfo* const childInfo {info->getChild(0U)};
+  bool res {getBodyText()->execute(childInfo,arb)};
+  if(childInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+    res = false;
+  }
+
+  return res;
+}
+
+const RBARuleObject*
+RBALambdaExpression::getReferenceObjectCore(RBAConstraintInfo* info,
+                                            RBAArbitrator* arb) const
+{
+  getX()->setRuleObj(ruleObj_);
+
+  RBAConstraintInfo* const childInfo {info->getChild(0U)};
+  const RBARuleObject* const res {getBodyText()->getReferenceObject(childInfo, arb)};
+  if (childInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  }
+
+  return res;
+}
+std::int32_t
+RBALambdaExpression::getValueCore(RBAConstraintInfo* info,
+                                  RBAArbitrator* arb) const
+{
+  getX()->setRuleObj(ruleObj_);
+
+  RBAConstraintInfo* const childInfo {info->getChild(0U)};
+  const std::int32_t res {getBodyText()->getValue(childInfo, arb)};
+  if (childInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  }
+
+  return res;
+}
+#ifdef RBA_USE_LOG
+void
+RBALambdaExpression::createHierarchy()
+{
+  bodyText_->createHierarchy();
+}
+
+const std::string
+RBALambdaExpression::getExpressionText() const
+{
+  return "{ " + getX()->getElementName() + " |"
+    + bodyText_->getExpressionText() + "}";
+}
+
+const std::string
+RBALambdaExpression::getCoverageExpressionText() const
+{
+  return "{ " + getX()->getElementName() + " |" +
+    bodyText_->getCoverageExpressionText() + "}";
+}
+#endif
+
+void
+RBALambdaExpression::setRuleObj(const RBARuleObject* const ruleObj)
+{
+  ruleObj_ = ruleObj;
+  getX()->setRuleObj(ruleObj);
+}
+
+void
+RBALambdaExpression::clearRuleObj()
+{
+  ruleObj_ = nullptr;
+  getX()->clearRuleObj();
+}
+
+}
diff --git a/src/core/expression/RBALambdaExpression.hpp b/src/core/expression/RBALambdaExpression.hpp
new file mode 100644
index 0000000..76958e7
--- /dev/null
+++ b/src/core/expression/RBALambdaExpression.hpp
@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBALambdaExpression class header
+ */
+
+#ifndef RBALAMBDAEXPRESSION_HPP
+#define RBALAMBDAEXPRESSION_HPP
+
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class RBAArbitrator;
+class RBAConstraintInfo;
+class RBAVariable;
+class RBARuleObject;
+
+class DLL_EXPORT RBALambdaExpression : public RBAExpression
+{
+public:
+  RBALambdaExpression()=default;
+  RBALambdaExpression(const RBALambdaExpression&)=delete;
+  RBALambdaExpression(const RBALambdaExpression&&)=delete;
+  RBALambdaExpression& operator=(const RBALambdaExpression&)=delete;
+  RBALambdaExpression& operator=(const RBALambdaExpression&&)=delete;
+  virtual ~RBALambdaExpression()=default;
+
+public:
+  void setX(RBAVariable* const x);
+  void setBodyText(RBAExpression* const expr);
+  RBAVariable* const getX() const;
+  RBAExpression* const getBodyText() const;
+
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info,
+                                    RBAArbitrator* arb) const override;
+
+  void setRuleObj(const RBARuleObject* const ruleObj);
+  void clearRuleObj();
+
+  // Log
+#ifdef RBA_USE_LOG
+  void createHierarchy();
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+
+private:
+  // "variable" is not const because it calls setExpression() 
+  // in the arbitration process.
+  RBAVariable* variable_;
+  RBAExpression* bodyText_ {nullptr};
+  const RBARuleObject* ruleObj_ {nullptr};
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALambdaExpressionMaker.cpp b/src/core/expression/RBALambdaExpressionMaker.cpp
new file mode 100644
index 0000000..674067f
--- /dev/null
+++ b/src/core/expression/RBALambdaExpressionMaker.cpp
@@ -0,0 +1,75 @@
+/**
+ * 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.
+ */
+
+/// @file  RBALambdaExpressionMaker.cpp
+/// @brief LambdaExpression object generation class definition
+
+#include "RBALambdaExpressionMaker.hpp"
+#include "RBALambdaExpression.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBALambdaExpressionMaker::RBALambdaExpressionMaker()
+  : RBAExpressionMaker{"LambdaExpression"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBALambdaExpressionMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBALambdaExpression>();
+}
+
+RBAModelElement*
+RBALambdaExpressionMaker::setProperty(RBAModelElement* element,
+                                      const RBAJsonElement* jsonElem,
+                                      RBAModelImpl* model,
+                                      RBAModelElement* owner)
+{
+  RBALambdaExpression* const lambdaExpr
+    {dynamic_cast<RBALambdaExpression*>(element)};
+
+  // Set LetStatement
+  const std::int32_t pop_num {setLetStatement(model, lambdaExpr, jsonElem)};
+
+  // Set variable
+  const RBAJsonElement* const varElement {jsonElem->findChildren("x")};
+  RBAVariable* const var
+    {dynamic_cast<RBAVariable*>(getFactory()->createElement("Variable",
+                                                         varElement))};
+  lambdaExpr->setX(var);
+  // Set bodyText
+  getFactory()->pushVariable(var);
+  const RBAJsonElement* const body {jsonElem->findChildren("bodyText")};
+  RBAExpression* const expr
+    {dynamic_cast<RBAExpression*>(getFactory()->createElement(body->getClassName(),
+                                                           body))};
+  lambdaExpr->setBodyText(expr);
+
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+  
+  return lambdaExpr;
+}
+
+}
diff --git a/src/core/expression/RBALambdaExpressionMaker.hpp b/src/core/expression/RBALambdaExpressionMaker.hpp
new file mode 100644
index 0000000..04e5f05
--- /dev/null
+++ b/src/core/expression/RBALambdaExpressionMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBALambdaExpressionMaker.hpp
+/// @brief LambdaExpression object generation class header
+
+#ifndef RBALAMBDAEXPRESSIONMAKER_HPP
+#define RBALAMBDAEXPRESSIONMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief LambdaExpression object generation class
+class RBALambdaExpressionMaker : public RBAExpressionMaker
+{
+public:
+  RBALambdaExpressionMaker();
+  RBALambdaExpressionMaker(const RBALambdaExpressionMaker&)=delete;
+  RBALambdaExpressionMaker(const RBALambdaExpressionMaker&&)=delete;
+  RBALambdaExpressionMaker& operator=(const RBALambdaExpressionMaker&)=delete;
+  RBALambdaExpressionMaker& operator=(const RBALambdaExpressionMaker&&)=delete;
+  virtual ~RBALambdaExpressionMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALetStatement.cpp b/src/core/expression/RBALetStatement.cpp
new file mode 100644
index 0000000..f64cc18
--- /dev/null
+++ b/src/core/expression/RBALetStatement.cpp
@@ -0,0 +1,68 @@
+/**
+ * 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.
+ */
+
+/*
+ * LetStatement class definition
+ */
+
+#include "RBALetStatement.hpp"
+#include "RBALogManager.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAVariable.hpp"
+#include "RBAExpressionVisitor.hpp"
+
+namespace rba
+{
+
+RBAModelElementType RBALetStatement::getModelElementType() const
+{
+  return RBAModelElementType::LetStatement;
+}
+
+void RBALetStatement::setVariable(RBAVariable* const var)
+{
+  variable_ = var;
+}
+
+void
+RBALetStatement::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+void RBALetStatement::setVariable(RBAArbitrator* const arb)
+{
+  RBAConstraintInfo* const info {variable_->createConstraintInfo()};
+  variable_->setRuleObj(getLhsOperand()->getReferenceObject(info, arb));
+#ifdef RBA_USE_LOG
+  std::string valueName;
+  if (info->isExceptionBeforeArbitrate() == true) {
+    valueName = "before arbitrate skip";
+  } else if (variable_->getRuleObj() == nullptr) {
+    valueName = "NULL";
+  } else {
+    valueName = variable_->getRuleObj()->getElementName();
+    if (valueName == "") {
+      valueName = variable_->getRuleObj()->getDynamicName();
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      let " + variable_->getElementName() + " = "
+          + getLhsOperand()->getExpressionText() + " = " + valueName);
+#endif
+}
+} /* namespace rba */
diff --git a/src/core/expression/RBALetStatement.hpp b/src/core/expression/RBALetStatement.hpp
new file mode 100644
index 0000000..636b07d
--- /dev/null
+++ b/src/core/expression/RBALetStatement.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+
+/**
+ * LetStatement class header file
+ */
+
+#ifndef RBALETOPERATOR_HPP_
+#define RBALETOPERATOR_HPP_
+
+#include "RBAOperator.hpp"
+
+namespace rba {
+
+class RBAVariable;
+
+class DLL_EXPORT RBALetStatement : public RBAOperator
+{
+public:
+  RBALetStatement()=default;
+  RBALetStatement(const RBALetStatement&)=delete;
+  RBALetStatement(const RBALetStatement&&)=delete;
+  RBALetStatement& operator=(const RBALetStatement&)=delete;
+  RBALetStatement& operator=(const RBALetStatement&&)=delete;
+  virtual ~RBALetStatement()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  void setVariable(RBAVariable* const var);
+  void setVariable(RBAArbitrator* const arb);
+
+private:
+  RBAVariable* variable_;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALetStatementMaker.cpp b/src/core/expression/RBALetStatementMaker.cpp
new file mode 100644
index 0000000..93fcdee
--- /dev/null
+++ b/src/core/expression/RBALetStatementMaker.cpp
@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+/// @file  RBALetStatementMaker.cpp
+/// @brief LetStatement object generation class defintino.
+
+#include "RBALetStatementMaker.hpp"
+#include "RBALetStatement.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBALetStatementMaker::RBALetStatementMaker()
+  : RBAExpressionMaker{"LetStatement"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBALetStatementMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBALetStatement>();
+}
+
+RBAModelElement*
+RBALetStatementMaker::setProperty(RBAModelElement* element,
+                                  const RBAJsonElement* jsonElem,
+                                  RBAModelImpl* model,
+                                  RBAModelElement* owner)
+{
+  RBALetStatement* const letStmt {dynamic_cast<RBALetStatement*>(element)};
+
+  // Set variable
+  const RBAJsonElement* const varElement {jsonElem->findChildren("variable")};
+  RBAVariable* const var
+    {dynamic_cast<RBAVariable*>(getFactory()->createElement("Variable",
+                                                         varElement))};
+  letStmt->setVariable(var); // Set Body
+  
+  // popVariable() is executed by the caller of this function
+  getFactory()->pushVariable(var); 
+  const RBAJsonElement* const body {jsonElem->findChildren("body")};
+  RBAExpression* const expr
+    {dynamic_cast<RBAExpression*>(getFactory()->createElement(body->getClassName(),
+                                                           body))};
+  letStmt->addOperand(expr);
+
+  return letStmt;
+}
+
+}
diff --git a/src/core/expression/RBALetStatementMaker.hpp b/src/core/expression/RBALetStatementMaker.hpp
new file mode 100644
index 0000000..348ca71
--- /dev/null
+++ b/src/core/expression/RBALetStatementMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBALetStatementMaker.hpp
+/// @brief LetStatement object generation class header
+
+#ifndef RBAISACTIVEMAKER_HPP
+#define RBAISACTIVEMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief LetStatement object generation class
+class RBALetStatementMaker : public RBAExpressionMaker
+{
+public:
+  RBALetStatementMaker();
+  RBALetStatementMaker(const RBALetStatementMaker&)=delete;
+  RBALetStatementMaker(const RBALetStatementMaker&&)=delete;
+  RBALetStatementMaker& operator=(const RBALetStatementMaker&)=delete;
+  RBALetStatementMaker& operator=(const RBALetStatementMaker&&)=delete;
+  virtual ~RBALetStatementMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBALogicalOperator.cpp b/src/core/expression/RBALogicalOperator.cpp
new file mode 100644
index 0000000..e931b7a
--- /dev/null
+++ b/src/core/expression/RBALogicalOperator.cpp
@@ -0,0 +1,73 @@
+
+/**
+ * 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.
+ */
+
+/**
+ * 論理オペレータクラス定義ファイル
+ */
+
+#include <sstream>
+#include "RBALogicalOperator.hpp"
+#include "RBAExpressionType.hpp"
+
+namespace rba
+{
+
+#ifdef RBA_USE_LOG
+const std::string
+RBALogicalOperator::getExpressionText() const
+{
+  std::ostringstream oss;
+  oss << "(";
+  const auto& exprList = getOperand();
+  const auto& lastExpr = exprList.back();
+  for (const auto& expr : exprList) {
+    oss << expr->getExpressionText();
+    if (expr != lastExpr) {
+      oss << " " << getSymbol() << " ";
+    }
+  }
+  oss << ")";
+
+  return oss.str();
+}
+
+const std::string
+RBALogicalOperator::getCoverageExpressionText() const
+{
+  std::ostringstream oss;
+  oss << "(";
+  auto exprList = getOperand();
+  auto lastExpr = exprList.back();
+  for (const auto& expr : exprList) {
+    oss << expr->getCoverageExpressionText();
+    if (expr != lastExpr) {
+      oss << " " << getSymbol() << " ";
+    }
+  }
+  oss << ")";
+
+  return oss.str();
+}
+
+RBAExpressionType
+RBALogicalOperator::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBALogicalOperator.hpp b/src/core/expression/RBALogicalOperator.hpp
new file mode 100644
index 0000000..b713f5a
--- /dev/null
+++ b/src/core/expression/RBALogicalOperator.hpp
@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+/**
+ * LogicalOperator class header
+ */
+
+#ifndef RBALOGICOPERATOR_HPP
+#define RBALOGICOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBALogicalOperator : public RBAOperator
+{
+ protected:
+  RBALogicalOperator()=default;
+  RBALogicalOperator(const RBALogicalOperator&)=delete;
+  RBALogicalOperator(const RBALogicalOperator&&)=delete;
+  RBALogicalOperator& operator=(const RBALogicalOperator&)=delete;
+  RBALogicalOperator& operator=(const RBALogicalOperator&&)=delete;
+
+ public:
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAMaxOperator.cpp b/src/core/expression/RBAMaxOperator.cpp
new file mode 100644
index 0000000..46d5ed1
--- /dev/null
+++ b/src/core/expression/RBAMaxOperator.cpp
@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+
+/**
+ * MaxOperator class definition
+ */
+
+#include "RBAMaxOperator.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAContent.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBALogManager.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALambdaExpression.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void
+RBAMaxOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAMaxOperator::getModelElementType() const
+{
+  return RBAModelElementType::MaxOperator;
+}
+
+const RBARuleObject* RBAMaxOperator::getReferenceObjectCore(
+    RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  LOG_addHierarchy(LOG_getSymbol());
+  const RBARuleObject* returnObj {nullptr};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const lhsObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                    arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsObj != nullptr) {
+      const RBAAllocatableSet* alloSet = dynamic_cast<const RBAAllocatableSet*>(lhsObj);
+      if (alloSet != nullptr) {
+        std::uint32_t i { 0U };
+        std::int32_t maxVal { -99 };
+        RBALambdaExpression* const lambda { getLambda() };
+        for (auto& obj : alloSet->getLeafAllocatable()) {
+          LOG_addHierarchy("#" + std::to_string(i));
+          ++i;
+          RBAConstraintInfo* const childInfo { info->getChild(i) };
+          lambda->setRuleObj(obj);
+          const std::int32_t val { lambda->getValue(childInfo, arb) };
+          LOG_removeHierarchy();
+          if ((maxVal < val) && (!childInfo->isExceptionBeforeArbitrate())) {
+            maxVal = val;
+            returnObj = obj;
+          }
+        }
+      } else {
+        const RBAContentSet* contentSet = dynamic_cast<const RBAContentSet*>(lhsObj);
+        if (contentSet != nullptr) {
+          std::uint32_t i { 0U };
+          std::int32_t maxVal { -99 };
+          RBALambdaExpression* const lambda { getLambda() };
+          for (auto& obj : contentSet->getLeafContent()) {
+            LOG_addHierarchy("#" + std::to_string(i));
+            ++i;
+            RBAConstraintInfo* const childInfo { info->getChild(i) };
+            lambda->setRuleObj(obj);
+            const std::int32_t val { lambda->getValue(childInfo, arb) };
+            LOG_removeHierarchy();
+            if ((maxVal < val) && (!childInfo->isExceptionBeforeArbitrate())) {
+              maxVal = val;
+              returnObj = obj;
+            }
+          }
+        }
+      }
+    }
+  }
+#ifdef RBA_USE_LOG
+  std::string objName = "NULL";
+  if (info->isExceptionBeforeArbitrate()) {
+    objName = "before arbitrate skip";
+  } else {
+    if (returnObj != nullptr){
+      objName = returnObj->getElementName();
+      if (objName == "") {
+        objName = returnObj->getDynamicName();
+      }
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      " + LOG_getExpressionText() + " is " + objName);
+#endif
+  LOG_removeHierarchy();
+  return returnObj;
+}
+#ifdef RBA_USE_LOG
+const std::string RBAMaxOperator::getSymbol() const
+{
+  return ".max";
+}
+
+const std::string RBAMaxOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol()
+      + getLambda()->getExpressionText();
+}
+
+const std::string RBAMaxOperator::getCoverageExpressionText() const
+{
+  getLambda()->clearRuleObj();
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol()
+      + getLambda()->getCoverageExpressionText();
+}
+#endif
+
+} // namespace rba
diff --git a/src/core/expression/RBAMaxOperator.hpp b/src/core/expression/RBAMaxOperator.hpp
new file mode 100644
index 0000000..046cec9
--- /dev/null
+++ b/src/core/expression/RBAMaxOperator.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/**
+ * MaxOperator class header
+ */
+
+#ifndef RBAMAXOPERATOR_HPP
+#define RBAMAXOPERATOR_HPP
+
+#include "RBALambdaContext.hpp"
+
+namespace rba
+{
+
+class RBAMaxOperator : public RBALambdaContext
+{
+ public:
+  RBAMaxOperator()=default;
+  RBAMaxOperator(const RBAMaxOperator&)=delete;
+  RBAMaxOperator(const RBAMaxOperator&&)=delete;
+  RBAMaxOperator& operator=(const RBAMaxOperator&)=delete;
+  RBAMaxOperator& operator=(const RBAMaxOperator&&)=delete;
+  virtual ~RBAMaxOperator()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+};
+
+} /* namespace rba */
+
+#endif /* RBAMAXOPERATOR_HPP */
diff --git a/src/core/expression/RBAMaxOperatorMaker.cpp b/src/core/expression/RBAMaxOperatorMaker.cpp
new file mode 100644
index 0000000..298bbbf
--- /dev/null
+++ b/src/core/expression/RBAMaxOperatorMaker.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAMaxOperatorMaker.cpp
+/// @brief MaxOperator object generation class definition
+
+#include "RBAMaxOperatorMaker.hpp"
+#include "RBAMaxOperator.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBAMaxOperatorMaker::RBAMaxOperatorMaker()
+  : RBALambdaContextMaker{"MaxOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAMaxOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAMaxOperator>();
+}
+
+RBAModelElement*
+RBAMaxOperatorMaker::setProperty(RBAModelElement* element,
+                                 const RBAJsonElement* jsonElem,
+                                 RBAModelImpl* model,
+                                 RBAModelElement* owner)
+{
+  static_cast<void>(
+      RBALambdaContextMaker::setProperty(element, jsonElem, model, owner));
+
+  return element;
+}
+
+std::unique_ptr<RBALambdaContext>
+RBAMaxOperatorMaker::createLambdaContext()
+{
+  return std::make_unique<RBAMaxOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAMaxOperatorMaker.hpp b/src/core/expression/RBAMaxOperatorMaker.hpp
new file mode 100644
index 0000000..1216674
--- /dev/null
+++ b/src/core/expression/RBAMaxOperatorMaker.hpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAMaxOperatorMaker.hpp
+/// @brief MaxOperator object generation class header
+
+#ifndef RBAMAXOPERATORMAKER_HPP
+#define RBAMAXOPERATORMAKER_HPP
+
+#include "RBALambdaContextMaker.hpp"
+
+namespace rba
+{
+
+/// @brief MaxOperator object generation class
+class RBAMaxOperatorMaker : public RBALambdaContextMaker
+{
+public:
+  RBAMaxOperatorMaker();
+  RBAMaxOperatorMaker(const RBAMaxOperatorMaker&)=delete;
+  RBAMaxOperatorMaker(const RBAMaxOperatorMaker&&)=delete;
+  RBAMaxOperatorMaker& operator=(const RBAMaxOperatorMaker&)=delete;
+  RBAMaxOperatorMaker& operator=(const RBAMaxOperatorMaker&&)=delete;
+  virtual ~RBAMaxOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+
+  /// @brief generate an empty object of LambdaContext
+  /// @details generate an empty object of unique_ptr
+  /// @return unique_ptr for object of LambdaContext
+  std::unique_ptr<RBALambdaContext> createLambdaContext() override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAMemberFeatureReferenceMaker.cpp b/src/core/expression/RBAMemberFeatureReferenceMaker.cpp
new file mode 100644
index 0000000..699bca0
--- /dev/null
+++ b/src/core/expression/RBAMemberFeatureReferenceMaker.cpp
@@ -0,0 +1,94 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAMemberFeatureReferenceMaker.cpp
+/// @brief ObjectReference of property object generator class definition
+
+#include "RBAMemberFeatureReferenceMaker.hpp"
+#include "RBAObjectReference.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAAbstractProperty.hpp"
+
+namespace rba
+{
+
+RBAMemberFeatureReferenceMaker::RBAMemberFeatureReferenceMaker()
+  : RBAObjectReferenceMaker{"MemberFeatureReference"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAMemberFeatureReferenceMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAObjectReference>();
+}
+
+RBAModelElement*
+RBAMemberFeatureReferenceMaker::setProperty(RBAModelElement* element,
+                                            const RBAJsonElement* jsonElem,
+                                            RBAModelImpl* model,
+                                            RBAModelElement* owner)
+{
+  RBAObjectReference* const objRef {dynamic_cast<RBAObjectReference*>(element)};
+
+  // Set reference object
+  objRef->setRefObject(getRuleObject(jsonElem,model));
+
+  return objRef;
+}
+
+const RBARuleObject*
+RBAMemberFeatureReferenceMaker::getRuleObject(const RBAJsonElement* 
+                                              const jsonElem,
+                                              RBAModelImpl* const model)
+{
+  const RBARuleObject* refObj {nullptr};
+  const auto typeStr = jsonElem->findChildren("type")->getString();
+  const auto refObjStr = jsonElem->findChildren("refObject")->getString();
+
+  if (jsonElem->findChildren("class")->getString() == "ObjectReference") {
+    refObj = dynamic_cast<RBARuleObject*>(getMaker(typeStr)->getInstance(model,
+                                          refObjStr));
+  } else {  // jsonElem->findChildren("class")->getString() == "MemberFeatureReference"
+    // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+    // [Contents that deviate from the rules]
+    //  calling getRuleObject() recursively
+    // [Explain that it is okay to deviate from the rules]
+    //  When "Content name.State machine name.State name" is used
+    //  in the constraint expression, it becomes the STATEMACHINE_STATE of
+    //  Member of "STATEMACHINE" of "CONTENT", so recursive call is used.
+    //  Since the number of elements in the rule model is finite and
+    //  there is no cyclic relationship, stack overflow does not occur and 
+    //  there is no problem.
+    const auto owner = const_cast<RBARuleObject*>(getRuleObject(jsonElem->findChildren("operand")->getChild(), model));
+    refObj = owner->getMember(refObjStr);
+    if (refObj == nullptr) {
+      if (getMaker(typeStr) != nullptr) {
+        refObj = dynamic_cast<RBARuleObject*>(getMaker(typeStr)->getInstance(model, 
+                                              refObjStr, owner));
+      }
+      if ((refObj == nullptr)
+          && (jsonElem->findChildren("type")->getString() == "PROPERTY")) {
+        refObj = dynamic_cast<RBASceneImpl*>(owner)->addProperty(refObjStr, -99);
+      }
+    }
+  }
+  return refObj;
+}
+}
diff --git a/src/core/expression/RBAMemberFeatureReferenceMaker.hpp b/src/core/expression/RBAMemberFeatureReferenceMaker.hpp
new file mode 100644
index 0000000..61880a7
--- /dev/null
+++ b/src/core/expression/RBAMemberFeatureReferenceMaker.hpp
@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAMemberFeatureReferenceMaker.cpp
+/// @brief ObjectReference of property object generator class header
+
+#ifndef RBAMEMBERFEATUREREFERENCEMAKER_HPP
+#define RBAMEMBERFEATUREREFERENCEMAKER_HPP
+
+#include "RBAObjectReferenceMaker.hpp"
+
+namespace rba
+{
+
+class RBARuleObject;
+
+/// @brief ObjectReference of property object generator class
+class RBAMemberFeatureReferenceMaker : public RBAObjectReferenceMaker
+{
+public:
+  RBAMemberFeatureReferenceMaker();
+  RBAMemberFeatureReferenceMaker(const RBAMemberFeatureReferenceMaker&)=delete;
+  RBAMemberFeatureReferenceMaker(const RBAMemberFeatureReferenceMaker&&)=delete;
+  RBAMemberFeatureReferenceMaker& operator=(const RBAMemberFeatureReferenceMaker&)=delete;
+  RBAMemberFeatureReferenceMaker& operator=(const RBAMemberFeatureReferenceMaker&&)=delete;
+  virtual ~RBAMemberFeatureReferenceMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+private:
+  const RBARuleObject* getRuleObject(const RBAJsonElement* const jsonElem,
+                                     RBAModelImpl* const model);
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAMinOperator.cpp b/src/core/expression/RBAMinOperator.cpp
new file mode 100644
index 0000000..923088b
--- /dev/null
+++ b/src/core/expression/RBAMinOperator.cpp
@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+
+/// MinOperator class definition
+
+#include "RBAMinOperator.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAContent.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALambdaExpression.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void
+RBAMinOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAMinOperator::getModelElementType() const
+{
+  return RBAModelElementType::MinOperator;
+}
+
+const RBARuleObject* RBAMinOperator::getReferenceObjectCore(
+    RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  LOG_addHierarchy(LOG_getSymbol());
+  const RBARuleObject* returnObj {nullptr};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const lhsObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                    arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (lhsObj != nullptr) {
+      const RBAAllocatableSet* alloSet = dynamic_cast<const RBAAllocatableSet*>(lhsObj);
+      if (alloSet != nullptr) {
+        std::uint32_t i { 0U };
+        std::int32_t minVal { INT32_MAX };
+        RBALambdaExpression* const lambda { getLambda() };
+        for (auto& obj : alloSet->getLeafAllocatable()) {
+          LOG_addHierarchy("#" + std::to_string(i));
+          ++i;
+          RBAConstraintInfo* const childInfo { info->getChild(i) };
+          lambda->setRuleObj(obj);
+          const std::int32_t val { lambda->getValue(childInfo, arb) };
+          LOG_removeHierarchy();
+          if ((val != -99) && (minVal > val)
+              && (!childInfo->isExceptionBeforeArbitrate())) {
+            minVal = val;
+            returnObj = obj;
+          }
+        }
+      } else {
+        const RBAContentSet* contentSet = dynamic_cast<const RBAContentSet*>(lhsObj);
+        if (contentSet != nullptr) {
+          std::uint32_t i { 0U };
+          std::int32_t minVal { INT32_MAX };
+          RBALambdaExpression* const lambda { getLambda() };
+          for (auto& obj : contentSet->getLeafContent()) {
+            LOG_addHierarchy("#" + std::to_string(i));
+            ++i;
+            RBAConstraintInfo* const childInfo { info->getChild(i) };
+            lambda->setRuleObj(obj);
+            const std::int32_t val { lambda->getValue(childInfo, arb) };
+            LOG_removeHierarchy();
+            if ((val != -99) && (minVal > val)
+                && (!childInfo->isExceptionBeforeArbitrate())) {
+              minVal = val;
+              returnObj = obj;
+            }
+          }
+        }
+      }
+    }
+  }
+#ifdef RBA_USE_LOG
+  std::string objName = "NULL";
+  if (info->isExceptionBeforeArbitrate()) {
+    objName = "before arbitrate skip";
+  } else {
+    if (returnObj != nullptr){
+      objName = returnObj->getElementName();
+      if (objName == "") {
+        objName = returnObj->getDynamicName();
+      }
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      " + LOG_getExpressionText() + " is " + objName);
+#endif
+  LOG_removeHierarchy();
+  return returnObj;
+}
+#ifdef RBA_USE_LOG
+const std::string RBAMinOperator::getSymbol() const
+{
+  return ".mix";
+}
+
+const std::string RBAMinOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol()
+      + getLambda()->getExpressionText();
+}
+
+const std::string RBAMinOperator::getCoverageExpressionText() const
+{
+  getLambda()->clearRuleObj();
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol()
+      + getLambda()->getCoverageExpressionText();
+}
+#endif
+
+} // namespace rba
diff --git a/src/core/expression/RBAMinOperator.hpp b/src/core/expression/RBAMinOperator.hpp
new file mode 100644
index 0000000..b128877
--- /dev/null
+++ b/src/core/expression/RBAMinOperator.hpp
@@ -0,0 +1,51 @@
+/**
+ * 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.
+ */
+
+/// MinOperator class header
+
+#ifndef RBAMINOPERATOR_HPP
+#define RBAMINOPERATOR_HPP
+
+#include "RBALambdaContext.hpp"
+
+namespace rba
+{
+
+class RBAMinOperator : public RBALambdaContext
+{
+ public:
+  RBAMinOperator()=default;
+  RBAMinOperator(const RBAMinOperator&)=delete;
+  RBAMinOperator(RBAMinOperator&&)=delete;
+  RBAMinOperator& operator=(const RBAMinOperator&)=delete;
+  RBAMinOperator& operator=(RBAMinOperator&&)=delete;
+  virtual ~RBAMinOperator()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+};
+
+} // namespace rba
+
+#endif // RBAMINOPERATOR_HPP
diff --git a/src/core/expression/RBAMinOperatorMaker.cpp b/src/core/expression/RBAMinOperatorMaker.cpp
new file mode 100644
index 0000000..060e552
--- /dev/null
+++ b/src/core/expression/RBAMinOperatorMaker.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAMinOperatorMaker.cpp
+/// @brief MinOperator object generator class definition
+
+#include "RBAMinOperatorMaker.hpp"
+#include "RBAMinOperator.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBAMinOperatorMaker::RBAMinOperatorMaker()
+  : RBALambdaContextMaker{"MinOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAMinOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAMinOperator>();
+}
+
+RBAModelElement*
+RBAMinOperatorMaker::setProperty(RBAModelElement* element,
+                                 const RBAJsonElement* jsonElem,
+                                 RBAModelImpl* model,
+                                 RBAModelElement* owner)
+{
+  static_cast<void>(
+      RBALambdaContextMaker::setProperty(element, jsonElem, model, owner));
+
+  return element;
+}
+
+std::unique_ptr<RBALambdaContext>
+RBAMinOperatorMaker::createLambdaContext()
+{
+  return std::make_unique<RBAMinOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAMinOperatorMaker.hpp b/src/core/expression/RBAMinOperatorMaker.hpp
new file mode 100644
index 0000000..6eb90e1
--- /dev/null
+++ b/src/core/expression/RBAMinOperatorMaker.hpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAMinOperatorMaker.hpp
+/// @brief MinOperator object generator class header
+
+#ifndef RBAMINOPERATORMAKER_HPP
+#define RBAMINOPERATORMAKER_HPP
+
+#include "RBALambdaContextMaker.hpp"
+
+namespace rba
+{
+
+/// @brief MinOperator object generator class
+class RBAMinOperatorMaker : public RBALambdaContextMaker
+{
+public:
+  RBAMinOperatorMaker();
+  RBAMinOperatorMaker(const RBAMinOperatorMaker&)=delete;
+  RBAMinOperatorMaker(const RBAMinOperatorMaker&&)=delete;
+  RBAMinOperatorMaker& operator=(const RBAMinOperatorMaker&)=delete;
+  RBAMinOperatorMaker& operator=(const RBAMinOperatorMaker&&)=delete;
+  virtual ~RBAMinOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+
+  /// @brief generate an empty object of LambdaContext
+  /// @details generate an empty object of unique_ptr
+  /// @return unique_ptr for object of LambdaContext
+  std::unique_ptr<RBALambdaContext> createLambdaContext() override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBANotOperator.cpp b/src/core/expression/RBANotOperator.cpp
new file mode 100644
index 0000000..afcf3c8
--- /dev/null
+++ b/src/core/expression/RBANotOperator.cpp
@@ -0,0 +1,99 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBANotOperator class definition
+ */
+
+#include "RBANotOperator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBANotOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBANotOperator::getModelElementType() const
+{
+  return RBAModelElementType::NotOperator;
+}
+
+bool
+RBANotOperator::executeCore(RBAConstraintInfo* info,
+                            RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const childInfo {info->getChild(0U)};
+  const bool isChildPassed {getLhsOperand()->execute(childInfo, arb)};
+  if (childInfo->isExceptionBeforeArbitrate() == true) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    isPassed = !isChildPassed;
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBANotOperator::getSymbol() const
+{
+  return "!";
+}
+
+const std::string
+RBANotOperator::getExpressionText() const
+{
+  return getSymbol() + getLhsOperand()->getExpressionText();
+}
+
+const std::string
+RBANotOperator::getCoverageExpressionText() const
+{
+  return getSymbol() + getLhsOperand()->getCoverageExpressionText();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBANotOperator.hpp b/src/core/expression/RBANotOperator.hpp
new file mode 100644
index 0000000..4af1461
--- /dev/null
+++ b/src/core/expression/RBANotOperator.hpp
@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBANotOperator class header
+ */
+
+#ifndef RBANOTOPERATOR_HPP
+#define RBANOTOPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBANotOperator : public RBALogicalOperator
+{
+public:
+  RBANotOperator()=default;
+  RBANotOperator(const RBANotOperator&)=delete;
+  RBANotOperator(const RBANotOperator&&)=delete;
+  RBANotOperator& operator=(const RBANotOperator&)=delete;
+  RBANotOperator& operator=(const RBANotOperator&&)=delete;
+  virtual ~RBANotOperator()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBANotOperatorMaker.cpp b/src/core/expression/RBANotOperatorMaker.cpp
new file mode 100644
index 0000000..e4e823c
--- /dev/null
+++ b/src/core/expression/RBANotOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBANotOperatorMaker.cpp
+/// @brief NotOperator object generator class definition
+
+#include "RBANotOperatorMaker.hpp"
+#include "RBANotOperator.hpp"
+
+namespace rba
+{
+
+RBANotOperatorMaker::RBANotOperatorMaker()
+  : RBAOperatorMaker{"NotOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBANotOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBANotOperator>();
+}
+
+}
diff --git a/src/core/expression/RBANotOperatorMaker.hpp b/src/core/expression/RBANotOperatorMaker.hpp
new file mode 100644
index 0000000..91f39b9
--- /dev/null
+++ b/src/core/expression/RBANotOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBANotOperatorMaker.hpp
+/// @brief NotOperator object generator class header
+
+#ifndef RBANOTOPERATORMAKER_HPP
+#define RBANOTOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief NotOperator object generator class header
+class RBANotOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBANotOperatorMaker();
+  RBANotOperatorMaker(const RBANotOperatorMaker&)=delete;
+  RBANotOperatorMaker(const RBANotOperatorMaker&&)=delete;
+  RBANotOperatorMaker& operator=(const RBANotOperatorMaker&)=delete;
+  RBANotOperatorMaker& operator=(const RBANotOperatorMaker&&)=delete;
+  virtual ~RBANotOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAObjectCompare.cpp b/src/core/expression/RBAObjectCompare.cpp
new file mode 100644
index 0000000..65bee04
--- /dev/null
+++ b/src/core/expression/RBAObjectCompare.cpp
@@ -0,0 +1,165 @@
+/**
+ * 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.
+ */
+
+/**
+ * ObjectCompare calss defintion
+ */
+
+#include "RBAObjectCompare.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAExpressionType.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+
+namespace rba
+{
+
+void
+RBAObjectCompare::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAObjectCompare::getModelElementType() const
+{
+  return RBAModelElementType::ObjectCompare;
+}
+
+bool
+RBAObjectCompare::executeCore(RBAConstraintInfo* info,
+                              RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBAExpression* const lhs {getLhsOperand()};
+  // Add left hand side expression to Constraint hierarchy for coverage
+  LOG_addHierarchy("#left");
+  const RBARuleObject* const lhobj {lhs->getReferenceObject(leftInfo, arb)};
+  // Remove left hand side expression from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  // Throw if one of the pre-arbitration exceptions appears in the reference
+  if (leftInfo->isExceptionBeforeArbitrate() == true) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    RBAConstraintInfo* const rightInfo {info->getChild(1U)};
+    const RBAExpression* const rhs {getRhsOperand()};
+    // Add right hand side expression to Constraint hierarchy for coverage
+    LOG_addHierarchy("#right");
+    const RBARuleObject* const rhobj {rhs->getReferenceObject(rightInfo, arb)};
+    // Remove right hand side expression to Constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    // Throw if one of the pre-arbitration exceptions appears in the reference
+    if (rightInfo->isExceptionBeforeArbitrate()) {
+      info->setExceptionBeforeArbitrate(true);
+    } else {
+      // False if both objects cannot be got
+      if ((lhobj != nullptr) && (rhobj != nullptr)) {
+        if (lhobj->getRawObject() == rhobj->getRawObject()) {
+          isPassed = true;
+　　　　　　　　　　// Even if re-arbitration is performed for "ObjectCompare" that uses 
+          // "ObjectRefrence" as an operand, the evaluation result does not  
+          // change from false to True, so it is not necessary to add  
+          // "FalseAllocatable" or "TrueAllocatabe" for re-arbitration.
+          // When "Expression" such as "AllocatedContent" is used as an operand,
+          // "FalseAllocatable" and "TrueAllocatabe" are added in the operand,
+          // so it is not necessary to add in ObjectCompare.
+        }
+      }
+    }
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAObjectCompare::getSymbol() const
+{
+  return "==";
+}
+
+const std::string
+RBAObjectCompare::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText()
+    + " " + getSymbol() + " " + getRhsOperand()->getExpressionText();
+}
+
+const std::string
+RBAObjectCompare::getCoverageExpressionText() const
+{
+  return getLhsOperand()->getCoverageExpressionText()
+    + " " + getSymbol() + " " + getRhsOperand()->getCoverageExpressionText();
+}
+
+void
+RBAObjectCompare::createHierarchy()
+{
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(getSymbol());
+  RBALogManager::coverageHierarchyOfConstraintExpressionLog(getCoverageExpressionText(), this);
+
+  RBAExpression*  expr0 = getLhsOperand();
+  RBAExpression*  expr1 = getRhsOperand();
+
+  // Add left hand side expression to Constraint hierarchy for coverage
+  LOG_addHierarchy("#left");
+  expr0->createHierarchy();
+  // Remove left hand side expression from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  // Add right hand side expression to Constraint hierarchy for coverage
+  LOG_addHierarchy("#right");
+  expr1->createHierarchy();
+  // Remove right hand side expression from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+}
+
+RBAExpressionType
+RBAObjectCompare::getUnderlyingType() const
+{
+  return RBAExpressionType::BOOLEAN;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAObjectCompare.hpp b/src/core/expression/RBAObjectCompare.hpp
new file mode 100644
index 0000000..c7c345d
--- /dev/null
+++ b/src/core/expression/RBAObjectCompare.hpp
@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+/**
+ * ObjectCompare calss header
+ */
+
+#ifndef RBAOBJECTCOMPARE_HPP
+#define RBAOBJECTCOMPARE_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAObjectCompare : public RBAOperator
+{
+public:
+  RBAObjectCompare()=default;
+  RBAObjectCompare(const RBAObjectCompare&)=delete;
+  RBAObjectCompare(const RBAObjectCompare&&)=delete;
+  RBAObjectCompare& operator=(const RBAObjectCompare&)=delete;
+  RBAObjectCompare& operator=(const RBAObjectCompare&&)=delete;
+  virtual ~RBAObjectCompare()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  void createHierarchy() override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAObjectCompareMaker.cpp b/src/core/expression/RBAObjectCompareMaker.cpp
new file mode 100644
index 0000000..ab696cf
--- /dev/null
+++ b/src/core/expression/RBAObjectCompareMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAObjectCompareMaker.cpp
+/// @brief ObjectCompare object generator class
+
+#include "RBAObjectCompareMaker.hpp"
+#include "RBAObjectCompare.hpp"
+
+namespace rba
+{
+
+RBAObjectCompareMaker::RBAObjectCompareMaker()
+  : RBAOperatorMaker{"ObjectCompare"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAObjectCompareMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAObjectCompare>();
+}
+
+}
diff --git a/src/core/expression/RBAObjectCompareMaker.hpp b/src/core/expression/RBAObjectCompareMaker.hpp
new file mode 100644
index 0000000..3d44a4e
--- /dev/null
+++ b/src/core/expression/RBAObjectCompareMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAObjectCompareMaker.hpp
+/// @brief ObjectCompare object generator class header
+
+#ifndef RBAOBJECTCOMPAREMAKER_HPP
+#define RBAOBJECTCOMPAREMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ObjectCompare object generator class
+class RBAObjectCompareMaker : public RBAOperatorMaker
+{
+public:
+  RBAObjectCompareMaker();
+  RBAObjectCompareMaker(const RBAObjectCompareMaker&)=delete;
+  RBAObjectCompareMaker(const RBAObjectCompareMaker&&)=delete;
+  RBAObjectCompareMaker& operator=(const RBAObjectCompareMaker&)=delete;
+  RBAObjectCompareMaker& operator=(const RBAObjectCompareMaker&&)=delete;
+  virtual ~RBAObjectCompareMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAObjectReference.cpp b/src/core/expression/RBAObjectReference.cpp
new file mode 100644
index 0000000..aefe83c
--- /dev/null
+++ b/src/core/expression/RBAObjectReference.cpp
@@ -0,0 +1,133 @@
+/**
+ * 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.
+ */
+
+/// ObjectReference class definition
+
+#include "RBAObjectReference.hpp"
+
+#include "RBAExpressionVisitor.hpp"
+#include "RBAVariable.hpp"
+#include "RBAModelElementType.hpp"
+#ifdef RBA_USE_LOG
+#include "RBAAbstractProperty.hpp"
+#include "RBASceneImpl.hpp"
+#endif
+
+namespace rba
+{
+
+void
+RBAObjectReference::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAObjectReference::getModelElementType() const
+{
+  return RBAModelElementType::ObjectReference;
+}
+
+const RBARuleObject*
+RBAObjectReference::getReferenceObjectCore(RBAConstraintInfo* info,
+                                           RBAArbitrator* arb) const
+{
+  const RBARuleObject* obj {refObject_};
+  if (obj->isModelElementType(RBAModelElementType::Variable)) {
+    // in case of varible, its reference
+    const RBAVariable* const val {dynamic_cast<const RBAVariable*>(obj)};
+    obj = val->getRuleObj();
+    std::shared_ptr<RBAConstraintInfo> valInfo {val->getConstraintInfo()};
+    if (valInfo != nullptr) {
+      info->setChild(valInfo);
+      if (valInfo->isExceptionBeforeArbitrate()) {
+        info->setExceptionBeforeArbitrate(true);
+      }
+    }
+  }
+  return obj;
+}
+
+void
+RBAObjectReference::setRefObject(const RBARuleObject* const newRefObject)
+{
+  refObject_ = newRefObject;
+}
+
+#ifdef RBA_USE_LOG
+
+void
+RBAObjectReference::setExpressionType(RBAExpressionType const newExprType)
+{
+  expressionType_ = newExprType;
+}
+
+void
+RBAObjectReference::createHierarchy()
+{
+  // No operation, because this does not affect the structure
+}
+
+const std::string
+RBAObjectReference::getExpressionText() const
+{
+  if (refObject_->isModelElementType(RBAModelElementType::Property)) {
+    return dynamic_cast<const RBAAbstractProperty*>(refObject_)->getScene()->getElementName();
+  }
+  else if ((refObject_->isModelElementType(RBAModelElementType::ViewContentState)) ||
+           (refObject_->isModelElementType(RBAModelElementType::SoundContentState))) {
+    return (refObject_->getOwner()->getElementName() + "." + refObject_->getElementName());
+  }
+  if(refObject_->getElementName() != ""){
+    return refObject_->getElementName();
+  } else {
+    return refObject_->getDynamicName();
+  }
+}
+
+const std::string
+RBAObjectReference::getCoverageExpressionText() const
+{
+  if (refObject_->isModelElementType(RBAModelElementType::Variable)) {
+    const RBAVariable* var =
+        dynamic_cast<const RBAVariable*>(refObject_);
+    if (var->getRuleObj()) {
+      if (var->getRuleObj()->getElementName() != "") {
+        return var->getRuleObj()->getElementName();
+      } else {
+        return var->getRuleObj()->getDynamicName();
+      }
+    }
+  }
+  if ((refObject_->isModelElementType(RBAModelElementType::ViewContentState)) ||
+      (refObject_->isModelElementType(RBAModelElementType::SoundContentState))) {
+    return (refObject_->getOwner()->getElementName() + "." + refObject_->getElementName());
+  }
+  if(refObject_->getElementName() != ""){
+    return refObject_->getElementName();
+  } else {
+    return refObject_->getDynamicName();
+  }
+}
+
+RBAExpressionType
+RBAObjectReference::getUnderlyingType() const
+{
+  return expressionType_;
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAObjectReference.hpp b/src/core/expression/RBAObjectReference.hpp
new file mode 100644
index 0000000..2eb38df
--- /dev/null
+++ b/src/core/expression/RBAObjectReference.hpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// ObjectReference class header
+
+#ifndef RBAOBJECTREFERENCE_HPP
+#define RBAOBJECTREFERENCE_HPP
+
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAObjectReference : public RBAExpression
+{
+public:
+  RBAObjectReference()=default;
+  RBAObjectReference(const RBAObjectReference&)=delete;
+  RBAObjectReference(const RBAObjectReference&&)=delete;
+  RBAObjectReference& operator=(const RBAObjectReference&)=delete;
+  RBAObjectReference& operator=(const RBAObjectReference&&)=delete;
+  virtual ~RBAObjectReference()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                                      RBAArbitrator* arb) const override;
+  void setRefObject(const RBARuleObject* const newRefObject);
+
+  // Log
+#ifdef RBA_USE_LOG
+  void setExpressionType(RBAExpressionType const newExprType);
+  void createHierarchy() override;
+  const std::string getExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+
+private:
+  const RBARuleObject* refObject_;
+#ifdef RBA_USE_LOG
+  RBAExpressionType expressionType_;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAObjectReferenceMaker.cpp b/src/core/expression/RBAObjectReferenceMaker.cpp
new file mode 100644
index 0000000..8c216ba
--- /dev/null
+++ b/src/core/expression/RBAObjectReferenceMaker.cpp
@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAObjectReferenceMaker.cpp
+/// @brief ObjectReference object generator class definition
+
+#include "RBAObjectReferenceMaker.hpp"
+#include "RBAObjectReference.hpp"
+
+#include "RBAJsonElement.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAModelImpl.hpp"
+
+namespace rba
+{
+
+RBAObjectReferenceMaker::RBAObjectReferenceMaker(const std::string& label)
+  : RBAExpressionMaker{label}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAObjectReferenceMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAObjectReference>();
+}
+
+RBAModelElement*
+RBAObjectReferenceMaker::setProperty(RBAModelElement* element,
+                                     const RBAJsonElement* jsonElem,
+                                     RBAModelImpl* model,
+                                     RBAModelElement* owner)
+{
+  RBAObjectReference* const objRef {dynamic_cast<RBAObjectReference*>(element)};
+
+  // Set reference object
+  //// Getting reference object string
+  const auto& refObjectStr = jsonElem->findChildren("refObject")->getString();
+
+  //// Find object
+  auto ruleObj = model->findModelElement(refObjectStr);
+
+  if(ruleObj == nullptr) {
+    ruleObj = getFactory()->getVariable(refObjectStr);
+    if(ruleObj == nullptr) {
+      const auto& typeStr = jsonElem->findChildren("type")->getString();
+      auto maker = getMaker(typeStr);
+      if (maker != nullptr) {
+        ruleObj = maker->getInstance(model, refObjectStr, owner);
+      }
+    }
+  }
+  objRef->setRefObject(dynamic_cast<const RBARuleObject*>(ruleObj));
+
+#ifdef RBA_USE_LOG
+  // Set expression type
+  const RBAExpressionType exprType {jsonElem->getExpressionType()};
+  objRef->setExpressionType(exprType);
+#endif
+
+  return objRef;
+}
+
+}
diff --git a/src/core/expression/RBAObjectReferenceMaker.hpp b/src/core/expression/RBAObjectReferenceMaker.hpp
new file mode 100644
index 0000000..ee58b92
--- /dev/null
+++ b/src/core/expression/RBAObjectReferenceMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAObjectReferenceMaker.hpp
+/// @brief ObjectReference object generator class header
+
+#ifndef RBAOBJECTREFERENCEMAKER_HPP
+#define RBAOBJECTREFERENCEMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ObjectReference object generator class header
+class DLL_EXPORT RBAObjectReferenceMaker : public RBAExpressionMaker
+{
+public:
+  explicit RBAObjectReferenceMaker(const std::string& label="ObjectReference");
+  RBAObjectReferenceMaker(const RBAObjectReferenceMaker&)=delete;
+  RBAObjectReferenceMaker(const RBAObjectReferenceMaker&&)=delete;
+  RBAObjectReferenceMaker& operator=(const RBAObjectReferenceMaker&)=delete;
+  RBAObjectReferenceMaker& operator=(const RBAObjectReferenceMaker&&)=delete;
+  virtual ~RBAObjectReferenceMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+  
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAOperator.cpp b/src/core/expression/RBAOperator.cpp
new file mode 100644
index 0000000..7d73f66
--- /dev/null
+++ b/src/core/expression/RBAOperator.cpp
@@ -0,0 +1,99 @@
+/**
+ * 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.
+ */
+
+/**
+ * Operator class definition
+ */
+
+#include "RBAOperator.hpp"
+#include "RBALogManager.hpp"
+
+namespace rba
+{
+
+const std::vector<RBAExpression*>&
+RBAOperator::getOperand() const
+{
+  return operand_;
+}
+
+void
+RBAOperator::addOperand(RBAExpression* const newExpr)
+{
+  if(newExpr != nullptr) {
+    operand_.push_back(newExpr);
+  }
+}
+
+RBAExpression*
+RBAOperator::getLhsOperand() const
+{
+  return operand_.front();
+}
+
+RBAExpression*
+RBAOperator::getRhsOperand() const
+{
+  return operand_.back();
+}
+
+const std::string
+RBAOperator::getPreMsg(const bool isPrevious) const
+{
+  if(isPrevious) {
+    return "(pre)";
+  }
+  else {
+    return "";
+  }
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAOperator::getSymbol() const
+{
+  return "";
+}
+
+void
+RBAOperator::createHierarchy()
+{
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(getSymbol());
+  RBALogManager::coverageHierarchyOfConstraintExpressionLog(getCoverageExpressionText(), this);
+
+  std::uint32_t oprSize{ static_cast<std::uint32_t>(getOperand().size()) };
+  if(oprSize == 1U) {
+    RBAExpression* expr = getLhsOperand();
+      expr->createHierarchy();
+  }
+  else {
+    std::uint32_t num{ 0U };
+    for(RBAExpression* expr : getOperand()) {
+      // Add count to Constraint hierarchy for coverage
+      LOG_addHierarchy("#" + std::to_string(num++));
+      expr->createHierarchy();
+      // Remove count from Constraint hierarchy for coverage
+      LOG_removeHierarchy();
+    }
+  }
+
+  // Remove count from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAOperator.hpp b/src/core/expression/RBAOperator.hpp
new file mode 100644
index 0000000..5d645f2
--- /dev/null
+++ b/src/core/expression/RBAOperator.hpp
@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+/**
+ * Operator class header
+ */
+
+#ifndef RBAOPERATOR_HPP
+#define RBAOPERATOR_HPP
+
+#include <vector>
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAOperator : public RBAExpression
+{
+protected:
+  RBAOperator()=default;
+  RBAOperator(const RBAOperator&)=delete;
+  RBAOperator(const RBAOperator&&)=delete;
+  RBAOperator& operator=(const RBAOperator&)=delete;
+  RBAOperator& operator=(const RBAOperator&&)=delete;
+
+public:
+  const std::vector<RBAExpression*>& getOperand() const;
+  void addOperand(RBAExpression* const newExpr);
+  RBAExpression* getLhsOperand() const;
+  RBAExpression* getRhsOperand() const;
+
+  // Log
+#ifdef RBA_USE_LOG
+  virtual const std::string getSymbol() const;
+  void createHierarchy() override;
+#endif
+
+protected:
+  std::string const getPreMsg(const bool isPrevious) const;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::vector<RBAExpression*> operand_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAOperatorMaker.cpp b/src/core/expression/RBAOperatorMaker.cpp
new file mode 100644
index 0000000..7da2885
--- /dev/null
+++ b/src/core/expression/RBAOperatorMaker.cpp
@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAOperatorMaker.cpp
+/// @brief Operator object generator abstract class
+
+#include "RBAOperatorMaker.hpp"
+#include "RBAOperator.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAOperatorMaker::RBAOperatorMaker(const std::string& label)
+  : RBAExpressionMaker{label}
+{
+}
+
+RBAModelElement*
+RBAOperatorMaker::setProperty(RBAModelElement* element,
+                              const RBAJsonElement* jsonElem,
+                              RBAModelImpl* model,
+                              RBAModelElement* owner)
+{
+  // Create expression
+  RBAOperator* const exprOpr {dynamic_cast<RBAOperator*>(element)};
+
+  // Set LetStatement
+  const auto pop_num = setLetStatement(model, exprOpr, jsonElem);
+
+  // Set operand
+  for(auto& param : jsonElem->findChildren("operand")->getChildren()) {
+    const auto expr = getFactory()->createElement(param->getClassName(), param.get());
+    exprOpr->addOperand(dynamic_cast<RBAExpression*>(expr));
+  }
+
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+
+  return exprOpr;
+}
+
+}
diff --git a/src/core/expression/RBAOperatorMaker.hpp b/src/core/expression/RBAOperatorMaker.hpp
new file mode 100644
index 0000000..681ff65
--- /dev/null
+++ b/src/core/expression/RBAOperatorMaker.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAOperatorMaker.hpp
+/// @brief Operator object generator abstract class header
+
+#ifndef RBAOPERATORMAKER_HPP
+#define RBAOPERATORMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Operator object generator abstract class
+class DLL_EXPORT RBAOperatorMaker : public RBAExpressionMaker
+{
+public:
+  explicit RBAOperatorMaker(const std::string& label="");
+  RBAOperatorMaker(const RBAOperatorMaker&)=delete;
+  RBAOperatorMaker(const RBAOperatorMaker&&)=delete;
+  RBAOperatorMaker& operator=(const RBAOperatorMaker&)=delete;
+  RBAOperatorMaker& operator=(const RBAOperatorMaker&&)=delete;
+  virtual ~RBAOperatorMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAOrOperator.cpp b/src/core/expression/RBAOrOperator.cpp
new file mode 100644
index 0000000..d55e4a0
--- /dev/null
+++ b/src/core/expression/RBAOrOperator.cpp
@@ -0,0 +1,100 @@
+/**
+ * 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.
+ */
+
+/**
+ * OrOperator class definition
+ */
+
+#include "RBAOrOperator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void
+RBAOrOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAOrOperator::getModelElementType() const
+{
+  return RBAModelElementType::OrOperator;
+}
+
+bool
+RBAOrOperator::executeCore(RBAConstraintInfo* info,
+                           RBAArbitrator* arb) const
+{
+  bool isPassed {false};
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy(LOG_getSymbol());
+  std::uint32_t index {0U};
+  for (const RBAExpression* const ope : getOperand()) {
+    RBAConstraintInfo* const childInfo {info->getChild(index)};
+    // Add count to Constraint hierarchy for coverage
+    LOG_addHierarchy("#" + std::to_string(index));
+    const bool res {ope->execute(childInfo, arb)};
+    // Remove count from Constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    if (childInfo->isExceptionBeforeArbitrate() == true) {
+      info->setExceptionBeforeArbitrate(true);
+    } else if (res == true) {
+      isPassed = true;
+    } else {
+      ;
+    }
+    ++index;
+  }
+  if (isPassed == true) {
+    info->setExceptionBeforeArbitrate(false);
+  }
+#ifdef RBA_USE_LOG
+  if (info->isExceptionBeforeArbitrate() == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] before arbitrate skip");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::SKIP);
+  } else if (isPassed == true) {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] true");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::TRUE);
+  } else {
+    LOG_arbitrateConstraintLogicLogLine(
+        "      [" + LOG_getExpressionText() + "] false");
+    LOG_coverageConstraintExpressionLog(LOG_getCoverageExpressionText(),
+                                        RBAExecuteResult::FALSE);
+  }
+#endif
+  // Remove count from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+  return isPassed;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAOrOperator::getSymbol() const
+{
+  return "OR";
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAOrOperator.hpp b/src/core/expression/RBAOrOperator.hpp
new file mode 100644
index 0000000..a52aca4
--- /dev/null
+++ b/src/core/expression/RBAOrOperator.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/**
+ * OrOperator class header
+ */
+
+#ifndef RBAOROPERATOR_HPP
+#define RBAOROPERATOR_HPP
+
+#include "RBALogicalOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAOrOperator : public RBALogicalOperator
+{
+ public:
+  RBAOrOperator()=default;
+  RBAOrOperator(const RBAOrOperator&)=delete;
+  RBAOrOperator(const RBAOrOperator&&)=delete;
+  RBAOrOperator& operator=(const RBAOrOperator&)=delete;
+  RBAOrOperator& operator=(const RBAOrOperator&&)=delete;
+  virtual ~RBAOrOperator()=default;
+
+ public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  bool executeCore(RBAConstraintInfo* info, RBAArbitrator * arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAOrOperatorMaker.cpp b/src/core/expression/RBAOrOperatorMaker.cpp
new file mode 100644
index 0000000..934c7e1
--- /dev/null
+++ b/src/core/expression/RBAOrOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAOrOperatorMaker.cpp
+/// @brief OrOperator object generator
+
+#include "RBAOrOperatorMaker.hpp"
+#include "RBAOrOperator.hpp"
+
+namespace rba
+{
+
+RBAOrOperatorMaker::RBAOrOperatorMaker()
+  : RBAOperatorMaker{"OrOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAOrOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAOrOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAOrOperatorMaker.hpp b/src/core/expression/RBAOrOperatorMaker.hpp
new file mode 100644
index 0000000..def4d8f
--- /dev/null
+++ b/src/core/expression/RBAOrOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAOrOperatorMaker.hpp
+/// @brief OrOperator object generator class header
+
+#ifndef RBAOROPERATORMAKER_HPP
+#define RBAOROPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief OrOperator object generator class
+class RBAOrOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAOrOperatorMaker();
+  RBAOrOperatorMaker(const RBAOrOperatorMaker&)=delete;
+  RBAOrOperatorMaker(const RBAOrOperatorMaker&&)=delete;
+  RBAOrOperatorMaker& operator=(const RBAOrOperatorMaker&)=delete;
+  RBAOrOperatorMaker& operator=(const RBAOrOperatorMaker&&)=delete;
+  virtual ~RBAOrOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAPlusOperator.cpp b/src/core/expression/RBAPlusOperator.cpp
new file mode 100644
index 0000000..8a6dbbb
--- /dev/null
+++ b/src/core/expression/RBAPlusOperator.cpp
@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+
+/**
+ * PlusOperator class definition
+ */
+
+#include "RBAPlusOperator.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+RBAModelElementType
+RBAPlusOperator::getModelElementType() const
+{
+  return RBAModelElementType::PlusOperator;
+}
+
+}
diff --git a/src/core/expression/RBAPlusOperator.hpp b/src/core/expression/RBAPlusOperator.hpp
new file mode 100644
index 0000000..ab04ebb
--- /dev/null
+++ b/src/core/expression/RBAPlusOperator.hpp
@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+
+/**
+ * PlusOperator class header
+ */
+
+#ifndef RBAPLUSOPERATOR_HPP
+#define RBAPLUSOPERATOR_HPP
+
+#include "RBAArithmeticOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAPlusOperator : public RBAArithmeticOperator
+{
+public:
+  RBAPlusOperator()=default;
+  RBAPlusOperator(const RBAPlusOperator&)=delete;
+  RBAPlusOperator(const RBAPlusOperator&&)=delete;
+  RBAPlusOperator& operator=(const RBAPlusOperator&)=delete;
+  RBAPlusOperator& operator=(const RBAPlusOperator&&)=delete;
+  virtual ~RBAPlusOperator()=default;
+
+public:
+  RBAModelElementType getModelElementType() const override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAPlusOperatorMaker.cpp b/src/core/expression/RBAPlusOperatorMaker.cpp
new file mode 100644
index 0000000..677d456
--- /dev/null
+++ b/src/core/expression/RBAPlusOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAPlusOperatorsMaker.cpp
+/// @brief PlusOperator object generator class definition
+
+#include "RBAPlusOperatorMaker.hpp"
+#include "RBAPlusOperator.hpp"
+
+namespace rba
+{
+
+RBAPlusOperatorMaker::RBAPlusOperatorMaker()
+  : RBAOperatorMaker{"PlusOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAPlusOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAPlusOperator>();
+}
+
+}
diff --git a/src/core/expression/RBAPlusOperatorMaker.hpp b/src/core/expression/RBAPlusOperatorMaker.hpp
new file mode 100644
index 0000000..aea1df7
--- /dev/null
+++ b/src/core/expression/RBAPlusOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAPlusOperatorsMaker.hpp
+/// @brief PlusOperator object generator class header
+
+#ifndef RBAPLUSOPERATORMAKER_HPP
+#define RBAPLUSOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief PlusOperator object generator class
+class RBAPlusOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBAPlusOperatorMaker();
+  RBAPlusOperatorMaker(const RBAPlusOperatorMaker&)=delete;
+  RBAPlusOperatorMaker(const RBAPlusOperatorMaker&&)=delete;
+  RBAPlusOperatorMaker& operator=(const RBAPlusOperatorMaker&)=delete;
+  RBAPlusOperatorMaker& operator=(const RBAPlusOperatorMaker&&)=delete;
+  virtual ~RBAPlusOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAPreviousModifier.cpp b/src/core/expression/RBAPreviousModifier.cpp
new file mode 100644
index 0000000..53a7112
--- /dev/null
+++ b/src/core/expression/RBAPreviousModifier.cpp
@@ -0,0 +1,97 @@
+/**
+ * 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.
+ */
+
+/**
+ * PreviousModifier class definition
+ */
+
+#include "RBAPreviousModifier.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAPreviousObjectWrapper.hpp"
+
+namespace rba
+{
+
+RBAPreviousModifier::RBAPreviousModifier()
+    : RBAExpression(),
+      previousObj_{std::make_unique<RBAPreviousObjectWrapper>()}
+{
+}
+
+void
+RBAPreviousModifier::accept(RBAExpressionVisitor& visitor)
+{
+  // RBASceneAllocatableCollector, 
+  // which is the only vistor that exists at the moment, 
+  // does not pass this path because it does not accept the rule object.
+  // In the future, another visitor may accept, so implement this.
+  visitor.visit(*this);
+}
+
+void
+RBAPreviousModifier::setObjReference(RBAExpression* const newObjRef)
+{
+  objReference_ = newObjRef;
+}
+
+RBAExpression* const
+RBAPreviousModifier::getObjReference() const
+{
+  return objReference_;
+}
+
+const RBARuleObject*
+RBAPreviousModifier::getReferenceObjectCore(RBAConstraintInfo* info,
+                                            RBAArbitrator* arb) const
+{
+  previousObj_->setRefObject(objReference_->getReferenceObject(info, arb));
+  return previousObj_.get();
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAPreviousModifier::getSymbol() const
+{
+  return "(pre)";
+}
+
+void
+RBAPreviousModifier::createHierarchy()
+{
+  objReference_->createHierarchy();
+}
+
+const std::string
+RBAPreviousModifier::getExpressionText() const
+{
+  return getSymbol() + objReference_->getExpressionText();
+}
+
+const std::string
+RBAPreviousModifier::getCoverageExpressionText() const
+{
+  return getSymbol() + objReference_->getCoverageExpressionText();
+}
+
+RBAExpressionType
+RBAPreviousModifier::getUnderlyingType() const
+{
+  return objReference_->getUnderlyingType();
+}
+
+#endif
+
+}
diff --git a/src/core/expression/RBAPreviousModifier.hpp b/src/core/expression/RBAPreviousModifier.hpp
new file mode 100644
index 0000000..ff34deb
--- /dev/null
+++ b/src/core/expression/RBAPreviousModifier.hpp
@@ -0,0 +1,75 @@
+/**
+ * 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.
+ */
+
+/**
+ * PreviousModifier class header
+ */
+
+
+#ifndef RBAPREVIOUSMODIFIER_HPP
+#define RBAPREVIOUSMODIFIER_HPP
+
+#include <memory>
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class RBAPreviousObjectWrapper;
+
+class DLL_EXPORT RBAPreviousModifier : public RBAExpression
+{
+public:
+  RBAPreviousModifier();
+  RBAPreviousModifier(const RBAPreviousModifier&)=delete;
+  RBAPreviousModifier(const RBAPreviousModifier&&)=delete;
+  RBAPreviousModifier& operator=(const RBAPreviousModifier&)=delete;
+  RBAPreviousModifier& operator=(const RBAPreviousModifier&&)=delete;
+  virtual ~RBAPreviousModifier()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  void setObjReference(RBAExpression* const newObjRef);
+  RBAExpression* const getObjReference() const;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                              RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  virtual const std::string getSymbol() const;
+  void createHierarchy() override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+private:
+  // This pointer is not "const" in order to call 
+  //  objReference_->getReferenceObject()
+  RBAExpression* objReference_;
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::unique_ptr<RBAPreviousObjectWrapper> previousObj_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAPreviousModifierMaker.cpp b/src/core/expression/RBAPreviousModifierMaker.cpp
new file mode 100644
index 0000000..764ef34
--- /dev/null
+++ b/src/core/expression/RBAPreviousModifierMaker.cpp
@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAPreviousModifierMaker.cpp
+/// @brief PreviousModifier object generator class definition
+
+#include "RBAPreviousModifierMaker.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAPreviousModifier.hpp"
+#include "RBAPreviousObjectWrapper.hpp"
+
+namespace rba
+{
+
+RBAPreviousModifierMaker::RBAPreviousModifierMaker()
+  : RBAExpressionMaker{"PreviousModifier"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAPreviousModifierMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAPreviousModifier>();
+}
+
+RBAModelElement*
+RBAPreviousModifierMaker::setProperty(RBAModelElement* element,
+                                      const RBAJsonElement* jsonElem,
+                                      RBAModelImpl* model,
+                                      RBAModelElement* owner)
+{
+  RBAPreviousModifier* const prevMod {dynamic_cast<RBAPreviousModifier*>(element)};
+
+  // Set LetStatement
+  const std::int32_t pop_num {setLetStatement(model, prevMod, jsonElem)};
+
+  // Set object reference
+  const RBAJsonElement* const objRefElem {jsonElem->findChildren("objReference")};
+  RBAModelElement* const expr {getFactory()->createElement(objRefElem->getClassName(),
+                                                     objRefElem)};
+  prevMod->setObjReference(dynamic_cast<RBAExpression*>(expr));
+
+  // Pop variable
+  for(std::int32_t i{0}; i<pop_num; i++) {
+    getFactory()->popVariable();
+  }
+
+  return prevMod;
+}
+
+}
diff --git a/src/core/expression/RBAPreviousModifierMaker.hpp b/src/core/expression/RBAPreviousModifierMaker.hpp
new file mode 100644
index 0000000..0f58892
--- /dev/null
+++ b/src/core/expression/RBAPreviousModifierMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAPreviousModifierMaker.cpp
+/// @brief PreviousModifier object generator class header
+
+#ifndef RBAPREVIOUSMODIFIERMAKER_HPP
+#define RBAPREVIOUSMODIFIERMAKER_HPP
+
+#include "RBAExpressionMaker.hpp"
+
+namespace rba
+{
+
+/// @brief PreviousModifier object generator class
+class RBAPreviousModifierMaker : public RBAExpressionMaker
+{
+public:
+  RBAPreviousModifierMaker();
+  RBAPreviousModifierMaker(const RBAPreviousModifierMaker&)=delete;
+  RBAPreviousModifierMaker(const RBAPreviousModifierMaker&&)=delete;
+  RBAPreviousModifierMaker& operator=(const RBAPreviousModifierMaker&)=delete;
+  RBAPreviousModifierMaker& operator=(const RBAPreviousModifierMaker&&)=delete;
+  virtual ~RBAPreviousModifierMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAPreviousObjectWrapper.cpp b/src/core/expression/RBAPreviousObjectWrapper.cpp
new file mode 100644
index 0000000..348b05f
--- /dev/null
+++ b/src/core/expression/RBAPreviousObjectWrapper.cpp
@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+
+/**
+ * PreviousObjectWrapper (Previous Wrapper of RuleObject) 
+ * generator class definition
+ */
+
+#include "RBAPreviousObjectWrapper.hpp"
+
+namespace rba
+{
+
+bool
+RBAPreviousObjectWrapper::isPrevious() const
+{
+  return true;
+}
+
+const RBARuleObject*
+RBAPreviousObjectWrapper::getRawObject() const
+{
+  return refObject_->getRawObject();
+}
+
+void
+RBAPreviousObjectWrapper::setRefObject(const RBARuleObject* const obj)
+{
+  refObject_ = obj;
+}
+
+}
diff --git a/src/core/expression/RBAPreviousObjectWrapper.hpp b/src/core/expression/RBAPreviousObjectWrapper.hpp
new file mode 100644
index 0000000..571c450
--- /dev/null
+++ b/src/core/expression/RBAPreviousObjectWrapper.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/**
+ * PreviousObjectWrapper (Previous Wrapper of RuleObject) 
+ * generator class header
+ */
+
+#ifndef RBAPREVIOUSOBJECTWRAPPER_HPP
+#define RBAPREVIOUSOBJECTWRAPPER_HPP
+
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAPreviousObjectWrapper : public RBARuleObject
+{
+public:
+  RBAPreviousObjectWrapper()=default;
+  RBAPreviousObjectWrapper(const RBAPreviousObjectWrapper&)=delete;
+  RBAPreviousObjectWrapper(const RBAPreviousObjectWrapper&&)=delete;
+  RBAPreviousObjectWrapper& operator=(const RBAPreviousObjectWrapper&)=delete;
+  RBAPreviousObjectWrapper& operator=(const RBAPreviousObjectWrapper&&)=delete;
+  virtual ~RBAPreviousObjectWrapper()=default;
+
+public:
+  bool isPrevious() const override;
+  const RBARuleObject* getRawObject() const override;
+  void setRefObject(const RBARuleObject* const obj);
+
+private:
+  const RBARuleObject* refObject_ {nullptr};
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAPropertyOperator.hpp b/src/core/expression/RBAPropertyOperator.hpp
new file mode 100644
index 0000000..250e6a2
--- /dev/null
+++ b/src/core/expression/RBAPropertyOperator.hpp
@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+
+/**
+ * PropertyOperator class definition
+ */
+
+#ifndef RBAPROPERTYOPERATOR_HPP
+#define RBAPROPERTYOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAPropertyOperator : public RBAOperator
+{
+protected:
+  RBAPropertyOperator()=default;
+  RBAPropertyOperator(const RBAPropertyOperator&)=delete;
+  RBAPropertyOperator(const RBAPropertyOperator&&)=delete;
+  RBAPropertyOperator& operator=(const RBAPropertyOperator&)=delete;
+  RBAPropertyOperator& operator=(const RBAPropertyOperator&&)=delete;
+
+public:
+  virtual ~RBAPropertyOperator()=default;
+
+};
+
+}
+
+#endif
+	
\ No newline at end of file
diff --git a/src/core/expression/RBASceneCondition.hpp b/src/core/expression/RBASceneCondition.hpp
new file mode 100644
index 0000000..44f543c
--- /dev/null
+++ b/src/core/expression/RBASceneCondition.hpp
@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+
+/**
+ * SceneCondition class header
+ */
+
+#ifndef RBASCENECONDITION_HPP
+#define RBASCENECONDITION_HPP
+
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBASceneCondition : public RBAExpression
+{
+protected:
+  RBASceneCondition()=default;
+  RBASceneCondition(const RBASceneCondition&)=delete;
+  RBASceneCondition(const RBASceneCondition&&)=delete;
+  RBASceneCondition& operator=(const RBASceneCondition&)=delete;
+  RBASceneCondition& operator=(const RBASceneCondition&&)=delete;
+public:
+  virtual ~RBASceneCondition()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASceneOperator.hpp b/src/core/expression/RBASceneOperator.hpp
new file mode 100644
index 0000000..630c655
--- /dev/null
+++ b/src/core/expression/RBASceneOperator.hpp
@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+
+/**
+ * SceneOperator class header
+ */
+
+#ifndef RBASCENEOPERATOR_HPP
+#define RBASCENEOPERATOR_HPP
+
+#include "RBADllExport.hpp"
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBASceneOperator : public RBAOperator
+{
+protected:
+  RBASceneOperator()=default;
+  RBASceneOperator(const RBASceneOperator&)=delete;
+  RBASceneOperator(const RBASceneOperator&&)=delete;
+  RBASceneOperator& operator=(const RBASceneOperator&)=delete;
+  RBASceneOperator& operator=(const RBASceneOperator&&)=delete;
+public:
+  ~RBASceneOperator()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASelectOperator.cpp b/src/core/expression/RBASelectOperator.cpp
new file mode 100644
index 0000000..be74fa5
--- /dev/null
+++ b/src/core/expression/RBASelectOperator.cpp
@@ -0,0 +1,140 @@
+/**
+ * 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.
+ */
+
+/**
+ * SelectOperator class definition
+ */
+
+#include <memory>
+#include "RBASelectOperator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALambdaExpression.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+RBASelectOperator::RBASelectOperator()
+: RBALambdaContext(),
+  allocatableSet_{std::make_unique<RBAAllocatableSet>()},
+  contentSet_{std::make_unique<RBAContentSet>()}
+{
+}
+
+void
+RBASelectOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBASelectOperator::getModelElementType() const
+{
+  return RBAModelElementType::SelectOperator;
+}
+
+const RBARuleObject* RBASelectOperator::getReferenceObjectCore(
+    RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  LOG_addHierarchy(LOG_getSymbol());
+  const RBARuleObject* returnObj {nullptr};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const lhsObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                    arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (lhsObj != nullptr) {
+    if (dynamic_cast<const RBAAllocatableSet*>(lhsObj) != nullptr) {
+      std::list<const RBAAllocatable*> objs {
+          dynamic_cast<const RBAAllocatableSet*>(lhsObj)->getLeafAllocatable()};
+      allocatableSet_->clear();
+      std::uint32_t i {0U};
+      RBALambdaExpression* const lambda {getLambda()};
+      for (auto& obj : objs) {
+        LOG_addHierarchy("#" + std::to_string(i));
+        ++i;
+        RBAConstraintInfo* const childInfo {info->getChild(i)};
+        lambda->setRuleObj(obj);
+        const bool isPassed {lambda->execute(childInfo, arb)};
+        LOG_removeHierarchy();
+        if (isPassed && (!childInfo->isExceptionBeforeArbitrate())) {
+          allocatableSet_->addTarget(obj);
+        }
+      }
+      returnObj = allocatableSet_.get();
+    } else {
+      std::list<const RBAContent*> objs {
+          dynamic_cast<const RBAContentSet*>(lhsObj)->getLeafContent()};
+      contentSet_->clear();
+      std::uint32_t i {0U};
+      RBALambdaExpression* const lambda {getLambda()};
+      for (auto& obj : objs) {
+        LOG_addHierarchy("#" + std::to_string(i));
+        ++i;
+        RBAConstraintInfo* const childInfo {info->getChild(i)};
+        lambda->setRuleObj(obj);
+        const bool isPassed {lambda->execute(childInfo, arb)};
+        LOG_removeHierarchy();
+        if (isPassed && (!childInfo->isExceptionBeforeArbitrate())) {
+          contentSet_->addTarget(obj);
+        }
+      }
+      returnObj = contentSet_.get();
+    }
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  std::string objName = "NULL";
+  if (returnObj != nullptr) {
+    objName = returnObj->getElementName();
+    if (objName == "") {
+      objName = returnObj->getDynamicName();
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      " + LOG_getExpressionText() + " is " + objName);
+#endif
+  LOG_removeHierarchy();
+  return returnObj;
+}
+#ifdef RBA_USE_LOG
+const std::string RBASelectOperator::getSymbol() const
+{
+  return ".select";
+}
+
+const std::string RBASelectOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol()
+      + getLambda()->getExpressionText();
+}
+
+const std::string RBASelectOperator::getCoverageExpressionText() const
+{
+  getLambda()->clearRuleObj();
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol()
+      + getLambda()->getCoverageExpressionText();
+}
+#endif
+
+} // namespace rba
diff --git a/src/core/expression/RBASelectOperator.hpp b/src/core/expression/RBASelectOperator.hpp
new file mode 100644
index 0000000..9c85fb0
--- /dev/null
+++ b/src/core/expression/RBASelectOperator.hpp
@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+
+/**
+ * SelectOperator class header
+ */
+
+#ifndef RBASELECTOPERATOR_HPP
+#define RBASELECTOPERATOR_HPP
+
+#include "RBALambdaContext.hpp"
+
+namespace rba
+{
+
+class RBAAllocatableSet;
+class RBAContentSet;
+
+class RBASelectOperator : public RBALambdaContext
+{
+ public:
+  RBASelectOperator();
+  RBASelectOperator(const RBASelectOperator&)=delete;
+  RBASelectOperator(const RBASelectOperator&&)=delete;
+  RBASelectOperator& operator=(const RBASelectOperator&)=delete;
+  RBASelectOperator& operator=(const RBASelectOperator&&)=delete;
+  virtual ~RBASelectOperator()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                              RBAArbitrator* arb) const override;
+
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+ private:
+  std::unique_ptr<RBAAllocatableSet> allocatableSet_;
+  std::unique_ptr<RBAContentSet> contentSet_;
+};
+
+} /* namespace rba */
+
+#endif /* RBASELECTOPERATOR_HPP */
diff --git a/src/core/expression/RBASelectOperatorMaker.cpp b/src/core/expression/RBASelectOperatorMaker.cpp
new file mode 100644
index 0000000..d7c1a35
--- /dev/null
+++ b/src/core/expression/RBASelectOperatorMaker.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+
+/// @file  RBASelectOperatorMaker.cpp
+/// @brief SelectOperator object generator class definition
+
+#include "RBASelectOperatorMaker.hpp"
+#include "RBASelectOperator.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBALambdaExpression.hpp"
+
+namespace rba
+{
+
+RBASelectOperatorMaker::RBASelectOperatorMaker()
+  : RBALambdaContextMaker{"SelectOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBASelectOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBASelectOperator>();
+}
+
+RBAModelElement*
+RBASelectOperatorMaker::setProperty(RBAModelElement* element,
+                                    const RBAJsonElement* jsonElem,
+                                    RBAModelImpl* model,
+                                    RBAModelElement* owner)
+{
+  static_cast<void>(
+      RBALambdaContextMaker::setProperty(element, jsonElem, model, owner));
+
+  return element;
+}
+
+std::unique_ptr<RBALambdaContext>
+RBASelectOperatorMaker::createLambdaContext()
+{
+  return std::make_unique<RBASelectOperator>();
+}
+
+}
diff --git a/src/core/expression/RBASelectOperatorMaker.hpp b/src/core/expression/RBASelectOperatorMaker.hpp
new file mode 100644
index 0000000..0415331
--- /dev/null
+++ b/src/core/expression/RBASelectOperatorMaker.hpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// @file  RBASelectOperatorMaker.cpp
+/// @brief SelectOperator object generator class header
+
+#ifndef RBASELECTOPERATORMAKER_HPP
+#define RBASELECTOPERATORMAKER_HPP
+
+#include "RBALambdaContextMaker.hpp"
+
+namespace rba
+{
+
+/// @brief SelectOperator object generator class
+class RBASelectOperatorMaker : public RBALambdaContextMaker
+{
+public:
+  RBASelectOperatorMaker();
+  RBASelectOperatorMaker(const RBASelectOperatorMaker&)=delete;
+  RBASelectOperatorMaker(const RBASelectOperatorMaker&&)=delete;
+  RBASelectOperatorMaker& operator=(const RBASelectOperatorMaker&)=delete;
+  RBASelectOperatorMaker& operator=(const RBASelectOperatorMaker&&)=delete;
+  virtual ~RBASelectOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated object
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner) override;
+
+  /// @brief generate an empty object of LambdaContext
+  /// @details generate an empty object of unique_ptr
+  /// @return unique_ptr for object of LambdaContext
+  std::unique_ptr<RBALambdaContext> createLambdaContext() override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASetExpression.hpp b/src/core/expression/RBASetExpression.hpp
new file mode 100644
index 0000000..5ad1de4
--- /dev/null
+++ b/src/core/expression/RBASetExpression.hpp
@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+
+/**
+ * SetExpression class header
+ */
+
+#ifndef RBASETEXPRESSION_HPP
+#define RBASETEXPRESSION_HPP
+
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBASetExpression : public RBAExpression
+{
+protected:
+  RBASetExpression()=default;
+  RBASetExpression(const RBASetExpression&)=delete;
+  RBASetExpression(const RBASetExpression&&)=delete;
+  RBASetExpression& operator=(const RBASetExpression&)=delete;
+  RBASetExpression& operator=(const RBASetExpression&&)=delete;
+public:
+  virtual ~RBASetExpression()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASetOfOperator.cpp b/src/core/expression/RBASetOfOperator.cpp
new file mode 100644
index 0000000..03e82eb
--- /dev/null
+++ b/src/core/expression/RBASetOfOperator.cpp
@@ -0,0 +1,194 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBASetOfOperator class definition
+ */
+
+#include <sstream>
+#include "RBASetOfOperator.hpp"
+#include "RBARuleObject.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAContent.hpp"
+#include "RBALogManager.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+RBASetOfOperator::RBASetOfOperator()
+    : RBAOperator(),
+      allocatableSet_{std::make_unique<RBAAllocatableSet>()},
+      contentSet_{std::make_unique<RBAContentSet>()}
+{
+}
+
+void
+RBASetOfOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBASetOfOperator::getModelElementType() const
+{
+  return RBAModelElementType::SetOfOperator;
+}
+
+const RBARuleObject*
+RBASetOfOperator::getReferenceObjectCore(RBAConstraintInfo* info,
+                                         RBAArbitrator* arb) const
+{
+  allocatableSet_->clear();
+  contentSet_->clear();
+
+  bool isAllocatableSet {false};
+  bool isContentSet {false};
+
+  std::uint32_t i {0U};
+  for(const RBAExpression* const expr : getOperand()) {
+    RBAConstraintInfo* const childInfo {info->getChild(i)};
+    const RBARuleObject* const obj {expr->getReferenceObject(childInfo,arb)};
+    if(childInfo->isExceptionBeforeArbitrate()) {
+      info->setExceptionBeforeArbitrate(true);
+      return nullptr;
+    }
+    if(obj != nullptr) {
+      if (obj->isModelElementType(RBAModelElementType::Area) ||
+          obj->isModelElementType(RBAModelElementType::Zone)) {
+        allocatableSet_->addTarget(dynamic_cast<const RBAAllocatable*>(obj));
+        isAllocatableSet = true;
+      }
+      else if (obj->isModelElementType(RBAModelElementType::ViewContent) ||
+               obj->isModelElementType(RBAModelElementType::SoundContent)) {
+        contentSet_->addTarget(dynamic_cast<const RBAContent*>(obj));
+        isContentSet = true;
+      }
+      else if (dynamic_cast<const RBAAllocatableSet*>(obj) != nullptr) {
+        for (const RBAAllocatable* const a : dynamic_cast<const RBAAllocatableSet*>(obj)->getLeafAllocatable()) {
+          allocatableSet_->addTarget(a);
+        }
+        isAllocatableSet = true;
+      } else {
+        for (const RBAContent* const c : dynamic_cast<const RBAContentSet*>(obj)->getLeafContent()) {
+          contentSet_->addTarget(c);
+        }
+        isContentSet = true;
+      }
+    }
+    i++;
+  }
+  if (isAllocatableSet) {
+    return allocatableSet_.get();
+  } else if (isContentSet){
+    return contentSet_.get();
+  } else {
+    return nullptr;
+  }
+}
+
+void
+RBASetOfOperator::doActionCore(RBAConstraintInfo* info, RBAArbitrator* arb)
+{
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy("SetOf");
+
+  std::uint32_t i {0U};
+  for(RBAExpression* const expr : getOperand()) {
+    // Add number of element to Constraint hierarchy for coverage
+    LOG_addHierarchy("#" + std::to_string(i) + ":");
+
+    // Since it should only execute Action, info is as it is
+    expr->doAction(info, arb);
+    i++;
+
+    // Remove number of element from Constraint hierarchy for coverage
+    LOG_removeHierarchy();
+  }
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+
+  return;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBASetOfOperator::getExpressionText() const
+{
+  std::ostringstream oss;
+  oss << "{";
+  const auto& exprList = getOperand();
+  const auto& lastExpr = exprList.back();
+  for (const auto& expr : exprList) {
+    oss << expr->getExpressionText();
+    if (expr != lastExpr) {
+      oss << ", ";
+    }
+  }
+  oss << "}";
+
+  return oss.str();
+}
+
+const std::string
+RBASetOfOperator::getCoverageExpressionText() const
+{
+  std::ostringstream oss;
+  oss << "{";
+  const auto& exprList = getOperand();
+  const auto& lastExpr = exprList.back();
+  for (const auto& expr : exprList) {
+    oss << expr->getCoverageExpressionText();
+    if (expr != lastExpr) {
+      oss << ", ";
+    }
+  }
+  oss << "}";
+
+  return oss.str();
+}
+
+void
+RBASetOfOperator::createHierarchy()
+{
+  // Add itself to Constraint hierarchy for coverage
+  LOG_addHierarchy("SetOf");
+  RBALogManager::coverageHierarchyOfConstraintExpressionLog(getCoverageExpressionText(), this);
+  uint32_t idx=0;
+  for(RBAExpression* expr : getOperand()) {
+    // Add number of element to Constraint hierarchy for coverage
+    LOG_addHierarchy("#"+std::to_string(idx)+":");
+    expr->createHierarchy();
+    // Remove number of element from Constraint hierarchy for coverage
+    LOG_removeHierarchy();
+    idx++;
+  }
+  // Remove itself from Constraint hierarchy for coverage
+  LOG_removeHierarchy();
+}
+
+RBAExpressionType
+RBASetOfOperator::getUnderlyingType() const
+{
+  return getLhsOperand()->getUnderlyingType();
+}
+#endif
+
+}
diff --git a/src/core/expression/RBASetOfOperator.hpp b/src/core/expression/RBASetOfOperator.hpp
new file mode 100644
index 0000000..d73e1f7
--- /dev/null
+++ b/src/core/expression/RBASetOfOperator.hpp
@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBASetOfOperator class header
+ */
+
+#ifndef RBASETOFOPERATOR_HPP
+#define RBASETOFOPERATOR_HPP
+
+#include <memory>
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class RBAAllocatableSet;
+class RBAContentSet;
+
+class DLL_EXPORT RBASetOfOperator : public RBAOperator
+{
+public:
+  RBASetOfOperator();
+  RBASetOfOperator(const RBASetOfOperator&)=delete;
+  RBASetOfOperator(const RBASetOfOperator&&)=delete;
+  RBASetOfOperator& operator=(const RBASetOfOperator&)=delete;
+  RBASetOfOperator& operator=(const RBASetOfOperator&&)=delete;
+  virtual ~RBASetOfOperator()=default;
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+  void createHierarchy() override;
+  RBAExpressionType getUnderlyingType() const override;
+#endif
+
+protected:
+  const RBARuleObject* getReferenceObjectCore(RBAConstraintInfo* info,
+                                              RBAArbitrator* arb) const override;
+  void doActionCore(RBAConstraintInfo* info, RBAArbitrator* arb) override;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::unique_ptr<RBAAllocatableSet> allocatableSet_;
+  std::unique_ptr<RBAContentSet> contentSet_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASetOfOperatorMaker.cpp b/src/core/expression/RBASetOfOperatorMaker.cpp
new file mode 100644
index 0000000..f17f17d
--- /dev/null
+++ b/src/core/expression/RBASetOfOperatorMaker.cpp
@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+
+/// @file  RBASetOfOperatorMaker.cpp
+/// @brief SetOfOperator object generator class
+
+#include "RBASetOfOperatorMaker.hpp"
+#include "RBASetOfOperator.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAContentSet.hpp"
+
+namespace rba
+{
+
+RBASetOfOperatorMaker::RBASetOfOperatorMaker()
+  : RBAOperatorMaker{"SetOfOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBASetOfOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBASetOfOperator>();
+}
+
+}
diff --git a/src/core/expression/RBASetOfOperatorMaker.hpp b/src/core/expression/RBASetOfOperatorMaker.hpp
new file mode 100644
index 0000000..87905fa
--- /dev/null
+++ b/src/core/expression/RBASetOfOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBASetOfOperatorMaker.cpp
+/// @brief SetOfOperator object generator class header
+
+#ifndef RBASETOFOPERATORMAKER_HPP
+#define RBASETOFOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief SetOfOperator object generator class
+class RBASetOfOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBASetOfOperatorMaker();
+  RBASetOfOperatorMaker(const RBASetOfOperatorMaker&)=delete;
+  RBASetOfOperatorMaker(const RBASetOfOperatorMaker&&)=delete;
+  RBASetOfOperatorMaker& operator=(const RBASetOfOperatorMaker&)=delete;
+  RBASetOfOperatorMaker& operator=(const RBASetOfOperatorMaker&&)=delete;
+  virtual ~RBASetOfOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASetOperator.hpp b/src/core/expression/RBASetOperator.hpp
new file mode 100644
index 0000000..ded7a16
--- /dev/null
+++ b/src/core/expression/RBASetOperator.hpp
@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+
+/**
+ * SetOperator class header
+ */
+
+#ifndef RBASETOPERATOR_HPP
+#define RBASETOPERATOR_HPP
+
+#include "RBAOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBASetOperator : public RBAOperator
+{
+protected:
+  RBASetOperator()=default;
+  RBASetOperator(const RBASetOperator&)=delete;
+  RBASetOperator(const RBASetOperator&&)=delete;
+  RBASetOperator& operator=(const RBASetOperator&)=delete;
+  RBASetOperator& operator=(const RBASetOperator&&)=delete;
+public:
+  virtual ~RBASetOperator()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBASizeOperator.cpp b/src/core/expression/RBASizeOperator.cpp
new file mode 100644
index 0000000..c928bcf
--- /dev/null
+++ b/src/core/expression/RBASizeOperator.cpp
@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+
+//
+// SizeOperator class definition
+//
+
+#include "RBASizeOperator.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBALogManager.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+void RBASizeOperator::accept(RBAExpressionVisitor& visitor)
+{
+  visitor.visit(*this);
+}
+RBAModelElementType RBASizeOperator::getModelElementType() const
+{
+  return RBAModelElementType::SizeOperator;
+}
+std::int32_t RBASizeOperator::getValueCore(RBAConstraintInfo* info,
+                                           RBAArbitrator* arb) const
+{
+  LOG_addHierarchy(LOG_getSymbol());
+  std::int32_t returnValue {-99};
+  RBAConstraintInfo* const leftInfo {info->getChild(0U)};
+  const RBARuleObject* const lhsObj {getLhsOperand()->getReferenceObject(leftInfo,
+                                                                    arb)};
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else if (lhsObj != nullptr) {
+    if (dynamic_cast<const RBAAllocatableSet*>(lhsObj) != nullptr) {
+      returnValue = static_cast<std::int32_t>(dynamic_cast<const RBAAllocatableSet*>(lhsObj)
+          ->getLeafAllocatable().size());
+    } else {
+      returnValue = static_cast<std::int32_t>(dynamic_cast<const RBAContentSet*>(lhsObj)->getLeafContent()
+          .size());
+    }
+  } else {
+    ;
+  }
+#ifdef RBA_USE_LOG
+  LOG_arbitrateConstraintLogicLogLine(
+      "      " + LOG_getExpressionText() + " is " + std::to_string(returnValue));
+#endif
+  LOG_removeHierarchy();
+  return returnValue;
+}
+
+#ifdef RBA_USE_LOG
+const std::string RBASizeOperator::getSymbol() const
+{
+  return ".size()";
+}
+const std::string RBASizeOperator::getExpressionText() const
+{
+  return getLhsOperand()->getExpressionText() + getSymbol();
+}
+const std::string RBASizeOperator::getCoverageExpressionText() const
+{
+  return getLhsOperand()->getCoverageExpressionText() + getSymbol();
+}
+#endif
+
+} /* namespace rba */
diff --git a/src/core/expression/RBASizeOperator.hpp b/src/core/expression/RBASizeOperator.hpp
new file mode 100644
index 0000000..26f22fa
--- /dev/null
+++ b/src/core/expression/RBASizeOperator.hpp
@@ -0,0 +1,51 @@
+/**
+ * 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.
+ */
+
+//
+// SizeOperator class header
+//
+
+#ifndef RBASIZEOPERATOR_HPP
+#define RBASIZEOPERATOR_HPP
+
+#include "RBASetOperator.hpp"
+
+namespace rba
+{
+
+class RBASizeOperator : public RBASetOperator
+{
+ public:
+  RBASizeOperator()=default;
+  RBASizeOperator(const RBASizeOperator&)=delete;
+  RBASizeOperator(const RBASizeOperator&&)=delete;
+  RBASizeOperator& operator=(const RBASizeOperator&)=delete;
+  RBASizeOperator& operator=(const RBASizeOperator&&)=delete;
+  virtual ~RBASizeOperator()=default;
+
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info, RBAArbitrator* arb) const override;
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+  const std::string getExpressionText() const override;
+  const std::string getCoverageExpressionText() const override;
+#endif
+};
+
+} /* namespace rba */
+
+#endif /* SRC_CORE_EXPRESSION_RBASIZEOPERATOR_HPP_ */
diff --git a/src/core/expression/RBASizeOperatorMaker.cpp b/src/core/expression/RBASizeOperatorMaker.cpp
new file mode 100644
index 0000000..2a905c7
--- /dev/null
+++ b/src/core/expression/RBASizeOperatorMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBASizeOperatorMaker.cpp
+/// @brief SizeOperator object generator class definition
+
+#include "RBASizeOperatorMaker.hpp"
+#include "RBASizeOperator.hpp"
+
+namespace rba
+{
+
+RBASizeOperatorMaker::RBASizeOperatorMaker()
+  : RBAOperatorMaker{"SizeOperator"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBASizeOperatorMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBASizeOperator>();
+}
+
+}
diff --git a/src/core/expression/RBASizeOperatorMaker.hpp b/src/core/expression/RBASizeOperatorMaker.hpp
new file mode 100644
index 0000000..b5dd0f6
--- /dev/null
+++ b/src/core/expression/RBASizeOperatorMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBASizeOperatorMaker.hpp
+/// @brief SizeOperator object generator abstract class header
+
+#ifndef RBASIZEOPERATORMAKER_HPP
+#define RBASIZEOPERATORMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief SizeOperator object generator class
+class RBASizeOperatorMaker : public RBAOperatorMaker
+{
+public:
+  RBASizeOperatorMaker();
+  RBASizeOperatorMaker(const RBASizeOperatorMaker&)=delete;
+  RBASizeOperatorMaker(const RBASizeOperatorMaker&&)=delete;
+  RBASizeOperatorMaker& operator=(const RBASizeOperatorMaker&)=delete;
+  RBASizeOperatorMaker& operator=(const RBASizeOperatorMaker&&)=delete;
+  virtual ~RBASizeOperatorMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAStateValue.cpp b/src/core/expression/RBAStateValue.cpp
new file mode 100644
index 0000000..f2fe5cb
--- /dev/null
+++ b/src/core/expression/RBAStateValue.cpp
@@ -0,0 +1,107 @@
+/**
+ * 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.
+ */
+
+ /// StateValue class denition
+
+#include <string>
+#include "RBAStateValue.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentState.hpp"
+#include "RBAExpressionVisitor.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void RBAStateValue::accept(RBAExpressionVisitor& visitor)
+{
+  // RBASceneAllocatableCollector which is the only existing vistor
+  // does not pass this path because it does not accept 
+  // the expression that returns Value.　But, in the future,
+  // another visitor may accept, so implement this.
+  visitor.visit(*this);
+}
+
+RBAModelElementType
+RBAStateValue::getModelElementType() const
+{
+  return RBAModelElementType::StateValue;
+}
+
+std::int32_t
+RBAStateValue::getValueCore(RBAConstraintInfo* info, RBAArbitrator* arb) const
+{
+  std::int32_t result { -99 };
+  const auto leftInfo = info->getChild(0U);
+  const auto r = getLhsOperand()->getReferenceObject(leftInfo, arb);
+  const RBAContent* c { nullptr };
+  const RBAContentState* cs { nullptr };
+  if (leftInfo->isExceptionBeforeArbitrate()) {
+    info->setExceptionBeforeArbitrate(true);
+  } else {
+    if (r != nullptr) {
+      c = dynamic_cast<const RBAContent*>(r->getRawObject());
+      if (c != nullptr) {
+        if (r->isPrevious()) {
+          cs = arb->getResult()->getPreActiveState(c);
+        } else {
+          cs = arb->getResult()->getActiveState(c);
+        }
+        if (cs != nullptr) {
+          result = cs->getContentStatePriority();
+        }
+      }
+    }
+  }
+#ifdef RBA_USE_LOG
+  std::string pre;
+  std::string cName { "NULL" };
+  std::string resultText{ "no Content skip" };
+  if (r != nullptr) {
+    cName = r->getElementName();
+    pre = getPreMsg(r->isPrevious());
+  }
+  if (info->isExceptionBeforeArbitrate()) {
+    resultText = "before arbitrate skip";
+  } else {
+    if (cs != nullptr) {
+      resultText = cs->getElementName() + " : " + std::to_string(result);
+    }
+  }
+  LOG_arbitrateConstraintLogicLogLine(
+      "      "
+      + pre
+      + "Content["
+      + cName
+      + "] state value ["
+      + resultText
+      + "]");
+#endif
+  return result;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAStateValue::getSymbol() const
+{
+  return ".stateValue()";
+}
+#endif
+
+}
diff --git a/src/core/expression/RBAStateValue.hpp b/src/core/expression/RBAStateValue.hpp
new file mode 100644
index 0000000..52cf8fc
--- /dev/null
+++ b/src/core/expression/RBAStateValue.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+ /// StateValue class header
+
+#ifndef RBASTATEVALUE_HPP
+#define RBASTATEVALUE_HPP
+
+#include <cstdint>
+#include "RBAContentOperator.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAStateValue : public RBAContentOperator
+{
+public:
+  RBAStateValue()=default;
+  RBAStateValue(const RBAStateValue&)=delete;
+  RBAStateValue(RBAStateValue&&)=delete;
+  RBAStateValue& operator=(const RBAStateValue&)=delete;
+  RBAStateValue& operator=(RBAStateValue&&)=delete;
+  virtual ~RBAStateValue()=default;
+
+public:
+  void accept(RBAExpressionVisitor& visitor) override;
+  RBAModelElementType getModelElementType() const override;
+  std::int32_t getValueCore(RBAConstraintInfo* info,
+                            RBAArbitrator* arb) const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getSymbol() const override;
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAStateValueMaker.cpp b/src/core/expression/RBAStateValueMaker.cpp
new file mode 100644
index 0000000..22a0c81
--- /dev/null
+++ b/src/core/expression/RBAStateValueMaker.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAStateValueMaker.cpp
+/// @brief StateValue object generator class
+
+#include "RBAStateValueMaker.hpp"
+#include "RBAStateValue.hpp"
+
+namespace rba
+{
+
+RBAStateValueMaker::RBAStateValueMaker()
+  : RBAOperatorMaker{"StateValue"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAStateValueMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAStateValue>();
+}
+
+}
diff --git a/src/core/expression/RBAStateValueMaker.hpp b/src/core/expression/RBAStateValueMaker.hpp
new file mode 100644
index 0000000..8b01e09
--- /dev/null
+++ b/src/core/expression/RBAStateValueMaker.hpp
@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAStateValueMaker.cpp
+/// @brief StateValue object generator class header
+
+#ifndef RBASTATEVALUEMAKER_HPP
+#define RBASTATEVALUEMAKER_HPP
+
+#include "RBAOperatorMaker.hpp"
+
+namespace rba
+{
+
+/// @brief StateValue object generator class
+class RBAStateValueMaker : public RBAOperatorMaker
+{
+public:
+  RBAStateValueMaker();
+  RBAStateValueMaker(const RBAStateValueMaker&)=delete;
+  RBAStateValueMaker(const RBAStateValueMaker&&)=delete;
+  RBAStateValueMaker& operator=(const RBAStateValueMaker&)=delete;
+  RBAStateValueMaker& operator=(const RBAStateValueMaker&&)=delete;
+  virtual ~RBAStateValueMaker()=default;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAValueExpression.hpp b/src/core/expression/RBAValueExpression.hpp
new file mode 100644
index 0000000..111ad02
--- /dev/null
+++ b/src/core/expression/RBAValueExpression.hpp
@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+
+/**
+ * ValueExpression class header
+ */
+
+#ifndef RBAVALUEEXPRESSION_HPP
+#define RBAVALUEEXPRESSION_HPP
+
+#include "RBAExpression.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAValueExpression : public RBAExpression
+{
+protected:
+  RBAValueExpression()=default;
+  RBAValueExpression(const RBAValueExpression&)=delete;
+  RBAValueExpression(const RBAValueExpression&&)=delete;
+  RBAValueExpression& operator=(const RBAValueExpression&)=delete;
+  RBAValueExpression& operator=(const RBAValueExpression&&)=delete;
+public:
+  virtual ~RBAValueExpression()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAVariable.cpp b/src/core/expression/RBAVariable.cpp
new file mode 100644
index 0000000..9220c0a
--- /dev/null
+++ b/src/core/expression/RBAVariable.cpp
@@ -0,0 +1,79 @@
+/**
+ * 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.
+ */
+
+/**
+ * Variable class defintion
+ */
+
+#include "RBAVariable.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+RBAVariable::RBAVariable(const std::string& name)
+  : RBARuleObject{name}
+{
+}
+
+RBAModelElementType
+RBAVariable::getModelElementType() const
+{
+  return RBAModelElementType::Variable;
+}
+
+const RBARuleObject*
+RBAVariable::getRuleObj() const
+{
+  return ruleObj_;
+}
+
+void
+RBAVariable::setRuleObj(const RBARuleObject* const ruleObj)
+{
+  ruleObj_ = ruleObj;
+}
+
+void
+RBAVariable::clearRuleObj()
+{
+  ruleObj_ = nullptr;
+}
+
+RBAConstraintInfo*
+RBAVariable::createConstraintInfo()
+{
+  // When the "Let" expression is written in a lambda expression such as 
+  // "For-All", the expansion result of the "Let" expression also changes 
+  // each time the variable of "For-All" changes. Even if the Let expression 
+  // is written in "For-All", there is only one valiable object.
+  // Therefore, "constraintInfo" cannot be cleared and reused, and it is 
+  // necessary to do "make_shared" each time the "Let" expression is evaluated.
+  // The ownership of the "ConstraintInfo" of the "Let" expression is 
+  // transferred to the "ConstraintInfo" of the "RBAObjectReference" 
+  // when the RBAObjectReference that refers to the definition of the Let 
+  // expression is evaluated.
+  constraintInfo_ = std::make_shared<RBAConstraintInfo>();
+  return constraintInfo_.get();
+}
+
+std::shared_ptr<RBAConstraintInfo>
+RBAVariable::getConstraintInfo() const
+{
+  return constraintInfo_;
+}
+
+}
diff --git a/src/core/expression/RBAVariable.hpp b/src/core/expression/RBAVariable.hpp
new file mode 100644
index 0000000..88f071e
--- /dev/null
+++ b/src/core/expression/RBAVariable.hpp
@@ -0,0 +1,65 @@
+/**
+ * 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.
+ */
+
+/**
+ * Variable class header
+ */
+
+#ifndef RBAVARIABLE_HPP
+#define RBAVARIABLE_HPP
+
+#include <memory>
+#include "RBARuleObject.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAVariable : public RBARuleObject
+{
+public:
+  explicit RBAVariable(const std::string& name="");
+  RBAVariable(const RBAVariable&)=delete;
+  RBAVariable(const RBAVariable&&)=delete;
+  RBAVariable& operator=(const RBAVariable&)=delete;
+  RBAVariable& operator=(const RBAVariable&&)=delete;
+  virtual ~RBAVariable()=default;
+
+public:
+  RBAModelElementType getModelElementType() const override;
+
+  const RBARuleObject* getRuleObj() const;
+  void setRuleObj(const RBARuleObject* const ruleObj);
+  void clearRuleObj();
+  RBAConstraintInfo* createConstraintInfo();
+  std::shared_ptr<RBAConstraintInfo> getConstraintInfo() const;
+
+private:
+  const RBARuleObject* ruleObj_ {nullptr};
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::shared_ptr<RBAConstraintInfo> constraintInfo_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/expression/RBAVariableMaker.cpp b/src/core/expression/RBAVariableMaker.cpp
new file mode 100644
index 0000000..aa7d5e8
--- /dev/null
+++ b/src/core/expression/RBAVariableMaker.cpp
@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAVariableMaker.cpp
+/// @brief Variable object generator class definition
+
+#include "RBAVariableMaker.hpp"
+#include "RBAVariable.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAVariableMaker::RBAVariableMaker()
+  : RBAModelElementMaker::RBAModelElementMaker{"Variable"}
+{
+}
+
+RBAModelElement*
+RBAVariableMaker::create(const RBAJsonElement* jsonElem,
+                         RBAModelImpl* model,
+                         RBAModelElement* owner)
+{
+  // Register the instance without a name, because Variable has the same name
+  std::unique_ptr<RBAModelElement> inst
+    {createInstance(jsonElem->findChildren("name")->getString())};
+  const auto element = inst.get();
+  static_cast<void>(model->addModelElement(std::move(inst)));
+
+  return setProperty(element, jsonElem, model, owner);
+}
+
+std::unique_ptr<RBAModelElement>
+RBAVariableMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAVariable>(name);
+}
+
+RBAModelElement*
+RBAVariableMaker::setProperty(RBAModelElement* element,
+                              const RBAJsonElement* jsonElem,
+                              RBAModelImpl* model,
+                              RBAModelElement* owner)
+{
+  return element;
+}
+
+}
diff --git a/src/core/expression/RBAVariableMaker.hpp b/src/core/expression/RBAVariableMaker.hpp
new file mode 100644
index 0000000..e3d52e6
--- /dev/null
+++ b/src/core/expression/RBAVariableMaker.hpp
@@ -0,0 +1,70 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAVariableMaker.cpp
+/// @brief Variable object generator class header
+
+#ifndef RBAVARIABLEMAKER_HPP
+#define RBAVARIABLEMAKER_HPP
+
+#include "RBAModelElementMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Variable object generator class
+class RBAVariableMaker : public RBAModelElementMaker
+{
+public:
+  RBAVariableMaker();
+  RBAVariableMaker(const RBAVariableMaker&)=delete;
+  RBAVariableMaker(const RBAVariableMaker&&)=delete;
+  RBAVariableMaker& operator=(const RBAVariableMaker&)=delete;
+  RBAVariableMaker& operator=(const RBAVariableMaker&&)=delete;
+  virtual ~RBAVariableMaker()=default;
+
+public:
+  /// @brief Create ModelElement object
+  /// @details Create ModelElement object and register unique_ptr to model.
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store created object
+  /// @param[in,out] owner Parent object (Not in use)
+  /// @return ModelElement object
+  RBAModelElement* create(const RBAJsonElement* jsonElem,
+                          RBAModelImpl* model,
+                          RBAModelElement* owner=nullptr) override;
+
+protected:
+  /// @brief generate an empty instance
+  /// @details generate an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set attributes of model element for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store created object
+  /// @param[in,out] owner Parent object (Not in use)
+  /// @return ModelElement object
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAAffectInfo.cpp b/src/core/logic/RBAAffectInfo.cpp
new file mode 100644
index 0000000..6cf4e98
--- /dev/null
+++ b/src/core/logic/RBAAffectInfo.cpp
@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+
+/**
+ * AffectInfo class definition
+ */
+
+#include "RBAAffectInfo.hpp"
+
+namespace rba
+{
+
+/**
+ * @brief Returns whether the allocable already affects the target allocable
+ * @param allocatable Influential Allocatable
+ * @param affectAllocatable Affected Allocatable
+ * @return bool
+ */
+bool
+RBAAffectInfo::alreadyKnowsThatFormerHasAffectedToLatter(const RBAAllocatable* const allocatable,
+        const RBAAllocatable* const affectAllocatable) const
+{
+  for(const auto& alloc : reaffected_[allocatable]) {
+    if(alloc == affectAllocatable) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * @brief Register Affect information
+ * @param allocatable Influential Allocatable
+ * @param affectAllocatable Affected Allocatable
+ */
+void
+RBAAffectInfo::addInfoThatFormerAffectedToLatter(const RBAAllocatable* const allocatable,
+						 const RBAAllocatable* const affectAllocatable)
+{
+  static_cast<void>(reaffected_[allocatable].insert(affectAllocatable));
+}
+
+/**
+ * @brief Deletes the Affect information of "allocatable" registered by 
+ * 　　　　　　　other allocatables registered by arbitration of the specified 
+ * 　　　　　　　recursion hierarchy of the specified "allocatable".
+ * @param affectAllocatable
+ */
+void RBAAffectInfo::removeAffectInfo(const RBAAllocatable* const affectAllocatable)
+{
+  static_cast<void>(reaffected_.erase(affectAllocatable));
+}
+
+}
diff --git a/src/core/logic/RBAAffectInfo.hpp b/src/core/logic/RBAAffectInfo.hpp
new file mode 100644
index 0000000..c9c73be
--- /dev/null
+++ b/src/core/logic/RBAAffectInfo.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/**
+ * AffectInfo class header
+ */
+
+#ifndef RBAAFFECTINFO_HPP
+#define RBAAFFECTINFO_HPP
+
+#include <unordered_map>
+#include <set>
+
+namespace rba
+{
+
+class RBAAllocatable;
+
+class RBAAffectInfo
+{
+public:
+  RBAAffectInfo()=default;
+  RBAAffectInfo(const RBAAffectInfo&)=delete;
+  RBAAffectInfo(const RBAAffectInfo&&)=delete;
+  RBAAffectInfo& operator=(const RBAAffectInfo&)=delete;
+  RBAAffectInfo& operator=(const RBAAffectInfo&&)=delete;
+  virtual ~RBAAffectInfo()=default;
+
+public:
+  bool alreadyKnowsThatFormerHasAffectedToLatter(const RBAAllocatable* const allocatable,
+						 const RBAAllocatable* const affectAllocatable) const;
+  void addInfoThatFormerAffectedToLatter(const RBAAllocatable* const allocatable,
+					 const RBAAllocatable* const affectAllocatable);
+  void removeAffectInfo(const RBAAllocatable* const affectAllocatable);
+
+private:
+  // Information of other "allocatable" affected by "allocatable"
+  mutable std::unordered_map<const RBAAllocatable*,
+		   std::set<const RBAAllocatable*>>reaffected_;
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAArbitrator.cpp b/src/core/logic/RBAArbitrator.cpp
new file mode 100644
index 0000000..9fdd7d3
--- /dev/null
+++ b/src/core/logic/RBAArbitrator.cpp
@@ -0,0 +1,1987 @@
+/**
+ * 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.
+ */
+
+ /**
+ * Arbitrator class definition
+ */
+
+#include <algorithm>
+#include <sstream>
+#include "RBAArbitrator.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAResult.hpp"
+#include "RBAResultSet.hpp"
+#include "RBAAffectInfo.hpp"
+#include "RBAConstraintImpl.hpp"
+#include "RBAViewAction.hpp"
+#include "RBAViewTransition.hpp"
+#include "RBAViewMove.hpp"
+#include "RBARollbacker.hpp"
+#include "RBALogManager.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba {
+
+RBAArbitrator::RBAArbitrator(RBAModel* newModel)
+{
+  setModel(newModel);
+}
+
+#ifdef RBA_USE_LOG
+RBAArbitrator::RBAArbitrator(RBAModel* newModel, RBALogManager* logManager)
+{
+  setModel(newModel);
+  RBALogManager::setLogManager(logManager);
+  // Even if the argument logManager is null, it may be setLogManager() 
+  // from outside the rba, so it is determined by getLogManager() instead of 
+  // the argument determination.
+  if (RBALogManager::getLogManager() != nullptr) {
+    setSimulationMode(true);
+  }
+}
+#endif
+
+RBAArbitrator::~RBAArbitrator() noexcept
+{
+}
+
+void
+RBAArbitrator::setModel(RBAModel* newModel)
+{
+  setModel(dynamic_cast<RBAModelImpl*>(newModel));
+}
+
+const RBAModel*
+RBAArbitrator::getModel() const
+{
+  return dynamic_cast<RBAModel*>(model_);
+}
+
+void
+RBAArbitrator::initialize(std::list<std::string>& contexts)
+{
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  setRequestData(contexts, true);
+}
+
+std::unique_ptr<RBAResult>
+RBAArbitrator::execute(const std::string& contextName, bool require)
+{
+  const std::lock_guard<std::recursive_mutex> lock {getMutex()};
+  if (isValidContext(contextName) == false) {
+    // In case of error, creates a copy of "Result", 
+    // sets the error flag in it and returns
+    std::unique_ptr<RBAResultImpl> result {std::make_unique<RBAResultImpl>(
+        this, std::make_unique<RBAResultSet>(*getBackupResultSet()))};
+    result->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE);
+    return std::move(result);
+  } else {
+    static_cast<void>(setRequestData(contextName, require, nullptr,
+                      static_cast<std::uint32_t>(getRequestQue().size())));
+    return arbitrateMain();
+  }
+}
+
+std::unique_ptr<RBAResult>
+RBAArbitrator::execute(std::list<std::string>& contexts,
+		       bool require)
+{
+  const std::lock_guard<std::recursive_mutex> lock {getMutex()};
+  if (isValidContext(contexts) == false) {
+    // In case of error, creates a copy of "Result", 
+    // sets the error flag in it and returns
+    std::unique_ptr<RBAResultImpl> result {std::make_unique<RBAResultImpl>(
+        this, std::make_unique<RBAResultSet>(*getBackupResultSet()))};
+    result->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE);
+    return std::move(result);
+  } else {
+    setRequestData(contexts, require);
+    return arbitrateMain();
+  }
+}
+
+std::unique_ptr<RBAResult>
+RBAArbitrator::execute(const std::string& sceneName,
+		       std::list<std::pair<std::string,std::int32_t>>& properties)
+{
+  const std::lock_guard<std::recursive_mutex> lock {getMutex()};
+  // Check argument
+  if (isValidContext(sceneName) == false) {
+    // In case of error, creates a copy of "Result", 
+    // sets the error flag in it and returns
+    std::unique_ptr<RBAResultImpl> result {std::make_unique<RBAResultImpl>(
+        this, std::make_unique<RBAResultSet>(*getBackupResultSet()))};
+    result->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE);
+    return std::move(result);
+  } else {
+    static_cast<void>(setRequestData(sceneName, true, &properties,
+                      static_cast<std::uint32_t>(getRequestQue().size())));
+    return arbitrateMain();
+  }
+}
+
+std::unique_ptr<RBAResult>
+RBAArbitrator::setResultContentState(const std::string& allocatableName,
+				     const std::string& contextName)
+{
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  RBAResultSet* const backupResultSetTmp {getBackupResultSet().get()};
+  if (getReservedResultSet() == nullptr) {
+    setResult(std::make_unique<RBAResultImpl>(this,
+                                              std::make_unique<RBAResultSet>(),
+                                              std::move(getBackupResultSet())));
+  } else {
+    RBAResultSet* const reservedResultSetTmp {getReservedResultSet().get()};
+    setResult(std::make_unique<RBAResultImpl>(this,
+                                              std::move(getReservedResultSet()),
+                                              std::move(getBackupResultSet())));
+    setReservedResultSet(std::make_unique<RBAResultSet>(*reservedResultSetTmp));
+  }
+  setBackupResultSet(std::make_unique<RBAResultSet>(*backupResultSetTmp));
+  
+  // find allocatable
+  const RBAAllocatable* alloc {nullptr};
+  const RBAAreaImpl* const area {model_->findAreaImpl(allocatableName)};
+  if(area != nullptr) {
+    alloc = area;
+  }
+  else {
+    const RBAZoneImpl* const zone {model_->findZoneImpl(allocatableName)};
+    if(zone != nullptr) {
+      alloc = zone;
+    }
+  }
+  // find content state
+  const RBAContentState* state {nullptr};
+  const RBAViewContentStateImpl* const viewState
+    {model_->findViewContentStateImpl(contextName)};
+  if(viewState != nullptr) {
+    state = viewState;
+  }
+  else {
+    const RBASoundContentStateImpl* const soundState
+      {model_->findSoundContentStateImpl(contextName)};
+    if(soundState != nullptr) {
+      state = soundState;
+    }
+  }
+  if( (alloc == nullptr) || (state == nullptr) ) {
+    // Unknown context or allocatable
+    getResult()->setStatusType(RBAResultStatusType::UNKNOWN_CONTENT_STATE);
+    return std::move(getResultRef());
+  }
+  // Set alloc and state to result
+  const RBAContentState* const beforeContentState {alloc->getState()};
+  const_cast<RBAAllocatable*>(alloc)->setState(state);
+  const_cast<RBAAllocatable*>(alloc)->setChecked(true);
+  getResult()->setActive(state, true);
+  getResult()->setContentState(alloc, state);
+
+  // ----------------------------------------------------------
+  // Post processing of Arbitration
+  // ----------------------------------------------------------
+  postArbitrate();
+
+  // Excecute offline constraint
+#ifdef RBA_USE_LOG
+  checkAllConstraints();
+#endif
+
+  // ----------------------------------------------------------
+  // Update the state of Content
+  // ----------------------------------------------------------
+  if (beforeContentState != nullptr) {
+    // Update the state of the Content originally assigned to 
+    // the requested Allocatable
+    dynamic_cast<RBAContent*>(beforeContentState->getOwner())->updateStatus(getResultRef().get());
+  }
+  // Update the state of requested Content
+  dynamic_cast<RBAContent*>(state->getOwner())->updateStatus(getResultRef().get());
+
+  // Cancel processing of Content
+  checkCancelContent();
+
+  // Update display and non-display Area
+  updateResult();
+
+  // Generate Result
+  createResultData();
+
+  // Store backup of current arbitration result set
+  setBackupResultSet(getResult()->createBackupCurrentResultSet());
+  // Create next arbitration result set
+  setNextResultSet(getResult()->createNextCurrentResultSet());
+
+  return std::move(getResultRef());
+}
+
+std::unique_ptr<RBAResult>
+RBAArbitrator::cancelArbitration()
+{
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  if(getReservedResultSet() == nullptr) {
+    std::unique_ptr<RBAResultImpl> res
+      {std::make_unique<RBAResultImpl>(this,
+                                       std::make_unique<RBAResultSet>())};
+    res->setStatusType(RBAResultStatusType::CANCEL_ERROR);
+    return std::move(res);
+  }
+
+  setResult(
+      std::make_unique<RBAResultImpl>(this,
+                                      std::make_unique<RBAResultSet>(),
+                                      std::move(getReservedResultSet())));
+  setBackupResultSet(getResult()->createBackupCurrentResultSet());
+  setNextResultSet(getResult()->createNextCurrentResultSet());
+
+  return std::move(getResultRef());
+}
+
+void
+RBAArbitrator::clearArbitration()
+{
+  std::lock_guard<std::recursive_mutex> lock {getMutex()};
+  getCancelChecked().clear();
+  setReservedResultSet(nullptr);
+  setBackupResultSet(std::make_unique<RBAResultSet>());
+  for(const auto& scene : model_->getSceneImpls()) {
+    for(const std::string propertyName : scene->getPropertyNames()) {
+      const std::int32_t value {scene->getPropertyValue(propertyName)};
+      getBackupResultSet()->setSceneProperty(scene, propertyName, value);
+    }
+  }
+  setNextResultSet(
+      std::make_unique<RBAResultSet>(*getBackupResultSet().get()));
+  setResult(std::make_unique<RBAResultImpl>(
+      this,
+      std::make_unique<RBAResultSet>(*getBackupResultSet().get())));
+
+  model_->clearElementsStatus();
+}
+
+bool
+RBAArbitrator::setScene(const std::string& sceneName, bool require,
+			std::list<std::pair<std::string, std::int32_t>>& properties)
+{
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  return setRequestData(sceneName, require, &properties);
+}
+
+bool
+RBAArbitrator::setContentState(const std::string& contextName, bool require)
+{
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  const std::deque<std::unique_ptr<RBARequestQueMember>>& requestQue{getRequestQue()};
+  std::uint32_t syncIndex{static_cast<std::uint32_t>(requestQue.size())};
+  if (syncIndex > 0U ) {
+    const std::unique_ptr<RBARequestQueMember>& prevReq{requestQue.back()};
+    if (prevReq->isOn() == require) {
+      syncIndex = prevReq->getSyncIndex();
+    }
+  }
+  return setRequestData(contextName, require, nullptr, syncIndex);
+}
+
+bool
+RBAArbitrator::setAllocatableResult(const std::string& allocatableName,
+				    const std::string& contextName)
+{
+  std::lock_guard<std::recursive_mutex> lock {getMutex()};
+  // Get allocatable
+  const auto alloc = model_->findAllocatable(allocatableName);
+  if(alloc == nullptr) {
+    return false;
+  }
+
+  // Get context
+  const auto state = model_->findContentState(contextName);
+  if(state == nullptr) {
+    return false;
+  }
+
+  // Set state to allocatable
+  const auto beforeContentState = alloc->getState();
+  const_cast<RBAAllocatable*>(alloc)->setState(state);
+  RBAResultSet* const nextResultSet {getNextResultSet().get()};
+  RBAResultSet* const prevResultSet {getBackupResultSet().get()};
+  nextResultSet->setContentState(alloc, state);
+  prevResultSet->setContentState(alloc, state);
+  nextResultSet->setActive(state, true);
+  prevResultSet->setActive(state, true);
+
+  // ----------------------------------------------------------
+  // Update the state of Content
+  // ----------------------------------------------------------
+  // Create "result" and update state, because updating the content state 
+  // determines the transition destination this time 
+  // based on previous state.
+  setResult(std::make_unique<RBAResultImpl>(
+      this,
+      std::make_unique<RBAResultSet>(*getBackupResultSet()),
+      std::make_unique<RBAResultSet>(*getNextResultSet())));
+  RBAContent* const content {dynamic_cast<RBAContent*>(state->getOwner())};
+  content->updateRequestStatus(getResult()->getCurResultSet().get(), true);
+  if (beforeContentState != nullptr) {
+    // Update the state of the content originally assigned to 
+    // the requested Allocatable
+    dynamic_cast<RBAContent*>(beforeContentState->getOwner())->updateStatus(getResultRef().get());
+  }
+  // Update the state of requested Content
+  content->updateStatus(getResultRef().get());
+
+  setBackupResultSet(std::make_unique<RBAResultSet>(*getResult()->getPreResultSet()));
+  setNextResultSet(getResult()->createNextCurrentResultSet());
+
+  return true;
+}
+
+bool
+RBAArbitrator::RBAArbitrator::evaluate(RBAExpression* expression)
+{
+  if(expression == nullptr) {
+    return false;
+  }
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  RBAConstraintInfo info;
+  // Constraint expression evaluation
+  return expression->execute(&info, this);
+}
+
+const RBARuleObject*
+RBAArbitrator::evaluateObject(RBAExpression* expression)
+{
+  if(expression == nullptr) {
+    return nullptr;
+  }
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  RBAConstraintInfo info;
+  // Constraint expression evaluation
+  const RBARuleObject* const ruleObj
+    {expression->getReferenceObject(&info, this)};
+  if (ruleObj != nullptr) {
+    return ruleObj->getRawObject();
+  } else {
+    return nullptr;
+  }
+}
+
+int32_t
+RBAArbitrator::evaluateValue(RBAExpression* expression)
+{
+  if(expression == nullptr) {
+    return -99;
+  }
+  const std::lock_guard<std::recursive_mutex> lock{getMutex()};
+  RBAConstraintInfo info;
+  // Constraint expression evaluation
+  return expression->getValue(&info, this);
+}
+
+
+void
+RBAArbitrator::setModel(RBAModelImpl* const newModel)
+{
+  std::lock_guard<std::recursive_mutex> lock {getMutex()};
+  model_ = newModel;
+  model_->createSortedAllocatables();
+  clearArbitration();
+}
+
+bool
+RBAArbitrator::
+satisfiesConstraints() const
+{
+  const std::lock_guard<std::recursive_mutex> lock{mutex_};
+  // Temporarily store the actual result_ 
+  // because result_ is used for evaluation
+  std::unique_ptr<RBAResultImpl> tmpResult {std::move(result_)};
+  result_ = std::make_unique<RBAResultImpl>(
+      this,
+      std::make_unique<RBAResultSet>(*(reservedResultSet_.get())),
+      std::make_unique<RBAResultSet>(*(resultSetForSatisfiesConstraints_.get())));
+  bool result {true};
+  for(const RBAConstraintImpl*& constraint : model_->getConstraintImpls()) {
+    if (constraint->isRuntime() == true) {
+      result = const_cast<RBAConstraintImpl*>(constraint)->execute(const_cast<RBAArbitrator*>(this));
+      if (result == false) {
+        break;
+      }
+    }
+  }
+  result_ = std::move(tmpResult);
+  return result;
+}
+
+/**
+ * Execute arbitration
+ */
+std::unique_ptr<RBAResult>
+RBAArbitrator::arbitrateMain()
+{
+  // Store request state before arbitration, 
+  // in case cancelArbitration() is executed
+  reservedResultSet_ = std::make_unique<RBAResultSet>(*backupResultSet_);
+
+  // Differential arbitration for each request
+  if (requestQue_.empty()) {
+    // Prepare Result here because it will be used in differenceArbitrate.
+    result_ = std::make_unique<RBAResultImpl>(this,
+                                              std::move(backupResultSet_),
+                                              std::move(nextResultSet_));
+    // Arbitration request without arguments.
+    // there is a possibility of being queued in "requestQue_"
+    // due to "onDisplayed" in this, 
+    differenceArbitrate();
+  }
+  if (!requestQue_.empty()) {
+    result_ = std::make_unique<RBAResultImpl>(this,
+                                              std::move(backupResultSet_),
+                                              std::move(nextResultSet_));
+    do {
+      const std::unique_ptr<RBARequestQueMember> request {std::move(requestQue_.front())};
+      requestQue_.pop_front();
+      result_->setActive(request->getContentState(), request->isOn());
+      // Update the state of Content
+      RBAContent* const content {dynamic_cast<RBAContent*>(request->getContentState()->getOwner())};
+      content->updateRequestStatus(result_->getCurResultSet().get(), request->isOn());
+      if (requestQue_.empty()) {
+        differenceArbitrate();
+        if (!requestQue_.empty()) {
+          // Update "result_" for the next differenceArbitrate().
+          result_ = std::make_unique<RBAResultImpl>(this,
+                                                    std::move(backupResultSet_),
+                                                    std::move(nextResultSet_));
+        }
+      } else if (requestQue_.front()->getSyncIndex() != request->getSyncIndex()) {
+        differenceArbitrate();
+        // Update "result_" for the next differenceArbitrate().
+        result_ = std::make_unique<RBAResultImpl>(this,
+                                                  std::move(backupResultSet_),
+                                                  std::move(nextResultSet_));
+      } else {
+        // No Operation
+      }
+    } while (!requestQue_.empty());
+  }
+
+  result_ = std::make_unique<RBAResultImpl>(
+      this, std::make_unique<RBAResultSet>(*reservedResultSet_),
+      result_->createBackupCurrentResultSet());
+
+  // Cancel processing of Content
+  checkCancelContent();
+
+  // Update displayed and non-displayed Area
+  updateResult();
+
+#ifdef RBA_USE_LOG
+  RBALogManager::setType(RBALogManager::TYPE_RESULT);
+  logResultArbitration();
+
+  setLogToResult();
+  RBALogManager::setType(RBALogManager::TYPE_NOTHING);
+#endif
+
+  createResultData();
+  // Store backup of current arbitration result set
+  backupResultSet_ = result_->createBackupCurrentResultSet();
+  // Create next arbitration result set
+  nextResultSet_ = result_->createNextCurrentResultSet();
+
+  // The "result_" of the return value is changed to another name,
+  // because "result_" will be used for storing.
+  auto retResult = std::move(result_);
+
+  // Hold the arbitration result because the arbitration result may be used 
+  // in cases other than arbitration.
+  result_ = std::make_unique<RBAResultImpl>(retResult.get());
+
+  // A compile error occurs if std::move() is missing because 
+  // std::unique_ptr<RBAResultImpl>　is cast to std::unique_ptr<RBAResult>
+  return std::move(retResult);
+}
+
+bool
+RBAArbitrator::
+isValidContext(const std::string& context)
+{
+  if (context != "") {
+    const RBAContentState* const state {model_->findContentState(context)};
+    if (state == nullptr) {
+      const RBASceneImpl* const scene {model_->findSceneImpl(context)};
+      if (scene == nullptr) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+bool
+RBAArbitrator::
+isValidContext(std::list<std::string>& contexts)
+{
+  for(const std::string contextName : contexts) {
+    if(isValidContext(contextName) == false) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Reflect input information
+ */
+
+bool
+RBAArbitrator::setRequestData(
+    const std::string& context, bool require,
+    std::list<std::pair<std::string, std::int32_t>>* const properties,
+    std::uint32_t syncIndex)
+{
+  bool isSet {false};
+  if (context != "") {
+    // When content state is specified
+    // If contextName is the only content name, pop the first content state
+    const RBAContentState* state {model_->findContentState(context)};
+    if (state != nullptr) {
+      requestQue_.push_back( std::make_unique<RBARequestQueMember>(state, require, syncIndex));
+      isSet = true;
+    } else {
+      // When Scene is specified
+      const RBASceneImpl* const scene {model_->findSceneImpl(context)};
+      if (scene != nullptr) {
+        // for next arbitration
+        nextResultSet_->setActive(scene, require);
+        // For when "Result" is referenced before the next arbitration
+        result_->setActive(scene, require);
+        isSet = true;
+        if (properties != nullptr) {
+          for (auto& p : *properties) {
+            const RBAAbstractProperty* const ap {scene->getProperty(p.first)};
+            if (ap != nullptr) {
+              // for next arbitration
+              nextResultSet_->setSceneProperty(ap, p.second);
+              // For when "Result" is referenced before the next arbitration
+              result_->setSceneProperty(ap, p.second);
+            }
+          }
+        }
+      }
+    }
+  }
+  return isSet;
+}
+
+void
+RBAArbitrator::setRequestData(const RBAContentState* state,
+                                  bool require)
+{
+  if (requestQue_.empty()){
+    requestQue_.push_back( std::make_unique<RBARequestQueMember>(state, require, 0U));
+  } else {
+    requestQue_.push_back( std::make_unique<RBARequestQueMember>(state, require, requestQue_.back()->getSyncIndex()));
+  }
+}
+
+void
+RBAArbitrator::setRequestData(const RBAContent* const content,
+                                  bool require)
+{
+  if (requestQue_.empty()){
+    requestQue_.push_back( std::make_unique<RBARequestQueMember>(content->getStates().front(), require, 0U));
+  } else {
+    requestQue_.push_back( std::make_unique<RBARequestQueMember>(content->getStates().front(), require, requestQue_.back()->getSyncIndex()));
+  }
+}
+
+void
+RBAArbitrator::setActive(const RBASceneImpl* const scene, const bool require)
+{
+  if (nextResultSet_ != nullptr) {
+    // Update nextResultSet_" when onScene is done in onRequest or onWithdrawn
+    nextResultSet_->setActive(scene, require);
+  } else {
+    result_->setActive(scene, require);
+  }
+}
+
+void
+RBAArbitrator::setSceneProperty(const RBAAbstractProperty* const prop, const std::int32_t value)
+{
+  if (nextResultSet_ != nullptr) {
+    // Update nextResultSet_" when onScene is done in onRequest or onWithdrawn
+    nextResultSet_->setSceneProperty(prop, value);
+  } else {
+    result_->getCurResultSet()->setSceneProperty(prop, value);
+  }
+}
+
+void
+RBAArbitrator::setRequestData(std::list<std::string>& contexts,
+                              const bool require)
+{
+  const std::uint32_t syncIndex {static_cast<std::uint32_t>(requestQue_.size())};
+  for (auto& c : contexts) {
+    static_cast<void>(setRequestData(c, require, nullptr, syncIndex));
+  }
+}
+
+/**
+ * @brief Execute an extended version of arbitration that allows arbitration 
+          when the "implication" is false
+ * @param areas
+ */
+void
+RBAArbitrator::
+arbitrate(std::list<RBAAllocatable*>& allocatables)
+{
+  LOG_arbitrateAreaLogLine("----Arbitrate----");
+  std::set<const RBAAllocatable*> revisitedInitSet;
+
+  std::set<const RBAAllocatable*> revisited;
+  for (auto& alloc : allocatables) {
+    revisited = revisitedInitSet;
+    // -------------------------------------------------------------------------
+    // To prevent an infinite loop, generate information to limit registration 
+  　　// of other "allocable" that affected the target "allocatable" 
+    // during arbitration
+    // -------------------------------------------------------------------------
+    RBAAffectInfo affectInfo;
+    LOG_arbitrateAreaLogLine(
+        alloc->getSymbol() + "[" + alloc->getElementName() + "] check start");
+    arbitrateAllocatable(alloc, revisited, 0, &affectInfo, nullptr);
+  }
+  for (auto& a : model_->getSortedAllocatables()) {
+    result_->setContentState(a, a->getState());
+  }
+}
+
+/**
+ * @brief Recursively arbitrate "allocatable"
+ * @param allocatable Allocatable that you want to arbitrate
+ * @param revisited Allocatable that re-arbitration is complete
+ * @param nest Re-arbitration nesting hierarchy (first arbitration is zero)
+ * @param affectInfo Allocatable information affected by "allocatable"
+ */
+void RBAArbitrator::arbitrateAllocatable(
+    RBAAllocatable* allocatable,
+    std::set<const RBAAllocatable*>& revisited,
+    const std::int32_t nest,
+    RBAAffectInfo* const affectInfo,
+    RBARollbacker* const parentRollbacker)
+{
+#ifdef RBA_USE_LOG
+  RBALogManager::setIndent(nest);
+#endif
+  // "Allocable" affected by "Allocable" which is the target of this arbitration
+  // during the recursive process until this variable is defined,
+  std::set<const RBAAllocatable*> affectAllocatables;
+  affectAllocatables.insert(allocatable->getAllocatablesAffectedByYou().begin(),
+                            allocatable->getAllocatablesAffectedByYou().end());
+
+  const RBAContentState* const beforeState {allocatable->getState()};
+
+  // Mark Content allocation for target Allocable" as "checked"
+  allocatable->setChecked(true);
+  // Get content status sorted by arbitration policy
+  // (only active requests)
+  std::list<const RBAContentState*> contentStates;
+  getSortedContentStates(allocatable, contentStates);
+  for(const RBAContentState* const contentState : contentStates) {
+    // Allocate Content to Area
+    allocatable->setState(contentState);
+#ifdef RBA_USE_LOG
+    {
+      std::string str = "  Content[";
+      if (contentState == nullptr) {
+        str += "null";
+      } else {
+        str += contentState->getOwner()->getElementName() + "::"
+            + contentState->getElementName();
+      }
+      str += "] check online constraints start";
+      RBALogManager::arbitrateContentLogLine(str);
+    }
+#endif
+    bool isSkipped {false};
+    const bool isPassed {checkConstraintAndReArbitrate(
+        allocatable, revisited, nest, affectInfo, parentRollbacker,
+        allocatable->getConstraints(), &isSkipped, false)};
+    if (isPassed == true) {
+
+      // ----------------------------------------------------------
+      // Check if self-allocatable should be hidden 
+      // by constraint expression after content allocation process.
+      // Check even if content is not assigned because there is contentValue()
+      // ----------------------------------------------------------
+#ifdef RBA_USE_LOG
+      std::string alloSymbol = allocatable->getSymbol();
+      std::string alloName = allocatable->getElementName();
+      if (allocatable->isArea() == true) {
+        LOG_arbitrateAreaLogLine(
+            "  check online constraints to confirm area hidden state");
+      } else {
+        LOG_arbitrateAreaLogLine(
+            "  check online constraints to confirm zone muted state");
+      }
+#endif
+      // Mark "hidden" of target "Allocable" as "checked"
+      allocatable->setHiddenChecked(true);
+      // Set "hidden" of target "Allocable" to false
+      allocatable->setHidden(false);
+      bool hiddenIsPassed {checkConstraintAndReArbitrate(
+          allocatable, revisited, nest, affectInfo, parentRollbacker,
+          allocatable->getHiddenFalseCheckConstraints(), &isSkipped, 
+          !allocatable->isZone())};
+      if (hiddenIsPassed == false) {
+        allocatable->setHidden(true);
+        hiddenIsPassed = checkConstraintAndReArbitrate(
+            allocatable, revisited, nest, affectInfo, parentRollbacker,
+            allocatable->getHiddenTrueCheckConstraints(), &isSkipped, 
+            !allocatable->isZone());
+        if (hiddenIsPassed == false) {
+          // Clear hiding state of Allocatable
+          allocatable->setHiddenChecked(false);
+        } else {
+          LOG_arbitrateAreaLogLine(
+              alloSymbol + "[" + alloName + "] change "
+                  + allocatable->getHiddenSymbol());
+        }
+      }
+
+      // -------------------------------------
+      // For Zone, judge attenuation after hiding (mute)
+      // -------------------------------------
+      bool attenuateIsPassed {true};
+      if (allocatable->isZone()) {
+        RBAZoneImpl* const zone {dynamic_cast<RBAZoneImpl*>(allocatable)};
+        // Mark "attenuattion" of target "Zone" as checked"
+        zone->setAttenuateChecked(true);
+        // Set "attenuattion" of target "Zone" to false
+        zone->setAttenuated(false);
+        LOG_arbitrateAreaLogLine(
+            "  check online constraints to confirm zone attenuated state");
+        attenuateIsPassed = checkConstraintAndReArbitrate(
+            allocatable, revisited, nest, affectInfo, parentRollbacker,
+            allocatable->getAttenuateFalseCheckConstraints(), &isSkipped, true);
+        if (attenuateIsPassed == false) {
+          zone->setAttenuated(true);
+          attenuateIsPassed = checkConstraintAndReArbitrate(
+              allocatable, revisited, nest, affectInfo, parentRollbacker,
+              allocatable->getAttenuateTrueCheckConstraints(), &isSkipped, true);
+          if (attenuateIsPassed == false) {
+            allocatable->setAttenuateChecked(false);
+          } else {
+            LOG_arbitrateAreaLogLine(
+                alloSymbol + "[" + alloName + "] change attenuated");
+          }
+        }
+      }
+#ifdef RBA_USE_LOG
+      {
+        std::string str = alloSymbol + "[" + alloName + "] ";
+        if (allocatable->isArea() == true) {
+          str += "displays";
+        } else {
+          str += "outputs";
+        }
+        str += " Content[";
+        const RBAContentState* state = allocatable->getState();
+        if (state == nullptr) {
+          str += "null";
+        } else {
+          str += state->getOwner()->getElementName() + "::"
+            + state->getElementName();
+        }
+        str += "] " + allocatable->getHiddenSymbol() + "["
+            + RBALogManager::boolToString(allocatable->isHidden()) + "]";
+        if (allocatable->isZone() == true) {
+          str += " attenuated["
+              + RBALogManager::boolToString(allocatable->isAttenuated()) + "]";
+        }
+        str += "\n";
+        LOG_arbitrateAreaLogLine(str);
+      }
+#endif
+      if ((hiddenIsPassed == true) && (attenuateIsPassed == true)) {
+        break;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------
+  // Re-arbitration of the Allocatable　that influenced
+  // ---------------------------------------------------------------------
+  if ((beforeState != allocatable->getState())
+          || allocatable->isHidden()
+          || allocatable->isAttenuated()) {
+
+    // Re-arbitration is performed in a state other than "hidden" 
+    // When allocating content. Therefore, if state become "hidden" or 
+    // "attenuation", re-arbitration is required for the "allocatable" 
+    // that was affected by re-arbitration during content allocation.
+    // Update the increased Area that influenced
+    if (allocatable->isHidden() || allocatable->isAttenuated()) {
+      for (const auto& a : allocatable->getAllocatablesAffectedByYou()) {
+        static_cast<void>(affectAllocatables.insert(a));
+      }
+    }
+
+    // If the re-arbitration source of Area/Zone (including any re-arbitration
+    // sources, if any reconciliation nests) becomes an Area/Zone affected by 
+    // the re-arbitration area/zone, such Area/Zone is excluded from 
+    // the re-arbitration target and the affected Area/Zone is re-arbitrated.
+    // Further, even if the affected Area/Zone is unarbitrated Allocatable
+    // at that time, it is excluded from the re-arbitration target of 
+    // the affected Area. This is because it is sufficient to arbitrate 
+    // during normal arbitration. 
+    for (const auto& a : revisited) {
+      if (affectAllocatables.find(a) != affectAllocatables.end()
+          || (!a->isChecked())) {
+        static_cast<void>(affectAllocatables.erase(a));
+      }
+    }
+    std::list<const RBAAllocatable*> sortedAllocatables(affectAllocatables.begin(),affectAllocatables.end());
+    sortedAllocatables.sort(&RBAAllocatable::compareIndex);
+    if (parentRollbacker != nullptr) {
+      std::shared_ptr<RBARollbacker> rollbacker {std::make_shared<RBARollbacker>()};
+      parentRollbacker->addChild(rollbacker);
+      rollbacker->backup(sortedAllocatables);
+    }
+
+    for (auto& affect : sortedAllocatables) {
+      // Remove Allocatable which will be re-arbitration from Allocatable 
+      // that influenced Allocable during arbitration.
+      allocatable->removeAffectAllocatable(affect);
+    }
+    static_cast<void>(revisited.insert(allocatable)); // Add to arbitrated Area
+    for (auto& affectAllocatable : sortedAllocatables) {
+      // @Deviation (EXP55-CPP,Rule-5_2_5,A5-2-3)
+      // [Contents that deviate from the rules]
+      //  This is a 'const_cast' expression that strips away a 'const' or 
+      //  'volatile' qualifier.
+      // [Why there is no problem if it deviate from the rules]
+    　　//  Confirmed that there is no problem from the design point of view.
+      //  We won't fix it now because we need to redesign the class, but
+      //  no much effort as of now.
+      RBAAllocatable* allo {const_cast<RBAAllocatable*>(affectAllocatable)};
+
+      // Initialize the check flag of the Allocatable that performs the 
+      // re-arbitration of the affetcted Allocatable
+      // If the affected Allocables are cleared in advance, a skip occurred in 
+      // the constraint expression evaluation during the re-arbitration of 
+      // the affected Allocatable that was carried out earlier, after that 
+      // re-arbitration will work during re-arbitration of affected Allocatable.
+      // Therefore, clear check flag individually 
+      // before re-arbitration of affected Allocable
+      allo->clearChecked();
+
+      LOG_arbitrateAreaLogLine( "    " +
+          affectAllocatable->getSymbol() + "["
+                                + affectAllocatable->getElementName()
+                                + "] affect allocatable check start");
+      // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+      // [Contents that deviate from the rules]
+      //  Recursively calling arbitrateAllocatable()
+      // [Why there is no problem if it deviate from the rules]
+      //  - This process is necessary for re-arbitration of the affected Area, 
+      //  - stack overflow will not occur becasue the infinite loop 
+      //    prevention process is imeplemented.
+      arbitrateAllocatable(allo, revisited, nest + 1, affectInfo,
+                           parentRollbacker);
+    }
+    for(const RBAAllocatable* const revisitAllocatable : sortedAllocatables) {
+      static_cast<void>(revisited.erase(revisitAllocatable));
+    }
+  }
+
+  // --------------------------------------------------
+  // Delete temporary affect information 
+  // to prevent infinite loop during re-arbitration
+  // --------------------------------------------------
+  affectInfo->removeAffectInfo(allocatable);
+#ifdef RBA_USE_LOG
+  RBALogManager::setIndent(nest-1);
+#endif
+}
+
+/**
+ * @brief Sort content state based on arbitration policy
+ * @param allocatable
+ * @param contentStates
+ * @return success/failure of sort
+ */
+bool
+RBAArbitrator::
+sortContentStates(const RBAAllocatable* const allocatable,
+                  std::list<const RBAContentState*>& states) const
+{
+  bool isResult {true};
+  switch(allocatable->getAllocatableArbitrationPolicy()) {
+  case RBAArbitrationPolicy::FIRST_COME_FIRST:
+	states.sort(&RBAContentState::compareFirstComeFirst);
+    break;
+  case RBAArbitrationPolicy::LAST_COME_FIRST:
+	states.sort(&RBAContentState::compareLastComeFirst);
+    break;
+  case RBAArbitrationPolicy::PRIORITY_FIRST_COME_FIRST:
+	states.sort(&RBAContentState::comparePriorityFirstComeFirst);
+    break;
+  case RBAArbitrationPolicy::DEFAULT:
+  case RBAArbitrationPolicy::PRIORITY_LAST_COME_FIRST:
+	states.sort(&RBAContentState::comparePriorityLastComeFirst);
+    break;
+  default:
+    isResult = false;
+    break;
+  }
+
+  return isResult;
+}
+
+/**
+ * @brief Get re-arbitration list from judgment NG constraint
+ * @param totalRevisitAllocatables
+ * @param allocatable
+ * @param falseConstraints
+ * @param revisited
+ */
+void
+RBAArbitrator::
+collectRevisitAllocatable(std::list<const RBAAllocatable*>* const totalRevisitAllocatables,
+        RBAAllocatable*& allocatable,
+        std::list<RBAConstraintImpl*>& falseConstraints,
+        std::set<const RBAAllocatable*>& revisited)
+{
+  std::set<const RBAAllocatable*> revisitAllocatablesSet;
+
+　　// Determine if re-arbitration should be done based on the constraint 
+  // that the determination was NG
+  for(RBAConstraintImpl*& constraint : falseConstraints) {
+    // Get Contraint information
+    const RBAConstraintInfo* const info {constraint->getInfo()};
+    // Allocatable, a candidate for re-arbitration
+    std::set<const RBAAllocatable*> rightFalseAllocatables;
+
+    if (info->needsRearbitrationFor(allocatable)) {
+      info->collectRearbitrationTargetFor(allocatable, rightFalseAllocatables, false);
+    }
+    if (rightFalseAllocatables.empty()) {
+      // Non-implication constraint　expression
+      // To ensure that "currently arbitrated allocable" does not lose to lower 
+      // priority allocable, arbitration of low priority Allocable is performed 
+      // if low priority Allocable is included in 
+      // "re-arbitration candidate Allocable".
+      info->collectFalseAllocatables(rightFalseAllocatables);
+      bool isContainsLowPriorityAllocatable {false};
+      for(const RBAAllocatable* const rightFalseAllocatable
+	    : rightFalseAllocatables) {
+        if(RBAAllocatable::compareIndex(allocatable,rightFalseAllocatable)) { 
+        // index is smaller for higher priority allocable
+          isContainsLowPriorityAllocatable = true;
+          break;
+        }
+      }
+      if(!isContainsLowPriorityAllocatable) {
+        continue;
+      }
+    }
+
+    // Remove Allocable during arbitration from re-arbitration target
+    static_cast<void>(rightFalseAllocatables.erase(allocatable));
+
+    // If even one Allocable candidate for re-arbitration has been 
+    // re-arbitrated, re-arbitration will not be performed again.
+    // Go to next content assignment
+    for(const RBAAllocatable* const rightFalseAllocatable : rightFalseAllocatables) {
+      if(revisited.find(rightFalseAllocatable) != revisited.end()) {
+        return;
+      }
+    }
+
+    // Set re-arbitration Allocable
+    for(const RBAAllocatable* const alloc : rightFalseAllocatables) {
+      static_cast<void>(revisitAllocatablesSet.insert(alloc));
+    }
+  }
+
+  // Re-arbitration Allocatable exists
+  if(!(revisitAllocatablesSet.empty())) {
+    // copy std::set to std::list 
+    static_cast<void>(totalRevisitAllocatables->insert(totalRevisitAllocatables->end(), 
+                      revisitAllocatablesSet.begin(), 
+                      revisitAllocatablesSet.end()));
+    // Sort re-arbitration Areas in ascending order based on priority
+    // It is necessary to sort by index comparison considering the order of models.
+    totalRevisitAllocatables->sort(&RBAAllocatable::compareIndex);
+  }
+}
+
+/**
+ * Confirm cancellation of all content status 
+ * to cancel Request which lost in arbitration
+ */
+void
+RBAArbitrator::
+postArbitrate()
+{
+#ifdef RBA_USE_LOG
+  RBALogManager::cancelRequestLogLine("----Cancel Request----");
+#endif
+  for(const RBAContentState* const state : model_->getContentStates()) {
+#ifdef RBA_USE_LOG
+    RBALogManager::cancelRequestLogLine("Content["+
+			     state->getOwner()->getElementName()+"::"+
+			     state->getElementName()+
+			     "] check start");
+#endif
+    static_cast<void>(cancelChecked_.insert(state));
+    if(!result_->isActive(state)) {
+#ifdef RBA_USE_LOG
+	    RBALogManager::cancelRequestLogLine("  Content["+
+				 state->getOwner()->getElementName()+"::"+
+				 state->getElementName()+
+				 "] is not Active skip");
+#endif
+      continue;
+    }
+    if(result_->isAlreadyOutputting(state)) {
+#ifdef RBA_USE_LOG
+      std::string contTypeName;
+      if(state->isViewContentState()) {
+        contTypeName = "Visible";
+      }
+      else {
+        contTypeName = "Sounding";
+      }
+      RBALogManager::cancelRequestLogLine("  Content["+
+                                          state->getOwner()->getElementName()+"::"+
+                                          state->getElementName()+
+                                          "] is "+contTypeName+" skip");
+#endif
+      continue;
+    }
+
+    changeContentStateCancelWithPolicy(state);
+  }
+
+#ifdef RBA_USE_LOG
+  // Log output for coverage of request cancellation
+  for(const RBAContentState* state : model_->getContentStates()) {
+    std::string contentName = state->getOwner()->getElementName();
+    std::string stateName = state->getElementName();
+    std::string canceled = isCancel(state) ? "t" : "f";
+    RBALogManager::coverageCanceledRequestLogLine(
+        contentName + "," + stateName + ',' +canceled);
+  }
+#endif
+}
+
+/**
+ * @brief Change the cancellation information of hidden Content status 
+          based on arbitration results and cancellation policy
+ * @param state
+ */
+void
+RBAArbitrator::
+changeContentStateCancelWithPolicy(const RBAContentState* const state)
+{
+  switch(dynamic_cast<RBAContent*>(state->getOwner())->getContentLoserType()) {
+  case RBAContentLoserType::GOOD_LOSER:
+#ifdef RBA_USE_LOG
+     RBALogManager::cancelRequestLogLine("  Content["+
+                              state->getOwner()->getElementName()+"::"+
+                              state->getElementName()+
+                              "] is Canceled because GOOD_LOSER");
+#endif
+    setCancel(state, true);
+    break;
+  case RBAContentLoserType::NEVER_GIVEUP:
+#ifdef RBA_USE_LOG
+    RBALogManager::cancelRequestLogLine("  Content["+
+                             state->getOwner()->getElementName()+"::"+
+                             state->getElementName()+
+                             "] is not Canceled because NEVER_GIVEUP");
+#endif
+    setCancel(state, false);
+    break;
+  case RBAContentLoserType::DO_NOT_GIVEUP_UNTIL_WIN:
+    if(state->isModelElementType(RBAModelElementType::ViewContentState)) {
+      if(result_->isPreVisible(dynamic_cast<const RBAViewContentStateImpl*>(state))) {
+#ifdef RBA_USE_LOG
+        RBALogManager::cancelRequestLogLine("  Content["+
+                                 state->getOwner()->getElementName()+"::"+
+                                 state->getElementName()+
+                                 "] is Canceled because DO_NOT_GIVEUP_UNTIL_WIN");
+#endif
+        setCancel(state, true);
+      } else {
+#ifdef RBA_USE_LOG
+        RBALogManager::cancelRequestLogLine("  Content["+
+                                 state->getOwner()->getElementName()+"::"+
+                                 state->getElementName()+
+                                 "] is not Canceled because DO_NOT_GIVEUP_UNTIL_WIN");
+#endif
+        setCancel(state, false);
+      }
+    }
+    else {
+      if(result_->isPreSounding(dynamic_cast<const RBASoundContentStateImpl*>(state))) {
+        setCancel(state, true);
+      } else {
+        setCancel(state, false);
+      }
+    }
+    break;
+  default:
+    break;
+  }
+}
+
+#ifdef RBA_USE_LOG
+void
+RBAArbitrator::
+checkAllConstraints()
+{
+  std::string log;
+  LOG_arbitrateConstraintLogLine("----Check All Constraint----");
+
+  if(simulationMode_) {
+    for(const RBAConstraintImpl* constraint : model_->getConstraintImpls()) {
+      bool result = const_cast<RBAConstraintImpl*>(constraint)->execute(this);
+      if(result == false) {
+	result_->addFailedConstraint(constraint);
+      }
+      if (constraint->isRuntime() == true) {
+        log += "online  ";
+      } else {
+        log += "offline ";
+      }
+      log += "constraint[" + constraint->getElementName() + "] ";
+      log += "result[" + RBALogManager::boolToString(result) + "]\n";
+    }
+    if (log.empty() != true ) {
+      log.erase(log.end() - 1, log.end()); // Remove last line break
+    }
+  }
+
+}
+#endif
+
+void
+RBAArbitrator::
+checkCancelContent() const
+{
+  for(const RBAViewContentState* const viewState
+	: result_->getActiveViewContentStates()) {
+    if(result_->isCancel(viewState)) {
+      result_->cancelContentState(dynamic_cast<const RBAContentState*>(viewState));
+    }
+  }
+  for(const RBASoundContentState* const soundState
+	: result_->getActiveSoundContentStates()) {
+    if(result_->isCancel(soundState)) {
+      result_->cancelContentState(dynamic_cast<const RBAContentState*>(soundState));
+    }
+  }
+}
+
+/**
+ * @brief Update display and non-dislay Allocatable List
+ */
+void
+RBAArbitrator::
+updateResult()
+{
+  // Deactivate canceled Content
+  result_->updateActiveContentStates();
+
+  // Update coordinates　of Area 
+  for(auto& area : result_->getVisibleAreas()) {
+    const RBAAreaImpl* const areaImpl {dynamic_cast<const RBAAreaImpl*>(area)};
+    const auto posCont = model_->findPositionContainerImpl(area->getName());
+    const auto sizeObj = result_->getSize(area);
+    if((posCont != nullptr) && (sizeObj != nullptr)) {
+      const auto offset = posCont->getOffset(sizeObj->getName());
+      const_cast<RBAAreaImpl*>(areaImpl)->setOffsetX(offset.first);
+      const_cast<RBAAreaImpl*>(areaImpl)->setOffsetY(offset.second);
+    }
+  }
+
+  // Set output Content state list
+  std::set<const RBAContentState*> outputtingContentStateSet;
+  for(auto& alloc : result_->getOutputtingAllocatables()) {
+    const auto state = result_->getAllocatedContentState(alloc);
+    static_cast<void>(outputtingContentStateSet.insert(state));
+  }
+  for(auto& state : outputtingContentStateSet) {
+    static_cast<void>(result_->addOutputtingContentState(state));
+  }
+  
+  for(auto& state : result_->getActiveContentStates()) {
+    // If the Area allocated in the display request is not displayed, 
+    // set it to "Stanby Content".
+    const auto allocs = result_->getAllocatable(state);
+    if(allocs.empty()) {
+      result_->addStandbyContent(dynamic_cast<RBAContent*>(state->getOwner()));
+    }
+  }
+}
+
+/**
+ * ### Generate result information
+ *
+ * Generate animation information (RBAViewAction) and register it in the 
+ * viewActions list of RBAResult.
+ * The animation information generation pattern is as follows.
+ * | Area A(pre)  | Area B(pre) | Area A(cur)  | Area B(cur) | type               |
+ * |:-:           |:-:          |:-:           |:-:          |:----               |
+ * | (none)       | -           | **content**  | -           | TRANSITON_ADD      |
+ * | **content**  | -           | (none)       | -           | TRANSITION_REMOVE  |
+ * | **contentA** | -           | **contentB** | -           | TRANSITION_REPLACE |
+ * | **content**  | (none)      | (none)       | **content** | MOVE               |
+ */
+void
+RBAArbitrator::
+createResultData()
+{
+  std::list<std::unique_ptr<RBAViewAction>> actions;
+  // Check the Areas that have not changed
+  std::set<const RBAArea*> stableAreas;
+  for(const RBAArea* const preArea : result_->getPreVisibleAreas()) {
+    if(result_->isVisible(preArea)) {
+      const RBAViewContent* const curContent {result_->getContentState(preArea)->getOwner()};
+      const RBAViewContent* const preContent {result_->getPreContentState(preArea)->getOwner()};
+      if(curContent == preContent) {
+        static_cast<void>(stableAreas.insert(preArea));
+      }
+    }
+  }
+  // Check "MOVE"
+  std::set<const RBAViewContent*> movedContents;
+  for(const RBAArea* curArea : result_->getVisibleAreas()) {
+    // Current display Area
+    const RBAViewContentState* curState {result_->getContentState(curArea)};
+    const RBAViewContent* const curContent {curState->getOwner()};
+    // Skip stable Area
+    if(stableAreas.find(curArea) != stableAreas.end()) {
+      continue;
+    }
+    for(const RBAArea* preArea : result_->getPreVisibleAreas()) {
+      // Do not consider stable areas to have changed
+      if (stableAreas.find(preArea) != stableAreas.end()) {
+    	  continue;
+      }
+      // Previous display Area
+      const RBAViewContent* const preContent {result_->getPreContentState(preArea)->getOwner()};
+      if(curContent == preContent) {
+        // "MOVE" if there is matching content
+        actions.push_back(std::make_unique<RBAViewMove>(preArea, curArea,
+							curState));
+        // Check moved Content
+        static_cast<void>(movedContents.insert(curState->getOwner()));
+      }
+    }
+  }
+  // Check "REMOVE"
+  for(const RBAArea* preArea : result_->getPreVisibleAreas()) {
+    // Skip  stable Area
+    if(stableAreas.find(preArea) != stableAreas.end()) {
+      continue;
+    }
+    const RBAViewContentState* preState {result_->getPreContentState(preArea)};
+    // Skip if Content is "MOVE"
+    if(movedContents.find(preState->getOwner())
+       != movedContents.end()) {
+      continue;
+    }
+    if(!result_->isVisible(preArea)) {
+      // If the previously displayed Area isn't displayed, it is REMOVE.
+      actions.push_back(std::make_unique<RBAViewTransition>(
+          RBAViewActionType::TRANSITION_REMOVE, preArea, preState));
+    }
+  }
+  // Check Examine ADD/REMOVE and REPLACE related to MOVE
+  for(const RBAArea* curArea : result_->getVisibleAreas()) {
+    // Display Area at this time
+    // Skip stable Area
+    if(stableAreas.find(curArea) != stableAreas.end()) {
+      continue;
+    }
+    const RBAViewContentState* curState {result_->getContentState(curArea)};
+    const RBAViewContent* const curContent {curState->getOwner()};
+    const RBAViewContentState* preState {result_->getPreContentState(curArea)};
+    
+    if(movedContents.find(curContent) != movedContents.end()) {
+      if((preState != nullptr) && (!result_->isVisible(preState))) {
+        // If the previously displayed content isn't displayed, it is REMOVE.
+        actions.push_back(std::make_unique<RBAViewTransition>(
+			  RBAViewActionType::TRANSITION_REMOVE,
+			  curArea, preState));
+      }
+      else {
+	continue;
+      }
+    }
+    else if(result_->isPreVisible(curArea)) {
+      // It was the display Area last time
+      // If pre is MOVE content
+      const RBAViewContent* const preContent {preState->getOwner()};
+      if(movedContents.find(preContent) != movedContents.end()) {
+        // Content at this time is ADD
+        actions.push_back(std::make_unique<RBAViewTransition>(
+		          RBAViewActionType::TRANSITION_ADD,
+			  curArea, curState));
+      }
+      else if(curContent != preContent) {
+        // REPLACE because the content is different
+        actions.push_back(std::make_unique<RBAViewTransition>(
+			  RBAViewActionType::TRANSITION_REPLACE,
+			  curArea, preState, curState));
+      } else {
+        ;
+      }
+    }
+    else {
+      // ADD because it was not the display Area last time
+      actions.push_back(std::make_unique<RBAViewTransition>(
+			RBAViewActionType::TRANSITION_ADD,
+			curArea, curState));
+    }
+  }
+
+  // Sort and register
+  actions.sort(&compareViewAction);
+  for(auto& action : actions) {
+    result_->addViewAction(action);
+  }
+}
+
+void
+RBAArbitrator::differenceArbitrate()
+{
+#ifdef RBA_USE_LOG
+  // Set request information in log
+  RBALogManager::setType(RBALogManager::TYPE_REQUEST);
+  logRequestArbitration();
+  RBALogManager::setType(RBALogManager::TYPE_PREVIOUS_RESULT);
+  logPreResultArbitration();
+  logRequestForCoverage();
+#endif
+
+  for (auto& a : model_->getSortedAllocatables()) {
+    a->clearStatus();
+  }
+
+  // ----------------------------------------------------------
+  // Arbitration
+  // ----------------------------------------------------------
+  // Priority and post-win arbitoration
+  // (Value arbitration is the same as priority arbitration)
+#ifdef RBA_USE_LOG
+RBALogManager::setType(RBALogManager::TYPE_ARBITRATE);
+#endif
+  arbitrate(model_->getSortedAllocatables());
+
+  // ----------------------------------------------------------
+  // Post processing of arbitration
+  // ----------------------------------------------------------
+#ifdef RBA_USE_LOG
+RBALogManager::setType(RBALogManager::TYPE_CANCEL_REQUEST);
+#endif
+  // when the constraint expression is evaluated by satisfiesConstraints(),
+  // if the cancel state is different from the time when execute() is executed, 
+  // the result may be false. Therefore, it is necessary to store 
+  // the state before cancellation processing.
+  // When performing the constraint expression evaluation in 
+  // satisfiedConstraints(), restore to this value and evaluate.
+  resultSetForSatisfiesConstraints_ = std::make_unique<RBAResultSet>(
+      *result_->getCurResultSet());
+  postArbitrate();
+
+  // Move offline Constraint
+#ifdef RBA_USE_LOG
+RBALogManager::setType(RBALogManager::TYPE_CHECK_ALL_CONSTRAINTS);
+  checkAllConstraints();
+#endif
+
+  // ----------------------------------------------------------
+  // Update Content state
+  // ----------------------------------------------------------
+  for (auto& c : model_->getContents()){
+    const_cast<RBAContent*>(c)->updateStatus(result_.get());
+  }
+
+  backupResultSet_ = result_->createBackupCurrentResultSet();
+  nextResultSet_ = result_->createNextCurrentResultSet();
+
+#ifdef RBA_USE_LOG
+  logResultForCoverage();
+#endif
+}
+
+bool
+RBAArbitrator::
+checkConstraints( std::list<RBAConstraintImpl*>& constraints,
+                  std::list<RBAConstraintImpl*>& falseConstraints,
+                  const RBAAllocatable* const allocatable)
+{
+  bool containsSkip {false};
+  for (const auto& constraint : constraints) {
+    const bool isPassed {constraint->execute(this)};
+    if (isPassed == false) {
+      falseConstraints.push_back(constraint);
+    }
+    if (constraint->getInfo()->isExceptionBeforeArbitrate()) {
+      if (constraint->getInfo()->needsReRearbitrationFor(allocatable)) {
+        containsSkip = true;
+      }
+    }
+  }
+  return containsSkip;
+}
+
+bool
+RBAArbitrator::
+checkConstraintAndReArbitrate(RBAAllocatable* allocatable,
+                              std::set<const RBAAllocatable*>& revisited,
+                              const std::int32_t nest,
+                              RBAAffectInfo* const affectInfo,
+                              RBARollbacker* const parentRollbacker,
+                              std::list<RBAConstraintImpl*>& constraints,
+                              bool * const isSkipped,
+                              const bool isFinal)
+{
+  bool isPassed {false};
+  std::list<RBAConstraintImpl*> falseConstraints;
+  const bool containsSkip {checkConstraints(constraints, falseConstraints, allocatable)};
+  if(falseConstraints.empty()) {
+    *isSkipped = (*isSkipped || containsSkip);
+    if(!containsSkip && !*isSkipped && isFinal) {
+      static_cast<void>(revisited.insert(allocatable));
+    }
+    isPassed = true;
+  } else {
+    std::list<const RBAAllocatable*> revisitAllocatables;
+    collectRevisitAllocatable(&revisitAllocatables, allocatable, falseConstraints, revisited);
+    if(!(revisitAllocatables.empty())) {
+      // There is re-arbitration Allocatable.
+      // Generates backup information for rollback when re-arbitration fails.
+      // For efficiency, instantiate only once when re-arbitration is needed 
+      // for the first time.
+      // Since it is backed up after content allocation, 
+      // it is necessary to set NULL to the allocated content after rollback.
+
+      // Rollback information when arbitration fails
+      std::shared_ptr<RBARollbacker> rollbacker {std::make_shared<RBARollbacker>()}; 
+      if (parentRollbacker != nullptr) {
+        parentRollbacker->addChild(rollbacker);
+      }
+      rollbacker->backup(revisitAllocatables);
+      // Initialize all re-arbitration Allocatable
+      for (auto& a : revisitAllocatables) {
+        const_cast<RBAAllocatable*>(a)->clearChecked();
+      }
+      // --------------------------------------------------
+      // Re-arbitrate "Allocatable" that has not been re-arbitrated 
+      // in the re-arbitration candidate list
+      // --------------------------------------------------
+      static_cast<void>(revisited.insert(allocatable));
+      for(const RBAAllocatable* const revisitAllocatable : revisitAllocatables) {
+        LOG_arbitrateAreaLogLine( "    " +
+            revisitAllocatable->getSymbol() + "["
+                                  + revisitAllocatable->getElementName()
+                                  + "] revisit allocatable check start");
+        arbitrateAllocatable(const_cast<RBAAllocatable*>(revisitAllocatable),
+			     revisited, nest + 1, affectInfo, rollbacker.get());
+      }
+      for(const RBAAllocatable* const revisitAllocatable : revisitAllocatables) {
+        static_cast<void>(revisited.erase(revisitAllocatable));
+      }
+      // --------------------------------------------------
+      // Check if content allocation succeeded as a result of re-arbitration
+      // --------------------------------------------------
+      falseConstraints.clear();
+      static_cast<void>(checkConstraints(constraints, falseConstraints, allocatable));
+      if (falseConstraints.empty()) {
+        // The content of the allocatable allocation is fixed by re-arbitration,
+        // so exit the loop and proceed to the next allocatable.
+        // In some cases, "Allocatable" is re-arbitrated due to recursion and 
+        // allocated Content is lost, but go to the next Allocable because
+        // all contents have been checked
+        isPassed = true;
+      } else {
+        // Roll back arbitration status and affected information
+        rollbacker->rollback(); 
+        if (parentRollbacker != nullptr) {
+          parentRollbacker->removeChild(rollbacker);
+        }
+      }
+    }
+  }
+  if (isPassed == false) {
+    //Collect Areas that affected the area in arbitration status
+    std::set<const RBAAllocatable*> allocatablesWhichHaveAffectedToThisAllocatable;
+
+    for (const RBAConstraintImpl* const constraint : falseConstraints) {
+      constraint->getInfo()->collectAffectedAllocatables(
+          false, allocatablesWhichHaveAffectedToThisAllocatable, false,
+          false);
+    }
+    static_cast<void>(allocatablesWhichHaveAffectedToThisAllocatable.erase(allocatable));
+
+    // Record fact that affected the area being arbitrated on Area that 
+    // affected Area during arbitration.
+    // The re-arbitration of the affected area is recorded in AffectInfo, 
+    // so it does not record the re-arbitrated area.
+    for (const RBAAllocatable* const a : allocatablesWhichHaveAffectedToThisAllocatable) {
+      if (!(affectInfo->alreadyKnowsThatFormerHasAffectedToLatter(a,
+                                                                  allocatable))) {
+        const_cast<RBAAllocatable*>(a)->addAllocatableWhichHasBeenAffectedByYou(
+            allocatable);
+        affectInfo->addInfoThatFormerAffectedToLatter(a, allocatable);
+      }
+    }
+  }
+  return isPassed;
+}
+
+void
+RBAArbitrator::
+setCancel(const RBAContentState* const state, const bool checked)
+{
+  result_->setCancel(state, checked);
+}
+
+bool
+RBAArbitrator::
+isCancel(const RBAContentState* const state) const
+{
+  if(state->isViewContentState()) {
+    return result_->isCancel(state);
+  }
+  else {
+    return result_->isCancel(state);
+  }
+}
+
+void
+RBAArbitrator::
+getSortedContentStates(const RBAAllocatable* const allocatable,
+                       std::list<const RBAContentState*>& contentStates) const
+{
+  for (const RBAContent* const content : allocatable->getInternalContents()) {
+    const RBAContentState* const state {result_->getActiveState(content)};
+    if (state != nullptr) {
+      contentStates.push_back(state);
+#ifdef RBA_USE_LOG
+    } else {
+      RBALogManager::arbitrateContentLogLine(
+          "  Content[" + content->getElementName() + "] is not Active skip");
+#endif
+    }
+  }
+  static_cast<void>(sortContentStates(allocatable, contentStates));
+  // Add null at the end, to evaluate constraint expression when unassigned
+  contentStates.push_back(nullptr);
+}
+
+std::int32_t
+RBAArbitrator::
+getViewActionPriority(const RBAViewActionType viewActionType)
+{
+  std::int32_t result{0};
+
+  switch(viewActionType) {
+  case RBAViewActionType::TRANSITION_REMOVE:
+    result = 4;
+    break;
+  case RBAViewActionType::MOVE:
+    result = 3;
+    break;
+  case RBAViewActionType::TRANSITION_ADD:
+    result = 2;
+    break;
+  case RBAViewActionType::TRANSITION_REPLACE:
+    result = 1;
+    break;
+  default:
+    break;
+  }
+
+  return result;
+}
+
+bool
+RBAArbitrator::
+compareViewAction(const std::unique_ptr<RBAViewAction>& lhs,
+                  const std::unique_ptr<RBAViewAction>& rhs)
+{
+  const std::int32_t lval {getViewActionPriority(lhs->getViewActionType())};
+  const std::int32_t rval {getViewActionPriority(rhs->getViewActionType())};
+
+  return lval > rval;
+}
+
+RBAResultImpl*
+RBAArbitrator::getResult() const
+{
+  return result_.get();
+}
+
+void RBAArbitrator::setResult(std::unique_ptr<RBAResultImpl> result)
+{
+  result_ = std::move(result);
+}
+
+std::set<const RBAContentState*>& RBAArbitrator::getCancelChecked()
+{
+  return cancelChecked_;
+}
+
+std::unique_ptr<RBAResultImpl>& RBAArbitrator::getResultRef() const
+{
+  return result_;
+}
+
+std::unique_ptr<RBAResultSet>& RBAArbitrator::getNextResultSet()
+{
+  return nextResultSet_;
+}
+
+void RBAArbitrator::setNextResultSet(std::unique_ptr<RBAResultSet> nextResultSet)
+{
+  nextResultSet_ = std::move(nextResultSet);
+}
+
+std::unique_ptr<RBAResultSet>& RBAArbitrator::getBackupResultSet()
+{
+  return backupResultSet_;
+}
+
+void RBAArbitrator::setBackupResultSet(std::unique_ptr<RBAResultSet> backupResultSet)
+{
+  backupResultSet_ = std::move(backupResultSet);
+}
+
+std::unique_ptr<RBAResultSet>& RBAArbitrator::getReservedResultSet()
+{
+  return reservedResultSet_;
+}
+
+void RBAArbitrator::setReservedResultSet(std::unique_ptr<RBAResultSet> reservedResultSet)
+{
+  reservedResultSet_ = std::move(reservedResultSet);
+}
+
+std::recursive_mutex& RBAArbitrator::getMutex() const
+{
+  return mutex_;
+}
+
+#ifdef RBA_USE_LOG
+void RBAArbitrator::setSimulationMode(bool simulationMode)
+{
+  simulationMode_ = simulationMode;
+}
+#endif
+
+std::deque<std::unique_ptr<RBARequestQueMember>>& RBAArbitrator::getRequestQue()
+{
+  return requestQue_;
+}
+
+#ifdef RBA_USE_LOG
+/**
+ * Output request information for log view
+ */
+void
+RBAArbitrator::logRequestArbitration()
+{
+  const std::list<const RBAAllocatable*> allocatables =
+      model_->getAllocatables();
+  RBALogManager::requestLogLine("----Request Information----");
+  RBALogManager::requestLogLine(
+      "Allocatable Count:" + std::to_string(allocatables.size()));
+  for (const RBAAllocatable* allocatable : allocatables) {
+    RBALogManager::requestLogLine(
+        "  " + allocatable->getSymbol() + "[" + allocatable->getElementName()
+            + "] policy[" + allocatable->getArbitrationPolicyString()
+            + "] visibility[" + allocatable->getVisibilityString() + "]");
+  }
+
+  const std::list<const RBAContentState*> contentStates = model_
+      ->getContentStates();
+  RBALogManager::requestLogLine(
+      "ContentState Count:" + std::to_string(contentStates.size()));
+  for (const RBAContentState* contentState : contentStates) {
+    std::string active;
+    if (contentState->getModelElementType() == RBAModelElementType::ViewContentState) {
+      active = RBALogManager::boolToString(
+          result_->isActive(
+              dynamic_cast<const RBAViewContentState*>(contentState)));
+    } else {
+      active = RBALogManager::boolToString(
+          result_->isActive(
+              dynamic_cast<const RBASoundContentState*>(contentState)));
+    }
+    RBALogManager::requestLogLine(
+        "  " + dynamic_cast<RBAContent*>(contentState->getOwner())->getSymbol() + "["
+            + contentState->getOwner()->getElementName() + "::"
+            + contentState->getElementName() + "] priority["
+            + contentState->getPriorityString() + "] isActive[" + active
+            + "] order[" + contentState->getOrderString() + "]");
+  }
+
+  const std::list<const RBAScene*> scenes = model_->getScenes();
+  RBALogManager::requestLogLine("Scene Count:" + std::to_string(scenes.size()));
+  for (const RBAScene* scene : scenes) {
+    RBALogManager::requestLogLine(
+        "  Scene[" + scene->getName() + "] isActive["
+            + RBALogManager::boolToString(result_->isActive(scene))
+            + "]");
+  }
+
+  std::list<RBAConstraint*> constraints = model_->getConstraints();
+  RBALogManager::requestLogLine(
+      "Constraint Count:" + std::to_string(constraints.size()));
+  for (RBAConstraint* constraint : constraints) {
+    RBAConstraintImpl* impl = dynamic_cast<RBAConstraintImpl*>(constraint);
+    RBALogManager::requestLogLine(
+        "  Constraint[" + impl->getName() + "] Expression["
+            + impl->getExpression()->getExpressionText() + "] runtime["
+            + RBALogManager::boolToString(impl->isRuntime()) + "]");
+  }
+
+}
+
+/**
+ * Output previous arbitration result for log view
+ */
+void
+RBAArbitrator::logPreResultArbitration()
+{
+  RBALogManager::resultLogLine("----Previous Result Information----");
+
+  auto allocs = model_->getAllocatables();
+  RBALogManager::resultLogLine("Allocatable TotalCount:"
+                               + std::to_string(allocs.size()));
+  for (auto& alloc : allocs) {
+    auto contentState = result_->getPreContentState(alloc);
+    auto hidden = result_->isPreHidden(alloc);
+    std::string str = "  " + alloc->getSymbol()
+                      + "[" + alloc->getElementName() + "] Content[";
+    if (contentState == nullptr) {
+      str += "null";
+    } else {
+      str += contentState->getOwner()->getElementName()
+             + "::" + contentState->getElementName();
+    }
+    str += "] " + alloc->getHiddenSymbol()
+           + "[" + RBALogManager::boolToString(hidden) + "]";
+    if (alloc->isZone() == true) {
+      str += " attenuated[";
+      str += RBALogManager::boolToString(
+              result_->isPreAttenuated(dynamic_cast<const RBAZone*>(alloc)));
+      str += "]";
+    }
+    RBALogManager::resultLogLine(str);
+    if (contentState && !hidden) {
+      RBALogManager::coveragePrevResultLogLine(
+        "A," + alloc->getElementName() + ","
+        + contentState->getOwner()->getElementName() + ","
+        + contentState->getElementName());
+    }
+  }
+
+  auto contents = model_->getContents();
+  RBALogManager::resultLogLine("Content TotalCount:"
+                               + std::to_string(contents.size()));
+  for (auto& content : contents) {
+    auto state = result_->getPreActiveState(content);
+    bool isOutputting = false;
+    bool isActive = false;
+    if (state != nullptr) {
+      isActive = true;
+      isOutputting = result_->isPreOutputting(state);
+    }
+    RBALogManager::resultLogLine(
+      "  " + content->getSymbol() + "[" + content->getElementName() + "] "
+      + content->getVisibleSymbol() + "["
+      + RBALogManager::boolToString(isOutputting) + "] active["
+      + RBALogManager::boolToString(isActive) + "]");
+    for (auto alloc : content->getAllocatables()) {
+      auto allocatedState = result_->getPreContentState(alloc);
+      if ((allocatedState != nullptr)
+          && (allocatedState->getOwner() == content)) {
+        RBALogManager::resultLogLine(
+          "    allocated " + alloc->getSymbol() + "["
+          + alloc->getElementName() + "]");
+      }
+    }
+  }
+}
+
+/**
+ * Output current arbitration result for log view
+ */
+void
+RBAArbitrator::logResultArbitration()
+{
+  RBALogManager::resultLogLine("----Result Information----");
+
+  const std::list<const RBAAllocatable*> allocatables
+    = model_->getAllocatables();
+  RBALogManager::resultLogLine("Allocatable TotalCount:" + std::to_string(allocatables.size()));
+  for(const RBAAllocatable* allocatable : allocatables) {
+    const RBAContentState* contentState = result_->getContentState(allocatable);
+    std::string str = "  ";
+    str += allocatable->getSymbol();
+    str += "[";
+    str += allocatable->getElementName();
+    str += "] Content[";
+    if (contentState == nullptr) {
+      str += "null";
+    } else {
+      str += contentState->getOwner()->getElementName() + "::"
+        + contentState->getElementName();
+    }
+    str += "] ";
+    str += allocatable->getHiddenSymbol();
+    str += "[";
+    str += RBALogManager::boolToString(result_->isHidden(allocatable));
+    str += "]";
+    if (allocatable->isZone() == true) {
+      str += " attenuated[";
+      str += RBALogManager::boolToString(result_->isAttenuated(dynamic_cast<const RBAZone*>(allocatable)));
+      str += "]";
+    }
+    RBALogManager::resultLogLine(str);
+  }
+
+  const std::list<const RBAContent*> contents = model_->getContents();
+  RBALogManager::resultLogLine("Content TotalCount:" + std::to_string(contents.size()));
+  for(const RBAContent* content : contents) {
+    bool isOutputting = false;
+    bool isCancel = false;
+    const RBAContentState* state = result_->getActiveState(content);
+    if(state != nullptr) {
+      isOutputting = result_->isOutputting(state);
+    } else {
+      for(const RBAContentState* state : content->getStates()) {
+        isCancel |= result_->isCancel(state);
+      }
+    }
+    RBALogManager::resultLogLine("  "
+        + content->getSymbol()
+        + "["
+        + content->getElementName()
+        + "] "
+        + content->getVisibleSymbol()
+        + "["
+        + RBALogManager::boolToString(isOutputting)
+        + "] cancel["
+        + RBALogManager::boolToString(isCancel)
+        + "]");
+    for(const RBAAllocatable* allocatable : content->getAllocatables()) {
+      const RBAContentState* allocatedState
+	= result_->getContentState(allocatable);
+      if((allocatedState != nullptr) && (allocatedState->getOwner() == content)) {
+        RBALogManager::resultLogLine("    allocated "
+                                     + allocatable->getSymbol() + "["
+                                     + allocatable->getElementName() + "]");
+      }
+    }
+  }
+}
+
+/**
+ * For coverage: Output request information
+ */
+void
+RBAArbitrator::logRequestForCoverage()
+{
+  for(const RBAContentState* contentState : model_->getContentStates()) {
+    std::ostringstream oss;
+    oss << "C,";
+    if(result_->isActive(contentState)) {
+      oss << "on,";
+    }
+    else {
+      oss << "off,";
+    }
+    oss << contentState->getOwner()->getElementName() << ",";
+    oss << contentState->getElementName() << ",";
+    oss << contentState->getContentStateOrder();
+    RBALogManager::coverageRequestLogLine(oss.str());
+  }
+  for(const RBAScene* scene : model_->getScenes()) {
+    std::ostringstream oss;
+    oss << "S,";
+    if(result_->isActive(scene)) {
+      oss << "on,";
+    }
+    else {
+      oss << "off,";
+    }
+    oss << scene->getName();
+    for(const auto& name : scene->getPropertyNames()) {
+      std::int32_t value {result_->getSceneProperty(scene, name)};
+      oss << ",";
+      oss << name;
+      oss << ":";
+      oss << value;
+    }
+    RBALogManager::coverageRequestLogLine(oss.str());
+  }
+}
+
+/**
+ * For coverage: Output result information
+ */
+void
+RBAArbitrator::logResultForCoverage()
+{
+  for(const RBAAllocatable* allocatable : model_->getAllocatables()) {
+    std::ostringstream oss;
+    oss << "A,";
+    oss << allocatable->getElementName() + ",";
+    const RBAContentState* contentState = result_->getContentState(allocatable);
+    if((contentState != nullptr) && (!result_->isHidden(allocatable))) {
+      oss << contentState->getOwner()->getElementName();
+    }
+    RBALogManager::coverageResultLogLine(oss.str());
+  }
+}
+
+void
+RBAArbitrator::setLogToResult()
+{
+  std::ostringstream oss;
+  oss << RBALogManager::getAllConstraintLog();
+  oss << RBALogManager::getRequestLog();
+  oss << RBALogManager::getPreviousResultLog();
+  oss << RBALogManager::getArbitrateLog();
+  oss << RBALogManager::getCancelRequestLog();
+  oss << RBALogManager::getCheckAllConstraintLog();
+  oss << RBALogManager::getResultLog();
+  result_->setLog(oss.str());
+}
+#endif
+
+}
diff --git a/src/core/logic/RBABackUpAllocatable.cpp b/src/core/logic/RBABackUpAllocatable.cpp
new file mode 100644
index 0000000..2843db1
--- /dev/null
+++ b/src/core/logic/RBABackUpAllocatable.cpp
@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+
+/**
+ * BackUpAllocatable class
+ */
+
+#include "RBABackUpAllocatable.hpp"
+
+namespace rba
+{
+
+RBABackUpAllocatable::RBABackUpAllocatable(const std::string& name)
+  : RBARuleObject{name},
+    RBAAllocatable{name}
+{
+}
+
+}
+
diff --git a/src/core/logic/RBABackUpAllocatable.hpp b/src/core/logic/RBABackUpAllocatable.hpp
new file mode 100644
index 0000000..a57aa01
--- /dev/null
+++ b/src/core/logic/RBABackUpAllocatable.hpp
@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+
+/**
+ * BackUpAllocatable class header
+ */
+
+#ifndef RBABACKUPALLOCATABLE_HPP
+#define RBABACKUPALLOCATABLE_HPP
+
+#include "RBAAllocatable.hpp"
+
+namespace rba
+{
+class RBABackUpAllocatable : public RBAAllocatable
+{
+public:
+  explicit RBABackUpAllocatable(const std::string& name);
+  RBABackUpAllocatable(const RBABackUpAllocatable&)=delete;
+  RBABackUpAllocatable(const RBABackUpAllocatable&&)=delete;
+  RBABackUpAllocatable& operator=(const RBABackUpAllocatable&)=delete;
+  RBABackUpAllocatable& operator=(const RBABackUpAllocatable&&)=delete;
+  virtual ~RBABackUpAllocatable()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBACommonMakerTable.cpp b/src/core/logic/RBACommonMakerTable.cpp
new file mode 100644
index 0000000..dde13b7
--- /dev/null
+++ b/src/core/logic/RBACommonMakerTable.cpp
@@ -0,0 +1,126 @@
+/**
+ * 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.
+ */
+
+/// @file  RBACommonMakerTable.cpp
+/// @brief Expression element maker table class definition file
+
+#include "RBACommonMakerTable.hpp"
+#include "RBAActiveStateMaker.hpp"
+#include "RBAAllocatedContentMaker.hpp"
+#include "RBAActiveContentsMaker.hpp"
+#include "RBAAndOperatorMaker.hpp"
+#include "RBAContentValueMaker.hpp"
+#include "RBAExistsOperatorMaker.hpp"
+#include "RBAForAllOperatorMaker.hpp"
+#include "RBAGetAllocatablesMaker.hpp"
+#include "RBAGetContentsListMaker.hpp"
+#include "RBAGetPropertyMaker.hpp"
+#include "RBAHasBeenDisplayedMaker.hpp"
+#include "RBAHasComeEarlierThanMaker.hpp"
+#include "RBAHasComeLaterThanMaker.hpp"
+#include "RBAIfStatementMaker.hpp"
+#include "RBAImpliesOperatorMaker.hpp"
+#include "RBAIntegerValueMaker.hpp"
+#include "RBAIsActiveMaker.hpp"
+#include "RBAIsEqualToOperatorMaker.hpp"
+#include "RBAIsGreaterThanEqualOperatorMaker.hpp"
+#include "RBAIsGreaterThanOperatorMaker.hpp"
+#include "RBAIsLowerThanEqualOperatorMaker.hpp"
+#include "RBAIsLowerThanOperatorMaker.hpp"
+#include "RBAIsOnMaker.hpp"
+#include "RBAIsTypeOfOperatorMaker.hpp"
+#include "RBALambdaExpressionMaker.hpp"
+#include "RBAMaxOperatorMaker.hpp"
+#include "RBAMemberFeatureReferenceMaker.hpp"
+#include "RBAMinOperatorMaker.hpp"
+#include "RBASelectOperatorMaker.hpp"
+#include "RBANotOperatorMaker.hpp"
+#include "RBAObjectCompareMaker.hpp"
+#include "RBAObjectReferenceMaker.hpp"
+#include "RBAOrOperatorMaker.hpp"
+#include "RBAPlusOperatorMaker.hpp"
+#include "RBAPreviousModifierMaker.hpp"
+#include "RBASetOfOperatorMaker.hpp"
+#include "RBASizeOperatorMaker.hpp"
+#include "RBAStateValueMaker.hpp"
+#include "RBAVariableMaker.hpp"
+#include "RBAConstraintMaker.hpp"
+#include "RBASceneMaker.hpp"
+#include "RBAModelElement.hpp"
+
+namespace rba
+{
+
+RBACommonMakerTable::RBACommonMakerTable()
+  : RBAAbstractMakerTable{}
+{
+  addTag("scenes");
+  addTag("constraints");
+  addTag("postconstraints");
+  addTag("rules");
+}
+
+std::list<std::unique_ptr<RBAModelElementMaker>>
+RBACommonMakerTable::getMakers() const
+{
+  std::list<std::unique_ptr<RBAModelElementMaker>> makers;
+  makers.push_back(std::make_unique<RBAActiveStateMaker>());
+  makers.push_back(std::make_unique<RBAAllocatedContentMaker>());
+  makers.push_back(std::make_unique<RBAActiveContentsMaker>());
+  makers.push_back(std::make_unique<RBAAndOperatorMaker>());
+  makers.push_back(std::make_unique<RBAContentValueMaker>());
+  makers.push_back(std::make_unique<RBAExistsOperatorMaker>());
+  makers.push_back(std::make_unique<RBAForAllOperatorMaker>());
+  makers.push_back(std::make_unique<RBAGetAllocatablesMaker>());
+  makers.push_back(std::make_unique<RBAGetContentsListMaker>());
+  makers.push_back(std::make_unique<RBAGetPropertyMaker>());
+  makers.push_back(std::make_unique<RBAHasBeenDisplayedMaker>());
+  makers.push_back(std::make_unique<RBAHasComeEarlierThanMaker>());
+  makers.push_back(std::make_unique<RBAHasComeLaterThanMaker>());
+  makers.push_back(std::make_unique<RBAIfStatementMaker>());
+  makers.push_back(std::make_unique<RBAImpliesOperatorMaker>());
+  makers.push_back(std::make_unique<RBAIntegerValueMaker>());
+  makers.push_back(std::make_unique<RBAIsActiveMaker>());
+  makers.push_back(std::make_unique<RBAIsEqualToOperatorMaker>());
+  makers.push_back(std::make_unique<RBAIsGreaterThanEqualOperatorMaker>());
+  makers.push_back(std::make_unique<RBAIsGreaterThanOperatorMaker>());
+  makers.push_back(std::make_unique<RBAIsLowerThanEqualOperatorMaker>());
+  makers.push_back(std::make_unique<RBAIsLowerThanOperatorMaker>());
+  makers.push_back(std::make_unique<RBAIsOnMaker>());
+  makers.push_back(std::make_unique<RBAIsTypeOfOperatorMaker>());
+  makers.push_back(std::make_unique<RBALambdaExpressionMaker>());
+  makers.push_back(std::make_unique<RBAMaxOperatorMaker>());
+  makers.push_back(std::make_unique<RBAMemberFeatureReferenceMaker>());
+  makers.push_back(std::make_unique<RBAMinOperatorMaker>());
+  makers.push_back(std::make_unique<RBASelectOperatorMaker>());
+  makers.push_back(std::make_unique<RBANotOperatorMaker>());
+  makers.push_back(std::make_unique<RBAObjectCompareMaker>());
+  makers.push_back(std::make_unique<RBAObjectReferenceMaker>());
+  makers.push_back(std::make_unique<RBAOrOperatorMaker>());
+  makers.push_back(std::make_unique<RBAPlusOperatorMaker>());
+  makers.push_back(std::make_unique<RBAPreviousModifierMaker>());
+  makers.push_back(std::make_unique<RBASetOfOperatorMaker>());
+  makers.push_back(std::make_unique<RBASizeOperatorMaker>());
+  makers.push_back(std::make_unique<RBAStateValueMaker>());
+  makers.push_back(std::make_unique<RBAVariableMaker>());
+  makers.push_back(std::make_unique<RBAConstraintMaker>());
+  makers.push_back(std::make_unique<RBASceneMaker>());
+  RBAModelElementMaker::addMaker("SCENE", std::make_unique<RBASceneMaker>());
+
+  return makers;
+}
+
+}
diff --git a/src/core/logic/RBACommonMakerTable.hpp b/src/core/logic/RBACommonMakerTable.hpp
new file mode 100644
index 0000000..ae18dad
--- /dev/null
+++ b/src/core/logic/RBACommonMakerTable.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// @file  RBACommonMakerTable.hpp
+/// @brief Expression element maker table class header
+
+#ifndef RBACOMMONMAKERTABLE_HPP
+#define RBACOMMONMAKERTABLE_HPP
+
+#include "RBAAbstractMakerTable.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBACommonMakerTable : public RBAAbstractMakerTable
+{
+public:
+  RBACommonMakerTable();
+  RBACommonMakerTable(const RBACommonMakerTable&)=delete;
+  RBACommonMakerTable(const RBACommonMakerTable&&)=delete;
+  RBACommonMakerTable& operator=(const RBACommonMakerTable&)=delete;
+  RBACommonMakerTable& operator=(const RBACommonMakerTable&&)=delete;
+  virtual ~RBACommonMakerTable()=default;
+
+public:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::list<std::unique_ptr<RBAModelElementMaker>> getMakers() const override;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAConstraintInfo.cpp b/src/core/logic/RBAConstraintInfo.cpp
new file mode 100644
index 0000000..b208c5f
--- /dev/null
+++ b/src/core/logic/RBAConstraintInfo.cpp
@@ -0,0 +1,695 @@
+/**
+ * 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.
+ */
+
+/// ConstraintInfo class
+
+#include <algorithm>
+#include "RBAAllocatable.hpp"
+#include "RBAConstraintInfo.hpp"
+#include "RBAExpression.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void RBAConstraintInfo::setExpression(const RBAExpression* const expression)
+{
+  expression_ = expression;
+}
+
+const RBAExpression*
+RBAConstraintInfo::getExpression() const
+{
+  return expression_;
+}
+
+void RBAConstraintInfo::addOperandAllocatable(const RBAAllocatable* const operandAllocatable)
+{
+  static_cast<void>(operandAllocatable_.insert(operandAllocatable));
+}
+
+void RBAConstraintInfo::setResult(const RBAExecuteResult result)
+{
+  result_ = result;
+}
+
+RBAConstraintInfo*
+RBAConstraintInfo::getChild(const std::uint32_t index) const
+{
+  const std::size_t requiredSize {static_cast<std::size_t>(index + 1U)};
+  if (children_.size() < requiredSize) {
+    children_.resize(requiredSize, std::make_unique<RBAConstraintInfo>());
+  }
+  // Use "[]" instead of "at" because it doesn't access out of range
+  return children_[static_cast<std::size_t>(index)].get();
+}
+
+void RBAConstraintInfo::setChild(const std::shared_ptr<RBAConstraintInfo> info)
+{
+  // This function is used in "let" expressions, which generate a new 
+  // "ConstraintInfo" on each evaluation.
+  // Therefore, in the case of "add", "children" will be added for each arbitration, 
+  // so use "set" to set "children" for each arbitration.
+  children_ = { info };
+}
+
+void RBAConstraintInfo::addTrueAllocatable(const RBAAllocatable* const allocatable)
+{
+  static_cast<void>(trueAllocatables_.insert(allocatable));
+}
+
+void RBAConstraintInfo::addFalseAllocatable(const RBAAllocatable* const allocatable)
+{
+  static_cast<void>(falseAllocatables_.insert(allocatable));
+}
+
+void RBAConstraintInfo::addTrueAllocatableFromOperand()
+{
+  for (const auto& c : children_) {
+    for (const auto& a : c->operandAllocatable_) {
+      static_cast<void>(trueAllocatables_.insert(a));
+    }
+  }
+}
+
+void RBAConstraintInfo::addFalseAllocatableFromOperand()
+{
+  for (const auto& c : children_) {
+    for (const auto& a : c->operandAllocatable_) {
+      static_cast<void>(falseAllocatables_.insert(a));
+    }
+  }
+}
+
+void RBAConstraintInfo::clearFalseAllocatable()
+{
+  falseAllocatables_.clear();
+}
+
+/// TCheck whether to invert True/False
+/// @return
+bool RBAConstraintInfo::isRevert() const
+{
+  if ((expression_ != nullptr)
+      && expression_->isModelElementType(RBAModelElementType::NotOperator)) {
+    return true;
+  }
+  return false;
+}
+
+bool RBAConstraintInfo::isSizeOperator() const
+{
+  if ((expression_ != nullptr)
+      && (expression_->isModelElementType(RBAModelElementType::SizeOperator))) {
+    return true;
+  }
+  return false;
+}
+
+const bool RBAConstraintInfo::isImplies() const
+{
+  if ((expression_ != nullptr)
+      && (expression_->isModelElementType(RBAModelElementType::ImpliesOperator)
+          || expression_->isModelElementType(RBAModelElementType::IfStatement))) {
+    return true;
+  }
+  return false;
+}
+
+void RBAConstraintInfo::clear()
+{
+  for (const std::shared_ptr<RBAConstraintInfo>& child : children_) {
+    // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+    //  [Contents that deviate from the rules]
+    //   recursively calling clear()
+    // 　[Reason that there is no problem if the rule is deviated]
+    //   ConstraintInfo is created for each node in the Constraint expression 
+    //   tree. The Constraint expression tree is determined by the constraint 
+    //   expressions written in the model file, and its depth is finite.
+    //   Therefore, stack overflow does not occur and there is no problem
+    child->clear();
+  }
+  result_ = RBAExecuteResult::SKIP;
+  exceptionBeforeArbitrate_ = false;
+  trueAllocatables_.clear();
+  falseAllocatables_.clear();
+  operandAllocatable_.clear();
+}
+
+bool RBAConstraintInfo::isExceptionBeforeArbitrate() const
+{
+  return exceptionBeforeArbitrate_;
+}
+
+void RBAConstraintInfo::setExceptionBeforeArbitrate(
+    const bool exceptionBeforeArbitrate)
+{
+  exceptionBeforeArbitrate_ = exceptionBeforeArbitrate;
+}
+
+bool RBAConstraintInfo::needsReRearbitrationFor(
+    const RBAAllocatable* const allocatable) const
+{
+  bool result {false};
+  if (children_.empty() == false) {
+    switch (expression_->getModelElementType()) {
+      case RBAModelElementType::ImpliesOperator:
+        if (children_.front()->isExceptionBeforeArbitrate()) {
+          result = children_.back()->needsReRearbitrationFor(allocatable);
+        }
+        break;
+      case RBAModelElementType::IfStatement:
+        if (children_.front()->isExceptionBeforeArbitrate()) {
+          // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+          //  [Contents that deviate from the rules]
+          //   Function '::rba::RBAConstraintInfo::needsReRearbitrationFor=(_,
+          //                          p={c::rba::RBAAllocatable})' is recursive.
+          // 　[Reason that there is no problem if the rule is deviated]
+          //   Recursive call is required as a feature
+          result = children_.back()->needsReRearbitrationFor(allocatable);
+        }
+        break;
+      default:
+        for (const auto& child : children_) {
+          result = (result || child->needsReRearbitrationFor(allocatable));
+        }
+        result =
+            (result || (trueAllocatables_.find(allocatable)  != trueAllocatables_.end())
+                    || (falseAllocatables_.find(allocatable) != falseAllocatables_.end()));
+        break;
+    }
+  }
+  return result;
+}
+
+bool RBAConstraintInfo::needsRearbitrationFor(const RBAAllocatable* const allocatable,
+                                              bool isImplies) const
+{
+  bool result {false};  // 再調停要否
+  if (children_.empty() == false) {
+    // When the syntax of the constraint expression is 
+    //  - ImpliesOperator
+    //  - IfStatement 
+    //  - other than the above
+    switch (expression_->getModelElementType()) {
+      case RBAModelElementType::ImpliesOperator:
+        // If the left side of the implication is true and 
+        // the left side contains an Allocatable during arbitration, 
+        // re-arbitration is required.
+        //
+        // If the left side of the implication is true and 
+        // the left side contains an allocatable state reference expression, 
+        // re-arbitration is NOT required.
+        if (children_.front()->isTrue()) {
+          if (children_.front()->contains(allocatable)) {
+            result = true;
+          } else {
+            if (children_.front()->contains(nullptr)) {
+              isImplies = true;
+            }
+            result = (result || children_.back()->needsRearbitrationFor(allocatable,
+                      isImplies));
+          }
+        }
+        break;
+      case RBAModelElementType::IfStatement:
+        // If the IF condition includes Allocatble in arbitration, 
+        // re-arbitration is required.
+        // If the IF condition includes an Allocatable state reference 
+        // expression, re-arbitration is NOT required.
+        // If the IF condition does not include an allocatable state reference 
+        // expression, search the child syntax.
+        if (children_.front()->contains(allocatable)) {
+          result = true;
+        } else {
+          if (children_.front()->contains(nullptr)) {
+            isImplies = true;
+          }
+          result = (result || children_.back()->needsRearbitrationFor(allocatable,
+                                                                      isImplies));
+        }
+        break;
+      default:
+        for (const auto& child : children_) {
+          // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+          //  [Contents that deviate from the rules]
+          //   Function '::rba::RBAConstraintInfo::needsRearbitrationFor=(_,
+          //                       p={c::rba::RBAAllocatable},_o)' is recursive. 
+          // 　[Reason that there is no problem if the rule is deviated]
+          //   Recursive call is required as a feature
+          result = (result || child->needsRearbitrationFor(allocatable, isImplies));
+        }
+        // The Constraint expression does not include IF or implication,
+        //  or
+        // the Allocatable state reference expression is not included　in the 
+        // left side of the IF condition of the parent syntax or 
+        // the implication of the parent syntax,
+        //  or
+        // "Allocable" during arbitration is included in the left side of 
+        // the IF condition of the parent syntax or the implication of the 
+        // parent syntax,
+        //
+        // re-arbitration is required.
+        if (!isImplies && contains(allocatable)) {
+          result = true;
+        }
+        break;
+    }
+  }
+  return result;
+}
+
+/// @brief Collect "Allocatable" whose right side is false.
+/// @details
+///  - Do not collect if an exception has occurred
+///  - When expression_ is nullptr or When expression_ is implication
+///    - If the left side is satisfied and there is a condition on the left 
+///      side that is affected by the allocatable state, collect the 
+///      allocatable that caused the right side to be false.
+///    - If the left side is satisfied and there is NO condition affected by 
+///      the allocatable state on the left side, this function is called on 
+///      the right side. (To correspond to implication or IF nest)
+///  - When expression_ is IF
+///    - If there is a condition on the left side that is affected by the 
+///      "Allocatable" state, collect the "Allocatable that caused the 
+///      right side to be false.
+///    - If there is no condition affected by the allocatable state on the left 
+///      side, call this function for the right side. 
+///      (To correspond to the implication or nest of IF)
+///  - When expression_ is negative
+///    - Call this function with "isNot" inverted for the left side.
+///      (To deal with implications or IFs present in children.)
+///  - When expression_ is above
+///    - Call this function for the child ConstraintInfo. 
+///      (To deal with implications or IFs present in children.)
+/// @param[in] allocatable "Allcatable" during arbitration
+/// @param[out] targets "Allocatable" for re-arbitration
+/// @param[in] isNot Inversion state of right and wrong by negation operator.
+void RBAConstraintInfo::collectRearbitrationTargetFor(
+    const RBAAllocatable* const allocatable, std::set<const RBAAllocatable*>& targets,
+    const bool isNot) const
+{
+  if (isExceptionBeforeArbitrate()) {
+    return;
+  }
+  if (children_.empty() == false) {
+    switch (expression_->getModelElementType()) {
+      case RBAModelElementType::ImpliesOperator:
+        if (children_.front()->isTrue()) {
+          if (isNot) {
+            children_.back()->collectTrueAllocatables(targets);
+          } else {
+            children_.back()->collectFalseAllocatables(targets);
+          }
+        } else if (!children_.front()->isFalse()) {
+          children_.back()->collectRearbitrationTargetFor(allocatable, targets,
+                                                          isNot);
+        } else {
+        }
+        break;
+      case RBAModelElementType::IfStatement:
+        if (isNot) {
+          children_.back()->collectTrueAllocatables(targets);
+        } else {
+          children_.back()->collectFalseAllocatables(targets);
+        }
+        break;
+      case RBAModelElementType::NotOperator:
+        // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+        //  [Contents that deviate from the rules]
+        //   Function '::rba::RBAConstraintInfo::collectRearbitrationTargetFor=(_,p={c::rba::RBAAllocatable},
+        //     &{c::std::set<p={c::rba::RBAAllocatable},{c::std::less<p={c::rba::RBAAllocatable}>},
+        //     {c::std::allocator<p={c::rba::RBAAllocatable}>}>},_o)' is recursive. 
+        // 　[Reason that there is no problem if the rule is deviated]
+        //   Recursive call is required as a feature
+        children_.front()->collectRearbitrationTargetFor(allocatable, targets,
+                                                         !isNot);
+        break;
+      default:
+        for (const auto& child : children_) {
+          child->collectRearbitrationTargetFor(allocatable, targets, isNot);
+        }
+        break;
+    }
+  }
+}
+
+void RBAConstraintInfo::collectTrueAllocatables(
+    std::set<const RBAAllocatable*>& allocatables) const
+{
+  if (isExceptionBeforeArbitrate() || isFalse()) {
+    return;
+  }
+  if (isRevert()) {
+    for (const auto& child : children_) {
+      child->collectFalseAllocatables(allocatables);
+    }
+    allocatables.insert(falseAllocatables_.begin(), falseAllocatables_.end());
+  } else if (isImplies()) {
+    children_.back()->collectTrueAllocatables(allocatables);
+  } else if (isSizeOperator()) {
+    // Since the size operator evaluates the number of sets, 
+    // the Allocatable that combines FalseAllocatable and TrueAllocatable 
+    // becomes TrueAllocatables.
+    children_.back()->collectTrueAllocatables(allocatables);
+    children_.back()->collectFalseAllocatables(allocatables);
+  } else {
+    for (const auto& child : children_) {
+      // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+      //  [Contents that deviate from the rules]
+      //   Function '::rba::RBAConstraintInfo::collectTrueAllocatables=(_,
+      //     &{c::std::set<p={c::rba::RBAAllocatable},
+      //     {c::std::less<p={c::rba::RBAAllocatable}>},
+      //     {c::std::allocator<p={c::rba::RBAAllocatable}>}>})' is recursive. 
+      // 　[Reason that there is no problem if the rule is deviated]
+      //   Recursive call is required as a feature
+      child->collectTrueAllocatables(allocatables);
+    }
+    allocatables.insert(trueAllocatables_.begin(), trueAllocatables_.end());
+  }
+  return;
+}
+
+void RBAConstraintInfo::collectFalseAllocatables(
+    std::set<const RBAAllocatable*>& allocatables) const
+{
+  if (isExceptionBeforeArbitrate() || isTrue()) {
+    return;
+  }
+  if (isRevert()) {
+    for (const auto& child : children_) {
+      child->collectTrueAllocatables(allocatables);
+    }
+    allocatables.insert(trueAllocatables_.begin(), trueAllocatables_.end());
+  } else if (isImplies()) {
+    children_.back()->collectFalseAllocatables(allocatables);
+  } else if (isSizeOperator()) {
+    // The size operator evaluates the number of sets, so "Allocatable", 
+    // which is a combination of "FalseAllocatable" and "TrueAllocatable", 
+    // becomes "FalseAllocatables".
+    children_.back()->collectTrueAllocatables(allocatables);
+    children_.back()->collectFalseAllocatables(allocatables);
+  } else {
+    for (const auto& child : children_) {
+      // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+      //  [Contents that deviate from the rules]
+      //   Function '::rba::RBAConstraintInfo::collectFalseAllocatables=(_,
+      //           &{c::std::set<p={c::rba::RBAAllocatable},
+      //           {c::std::less<p={c::rba::RBAAllocatable}>},
+      //           {c::std::allocator<p={c::rba::RBAAllocatable}>}>})' 
+      //   is recursive. 
+      // 　[Reason that there is no problem if the rule is deviated]
+      //   Recursive call is required as a feature
+      child->collectFalseAllocatables(allocatables);
+    }
+    allocatables.insert(falseAllocatables_.begin(), falseAllocatables_.end());
+  }
+  return;
+}
+
+bool RBAConstraintInfo::contains(const RBAAllocatable* const allocatable) const
+{
+  if (allocatable != nullptr) {
+    if (trueAllocatables_.find(allocatable) != trueAllocatables_.end()) {
+      return true;
+    }
+    if (falseAllocatables_.find(allocatable) != falseAllocatables_.end()) {
+      return true;
+    }
+  } else {
+    if (!trueAllocatables_.empty() || !falseAllocatables_.empty()) {
+      return true;
+    }
+  }
+  for (const auto& child : children_) {
+    // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+    //  [Contents that deviate from the rules]
+    //   Function '::rba::RBAConstraintInfo::contains=(_,
+    //                                p={c::rba::RBAAllocatable})' 
+    //   is recursive. 
+    // 　[Reason that there is no problem if the rule is deviated]
+    //   Recursive call is required as a feature
+    if (child->contains(allocatable)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool RBAConstraintInfo::isTrue() const
+{
+  return (result_ == RBAExecuteResult::TRUE);
+}
+
+bool RBAConstraintInfo::isFalse() const
+{
+  return (result_ == RBAExecuteResult::FALSE);
+}
+
+void RBAConstraintInfo::collectAffectedAllocatables(
+    const bool isRevert, std::set<const RBAAllocatable*>& affectAllocatables,
+    const bool collecting,
+    const bool forObject)
+{
+  // Collect the allocatable that caused the constraint expression to be False.
+  // It is implemented by recursively calling ConstraintInfo of the tree 
+  // structure created at the time of "Constraint" expression evaluation.
+  // with this function.
+  // Collect True because the success or failure of ConstraintInfo below 
+  // "negative" is reversed.
+  switch (getExpression()->getModelElementType()) {
+    case RBAModelElementType::NotOperator:
+      // ConstraintInfo below negative negates success or failure, 
+      // so invert isRevert and call child Info.
+      children_[0U]->collectAffectedAllocatables(!isRevert, affectAllocatables,
+                                                 collecting, forObject);
+      break;
+    case RBAModelElementType::SizeOperator:
+      // Since the size operator evaluates the number of sets, 
+      // "Allocatable" which is a combination of "FalseAllocatable" and 
+      // "TrueAllocatable" becomes "affectAllocatables".
+      children_[0U]->collectAffectedAllocatables(false, affectAllocatables,
+                                                 true, true);
+      break;
+    case RBAModelElementType::OrOperator:
+    case RBAModelElementType::ExistsOperator:
+      // the same processing is performed, because "Exists {A,B}{x|x.isXXX}" 
+      // is equivalent to "A.isXXX OR B.isXXX"
+      if (!isRevert) {
+        // Processing when "Info" of "OR"　in which evaluation result that is not 
+        // qualified by an odd number of negative is "Skip" or evaluation reslt 
+        // that is not qualified by an odd number of negative is "False".
+        if (!isTrue()) {
+          // Collect the Allocatable of child Info whose 
+          // whose evaluation result is False.
+          // When "A.isXXX OR B.isXXX", if the evaluation result of A is True, 
+          // the evaluation result of OR will be True even if the evaluation 
+          // result of B is False. Therefore, A affects B. 
+          // Conversely, B also affects A.
+          // Therefore, set "collecting" to True and 
+          // search "child Info" for allocatable.
+          for (auto& i : children_) {
+            i->collectAffectedAllocatables(isRevert, affectAllocatables, true,
+                                           forObject);  // Collct when "OR"
+          }
+        }
+      } else {
+        // Processing when "Info" of "OR"　in which evaluation result that is not 
+        // qualified by an odd number of negative is "Skip" or evaluation reslt 
+        // that is not qualified by an odd number of negative is "False".
+        // "!(A.isXXX OR B.isXXX)" can be decomposed into 
+        // "!A.isXXX AND !B.isXXX", so if "NOT", perform the same processing 
+        // as "AND".
+        if (!isFalse()) {
+          for (auto& i : children_) {
+            i->collectAffectedAllocatables(isRevert, affectAllocatables,
+                                           collecting, forObject);
+          }
+        }
+      }
+      break;
+    case RBAModelElementType::AndOperator:
+    case RBAModelElementType::ForAllOperator:
+      //"For-All {A,B}{x|x.isXXX}" is equivalent to "A.isXXX AND B.isXXX", 
+      // so the same processing is performed
+      if (isRevert) {
+        // Processing when "Info" of "AND"　in which evaluation result that 
+        // is not qualified by an odd number of "negative" is "Skip" or 
+        // evaluation reslt that is not qualified by an odd number of negative 
+        // is "True".
+        //
+        // "!(A.isXXX AND B.isXXX)" can be decomposed into 
+        // "!A.isXXX OR !B.isXXX", so if "NOT", perform the same processing 
+        // as "OR".
+        if (!isFalse()) {
+          for (auto& i : children_) {
+            // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+            //  [Contents that deviate from the rules]
+            //   Function '::rba::RBAConstraintInfo::collectAffectedAllocatables(_,_o,&{c::std::set<p={c::rba::RBAAllocatable},
+            //   {c::std::less<p={c::rba::RBAAllocatable}>},{c::std::allocator<p={c::rba::RBAAllocatable}>}>},_o)' is recursive.
+            // 　[Reason that there is no problem if the rule is deviated]
+            //   Recursive call is required as a feature
+            i->collectAffectedAllocatables(isRevert, affectAllocatables, true,
+                                           forObject);
+          }
+        }
+      } else {
+        // Processing when "Info" of "AND"　in which evaluation result that 
+        // is not qualified by an odd number of "negative" is "Skip" or 
+        // evaluation reslt that is not qualified by an odd number of negative 
+        // is "True".
+        //
+        // When "A.isXXX AND B.isXXX", the evaluation result of "AND" does not 
+        // become True unless the evaluation result of B becomes True, 
+        // regardless of the evaluation result of A.　Therefore, A does not 
+        // affect B, and B does not affect A.
+        // Therefore, "collecting" is as it is, and the "child Info" is 
+        // searched for an allocable influence.
+        if (!isTrue()) {
+          for (auto& i : children_) {
+            i->collectAffectedAllocatables(isRevert, affectAllocatables,
+                                           collecting, forObject);
+          }
+        }
+      }
+      break;
+    case RBAModelElementType::MaxOperator:
+    case RBAModelElementType::MinOperator:
+    {
+      // When the <set> expression is "IF(A.isDisplayed) THEN {B,C} ELSE {D,E}", 
+      // scan the left side to extract A as the area of influence
+      children_[0U]->collectAffectedAllocatables(false, affectAllocatables,
+                                                 collecting,forObject);
+      // All the operands that are "x" in the lambda expression affect 
+      // each other, so it is necessary to extract them as the affected Area.
+      for (std::uint8_t i { 1U }; i < children_.size(); ++i) {
+        children_[i]->collectAffectedAllocatables(isRevert, affectAllocatables,
+                                                  true, true);
+      }
+      break;
+    }
+    // "A -> B" is the same as "!A OR B".
+    case RBAModelElementType::ImpliesOperator:
+      if (!isRevert) {
+        if (!isTrue()) {
+          // "A.isXXX -> B.isXXX" can be decomposed into "!A.isXXX OR B.isXXX", 
+          // so the same process as OR is performed
+          // For the above reason, the acquisition target on the left side 
+          // inverts isRevert.
+          children_[0U]->collectAffectedAllocatables(!isRevert,
+                                                     affectAllocatables, true,
+                                                     forObject);
+          children_[1U]->collectAffectedAllocatables(isRevert,
+                                                     affectAllocatables, true,
+                                                     forObject);
+        }
+      } else {
+        if (!isFalse()) {
+          // "!(A.isXXX -> B.isXXX)" can be decomposed into "A.isXXX OR !B.isXXX"
+          // For the above reason, the acquisition target on the left side 
+          // inverts isRevert.
+          children_[0U]->collectAffectedAllocatables(!isRevert,
+                                                     affectAllocatables,
+                                                     collecting, forObject);
+          children_[1U]->collectAffectedAllocatables(isRevert,
+                                                     affectAllocatables,
+                                                     collecting, forObject);
+        }
+      }
+      break;
+    case RBAModelElementType::IfStatement:
+    // "IF(A) THEN B ELSE C" is the same as "!A OR B" if A is True, 
+    // and the same as "A OR C" if A is False
+      if (children_[0U]->isTrue()) {
+        if (!isRevert) {
+          if (!isTrue()) {
+            // "IF(A.isXXX) THEN B.isXXX ELSE C.isXXX" can be decomposed into 
+            // "(!A.isXXX OR B.isXXX)" when A is True.
+            // For the above reason, the acquisition target on the left side 
+            // inverts isRevert.
+            children_[0U]->collectAffectedAllocatables(!isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+            children_[1U]->collectAffectedAllocatables(isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+          }
+        } else {
+          if (!isFalse()) {
+            // "!(IF(A.isXXX) THEN B.isXXX ELSE C.isXXX)" can be decomposed into 
+            // "(!A.isXXX OR !B.isXXX)" when A is True.
+            // For the above reason, the acquisition target on the left side 
+            // inverts isRevert.
+            children_[0U]->collectAffectedAllocatables(isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+            children_[1U]->collectAffectedAllocatables(isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+          }
+        }
+      } else {
+        if (!isRevert) {
+          if (!isTrue()) {
+            // "IF(A.isXXX) THEN B.isXXX ELSE C.isXXX" can be decomposed into 
+            // "(A.isXXX OR C.isXXX)" when A is False.
+            children_[0U]->collectAffectedAllocatables(isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+            children_[1U]->collectAffectedAllocatables(isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+          }
+        } else {
+          if (!isFalse()) {
+            // "!(IF(A.isXXX) THEN B.isXXX ELSE C.isXXX)" can be decomposed into 
+            // "(A.isXXX OR !C.isXXX)" when A is False.
+            children_[0U]->collectAffectedAllocatables(!isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+            children_[1U]->collectAffectedAllocatables(isRevert,
+                                                       affectAllocatables, true,
+                                                       forObject);
+          }
+        }
+      }
+      break;
+    default:  // Collect Allocatable
+      if (collecting) {
+        if (isRevert) {
+          affectAllocatables.insert(trueAllocatables_.begin(),
+                                    trueAllocatables_.end());
+        } else {
+          affectAllocatables.insert(falseAllocatables_.begin(),
+                                    falseAllocatables_.end());
+        }
+        if (forObject) {
+          for (const auto& a : operandAllocatable_) {
+            affectAllocatables.insert(a);
+          }
+        }
+      }
+      for (auto& i : children_) {
+        i->collectAffectedAllocatables(isRevert, affectAllocatables, collecting,
+                                       forObject);
+      }
+      break;
+  }
+  return;
+}
+
+}
+
diff --git a/src/core/logic/RBAConstraintInfo.hpp b/src/core/logic/RBAConstraintInfo.hpp
new file mode 100644
index 0000000..8ab88dd
--- /dev/null
+++ b/src/core/logic/RBAConstraintInfo.hpp
@@ -0,0 +1,119 @@
+/**
+ * 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.
+ */
+
+/// ConstraintInfo (Constraint expression Information) class header
+
+#ifndef RBACONSTRAINTINFO_HPP
+#define RBACONSTRAINTINFO_HPP
+
+#include <cstdint>
+#include <memory>
+#include <set>
+#include <vector>
+#include "RBAExecuteResult.hpp"
+#include "RBADllExport.hpp"
+
+namespace rba {
+
+class RBAAllocatable;
+class RBAExpression;
+
+class DLL_EXPORT RBAConstraintInfo
+{
+public:
+  RBAConstraintInfo()=default;
+  RBAConstraintInfo(const RBAConstraintInfo&)=delete;
+  RBAConstraintInfo(const RBAConstraintInfo&&)=delete;
+  RBAConstraintInfo& operator=(const RBAConstraintInfo&)=delete;
+  RBAConstraintInfo& operator=(const RBAConstraintInfo&&)=delete;
+  virtual ~RBAConstraintInfo()=default;
+
+public:
+  void setExpression(const RBAExpression* const expression);
+  const RBAExpression* getExpression() const;
+  void addOperandAllocatable(const RBAAllocatable* const operandAllocatable);
+  void setResult(const RBAExecuteResult result);
+  RBAConstraintInfo* getChild(const std::uint32_t index) const;
+  void setChild(const std::shared_ptr<RBAConstraintInfo> info);
+  void addTrueAllocatable(const RBAAllocatable* const allocatable);
+  void addFalseAllocatable(const RBAAllocatable* const allocatable);
+  void addTrueAllocatableFromOperand();
+  void addFalseAllocatableFromOperand();
+  void clearFalseAllocatable();
+  const bool isImplies() const;
+  void clear();
+
+  bool isExceptionBeforeArbitrate() const;
+  void setExceptionBeforeArbitrate(const bool exceptionBeforeArbitrate);
+
+  /// @brief Determine the need for re-arbitration
+  /// @param [in] allocatable Allcatable druing arbitration
+  /// @param [in] isImplies Whether the constraint expression contains 
+  ///                       implication syntax.
+  /// @return Necessity of re-arbitration (true: need / false: No need)
+  bool needsRearbitrationFor(const RBAAllocatable* const allocatable,
+                             bool isImplies = false) const;
+
+  bool needsReRearbitrationFor(const RBAAllocatable* const allocatable) const;
+  void collectRearbitrationTargetFor(const RBAAllocatable* const allocatable,
+				     std::set<const RBAAllocatable*>& targets,
+				     const bool isNot) const;
+  void collectTrueAllocatables(std::set<const RBAAllocatable*>& allocatables) const;
+  void collectFalseAllocatables(std::set<const RBAAllocatable*>& allocatables) const;
+  bool contains(const RBAAllocatable* const allocatable) const;
+  bool isTrue() const;
+  bool isFalse() const;
+
+  /// @brief Extraction of affected Area/Zone
+  /// @param [in] isRevert Negative context (true: inside / false: outside)
+  /// @param [out] affectAllocatables List of affected Allcatable
+  /// @param [out] collecting Collection target context
+  ///                         (true: inside / false: outside)
+  /// @param [out] forObject ReferenceObject context
+  ///                        (true: inside / false: outside)
+  /// @return Necessity of re-arbitration (true: need / false: No need)
+  void collectAffectedAllocatables(
+      const bool isRevert, std::set<const RBAAllocatable*>& affectAllocatables,
+      const bool collecting,
+      const bool forObject);
+
+private:
+  bool isRevert() const;
+  bool isSizeOperator() const;
+
+private:
+  bool exceptionBeforeArbitrate_ {false};
+  const RBAExpression* expression_ {nullptr};
+  RBAExecuteResult result_ {RBAExecuteResult::SKIP};
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::set<const RBAAllocatable*> trueAllocatables_;
+  std::set<const RBAAllocatable*> falseAllocatables_;
+  std::set<const RBAAllocatable*> operandAllocatable_;
+  // use to respond with an empty set
+  const std::set<const RBAAllocatable*> emptyAllocatables_;
+  mutable std::vector<std::shared_ptr<RBAConstraintInfo>> children_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAConstraintMap.hpp b/src/core/logic/RBAConstraintMap.hpp
new file mode 100644
index 0000000..6f37694
--- /dev/null
+++ b/src/core/logic/RBAConstraintMap.hpp
@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAConstraintMap.hpp
+ */
+
+#ifndef RBACONSTRAINTMAP_HPP
+#define RBACONSTRAINTMAP_HPP
+
+namespace rba
+{
+
+enum class RBAConstraintMap : std::uint8_t
+{
+  CONTENT_ALLOCATE_CONSTRAINTS,
+  HIDDEN_TRUE_CHECK_CONSTRAINTS,
+  HIDDEN_FALSE_CHECK_CONSTRAINTS,
+  ATTENUATE_TRUE_CHECK_CONSTRAINTS,
+  ATTENUATE_FALSE_CHECK_CONSTRAINTS,
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAContentStatus.cpp b/src/core/logic/RBAContentStatus.cpp
new file mode 100644
index 0000000..04ed6d9
--- /dev/null
+++ b/src/core/logic/RBAContentStatus.cpp
@@ -0,0 +1,72 @@
+/**
+ * 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.
+ */
+
+//
+// ContentStatus (Content state transition management) class
+//
+
+#include "RBAContentState.hpp"
+#include "RBAContentStatus.hpp"
+#include "RBAContentStatusType.hpp"
+
+namespace rba
+{
+
+void RBAContentStatus::onRequest()
+{
+  if ((status_ != RBAContentStatusType::Displayed)
+      && (status_ != RBAContentStatusType::StandBy)) {
+    status_ = RBAContentStatusType::Undisplayed;
+  }
+}
+void RBAContentStatus::setStatusType(
+    const RBAContentStatusType type)
+{
+  status_ = type;
+}
+RBAContentStatusType RBAContentStatus::getStatusType() const
+{
+  return status_;
+}
+bool RBAContentStatus::isActive() const
+{
+  return ((status_ != RBAContentStatusType::NoRequest)
+      && (status_ != RBAContentStatusType::Canceled));
+}
+
+bool RBAContentStatus::isUndisplayed() const
+{
+  return (status_ == RBAContentStatusType::Undisplayed);
+}
+
+bool RBAContentStatus::isDisplayed() const
+{
+  return (status_ == RBAContentStatusType::Displayed);
+}
+bool RBAContentStatus::isStandby() const
+{
+  return (status_ == RBAContentStatusType::StandBy);
+}
+bool RBAContentStatus::hasBeenCanceled() const
+{
+  return (status_ == RBAContentStatusType::Canceled);
+}
+bool RBAContentStatus::hasBeenDisplayed() const
+{
+  return ((status_ == RBAContentStatusType::Displayed)
+      || (status_ == RBAContentStatusType::StandBy));
+}
+} /* namespace rba */
diff --git a/src/core/logic/RBAContentStatus.hpp b/src/core/logic/RBAContentStatus.hpp
new file mode 100644
index 0000000..69f7e8d
--- /dev/null
+++ b/src/core/logic/RBAContentStatus.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+//
+// ContentStatus (Content state transition management) class
+//
+
+#ifndef RBACONTENTSTATUS_HPP
+#define RBACONTENTSTATUS_HPP
+#include <cstdint>
+
+#include "RBAContentStatusType.hpp"
+
+namespace rba
+{
+class RBAContentState;
+
+class RBAContentStatus
+{
+ public:
+  RBAContentStatus()=default;
+  // Copy constructor is defined in default because it is used in another class
+  RBAContentStatus(const RBAContentStatus&)=default;
+  RBAContentStatus(const RBAContentStatus&&)=delete;
+  // Copy assignment operator is defined in default 
+  //  because it is used in other classes
+  RBAContentStatus& operator=(const RBAContentStatus&)=default;
+  RBAContentStatus& operator=(const RBAContentStatus&&)=delete;
+  virtual ~RBAContentStatus()=default;
+  void onRequest();
+  void setStatusType(const RBAContentStatusType type);
+  RBAContentStatusType getStatusType() const;
+  bool isActive() const;
+  bool isUndisplayed() const;
+  bool isDisplayed() const;
+  bool isStandby() const;
+  bool hasBeenCanceled() const;
+  bool hasBeenDisplayed() const;
+ private:
+  RBAContentStatusType status_ {RBAContentStatusType::NoRequest};
+};
+
+} /* namespace rba */
+
+#endif /* RBACONTENTSTATUS_HPP */
diff --git a/src/core/logic/RBARequest.cpp b/src/core/logic/RBARequest.cpp
new file mode 100644
index 0000000..c55cac1
--- /dev/null
+++ b/src/core/logic/RBARequest.cpp
@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+
+ /**
+ * RBARequest (request arbitration) class implementation 
+ */
+
+#include "RBARequest.hpp"
+
+namespace rba
+{
+
+RBARequest::RBARequest(const std::string& context, const bool isOn) :
+  context_{context},
+  isOn_{isOn}
+{
+}
+
+std::string
+RBARequest::getContext() const
+{
+  return context_;
+}
+
+bool
+RBARequest::isOn() const
+{
+  return isOn_;
+}
+
+}
diff --git a/src/core/logic/RBARequest.hpp b/src/core/logic/RBARequest.hpp
new file mode 100644
index 0000000..b6da5e4
--- /dev/null
+++ b/src/core/logic/RBARequest.hpp
@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+
+ /**
+ * RBARequest (request arbitration) class header
+ */
+
+#ifndef RBAREQUEST_HPP
+#define RBAREQUEST_HPP
+
+#include <string>
+#include "RBADllExport.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBARequest
+{
+ public:
+  explicit RBARequest(const std::string& context, const bool isOn = true);
+  RBARequest(const RBARequest&)=delete;
+  RBARequest(const RBARequest&&)=delete;
+  RBARequest& operator=(const RBARequest&)=delete;
+  RBARequest& operator=(const RBARequest&&)=delete;
+  virtual ~RBARequest()=default;
+
+ public:
+  std::string getContext() const;
+  bool isOn() const;
+  
+ private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::string context_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+  bool isOn_;
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBARequestQueMember.cpp b/src/core/logic/RBARequestQueMember.cpp
new file mode 100644
index 0000000..a5a0d35
--- /dev/null
+++ b/src/core/logic/RBARequestQueMember.cpp
@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+ /**
+ * RBARequestQueueMember class implementation 
+ */
+
+#include <cstdint>
+
+#include "RBARequestQueMember.hpp"
+#include "RBAContentState.hpp"
+
+namespace rba {
+
+RBARequestQueMember::RBARequestQueMember(const RBAContentState* const contentState, const bool isOn,
+                                         const std::uint32_t syncIndex):
+    contentState_{contentState},
+    isOn_{isOn},
+    syncIndex_{syncIndex}
+{
+}
+
+const RBAContentState* RBARequestQueMember::getContentState() const {
+  return contentState_;
+}
+
+bool RBARequestQueMember::isOn() const {
+  return isOn_;
+}
+
+std::uint32_t RBARequestQueMember::getSyncIndex() const {
+  return syncIndex_;
+}
+
+}
diff --git a/src/core/logic/RBARequestQueMember.hpp b/src/core/logic/RBARequestQueMember.hpp
new file mode 100644
index 0000000..cb18987
--- /dev/null
+++ b/src/core/logic/RBARequestQueMember.hpp
@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+ /**
+ * RBARequestQueueMember class header 
+ */
+
+#ifndef RBAREQUESTQUEMEMBER_HPP
+#define RBAREQUESTQUEMEMBER_HPP
+
+#include <cstdint>
+
+namespace rba {
+
+class RBAContentState;
+
+class RBARequestQueMember {
+ public:
+  RBARequestQueMember(const RBAContentState* const contentState, const bool isOn, const std::uint32_t syncIndex);
+  RBARequestQueMember()=delete;
+  RBARequestQueMember(const RBARequestQueMember&)=delete;
+  RBARequestQueMember(const RBARequestQueMember&&)=delete;
+  RBARequestQueMember& operator=(const RBARequestQueMember&)=delete;
+  RBARequestQueMember& operator=(const RBARequestQueMember&&)=delete;
+  virtual ~RBARequestQueMember() = default;
+
+  const RBAContentState* getContentState() const;
+  bool isOn() const;
+  std::uint32_t getSyncIndex() const;
+
+ private:
+  // Content state for which arbitration was requested
+  const RBAContentState* contentState_; 
+  // Whether display/output request or scene ON request
+  bool isOn_;
+
+  /// Index of arbitration syntax
+  /// QueMenber with the same value will be arbitrated at the same timing, 
+  /// and if the values are different, differential arbitration is performed.
+  /// When a request for execute(list,bool) is received, the content icluded
+  /// in the list will all have the same value. 
+  /// When setContentState(ContentState, bool) request is received twice, 
+  /// the first request and the second request have different values.
+  /// When created by onRequest or onWithdrawn, 
+  /// it has the same value as the request that triggered it.
+  std::uint32_t syncIndex_;
+};
+
+}
+
+#endif /* RBAREQUESTQUEMEMBER_HPP */
diff --git a/src/core/logic/RBAResultImpl.cpp b/src/core/logic/RBAResultImpl.cpp
new file mode 100644
index 0000000..41c291f
--- /dev/null
+++ b/src/core/logic/RBAResultImpl.cpp
@@ -0,0 +1,1088 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAResultImpl (result of arbitration implementation) class
+ */
+
+#include "RBAResultImpl.hpp"
+
+#include "RBAContentStatusType.hpp"
+#include "RBAArbitrator.hpp"
+#include "RBAViewContentImpl.hpp"
+#include "RBAViewContentStateImpl.hpp"
+#include "RBASoundContentImpl.hpp"
+#include "RBASoundContentStateImpl.hpp"
+#include "RBAResultSet.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAContentState.hpp"
+#include "RBAContent.hpp"
+#include "RBAAreaImpl.hpp"
+#include "RBAZoneImpl.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBASizeImpl.hpp"
+#include "RBAConstraint.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAViewActionType.hpp"
+#include "RBAViewTransition.hpp"
+#include "RBAViewMove.hpp"
+
+namespace rba {
+
+RBAResultImpl::RBAResultImpl(const RBAArbitrator* const arb,
+                              std::unique_ptr<RBAResultSet> newPrevResultSet):
+                                RBAResult(),
+                                preResultSet_{std::move(newPrevResultSet)},
+                                arb_{arb},
+                                statusType_{RBAResultStatusType::SUCCESS}
+{
+  curResultSet_ = std::make_unique<RBAResultSet>();
+  curResultSet_->copyActives(preResultSet_);
+  curResultSet_->copyProperties(preResultSet_);
+}
+
+RBAResultImpl::RBAResultImpl(const RBAArbitrator* const arb,
+                              std::unique_ptr<RBAResultSet> newPrevResultSet,
+                              std::unique_ptr<RBAResultSet> newCurResultSet):
+                                RBAResult(),
+                                curResultSet_{std::move(newCurResultSet)},
+                                preResultSet_{std::move(newPrevResultSet)},
+                                arb_{arb},
+                                statusType_{RBAResultStatusType::SUCCESS}
+{
+}
+
+RBAResultImpl::RBAResultImpl(const RBAResultImpl* const replicationTarget)
+  : RBAResult{},
+    curResultSet_{std::make_unique<RBAResultSet>(*(replicationTarget->curResultSet_.get()))},
+    preResultSet_{std::make_unique<RBAResultSet>(*(replicationTarget->preResultSet_.get()))},
+    arb_{replicationTarget->arb_},
+    statusType_{RBAResultStatusType::SUCCESS},
+    log_{replicationTarget->log_}
+{
+  for (const auto &va : replicationTarget->viewActions_) {
+    if (va->getViewActionType() == RBAViewActionType::MOVE) {
+      viewActions_.push_back(
+          std::make_unique<RBAViewMove>(va->getFromArea(), va->getToArea(),
+                                        va->getContentState()));
+    } else if (va->getViewActionType()
+        == RBAViewActionType::TRANSITION_REPLACE) {
+      viewActions_.push_back(
+          std::make_unique<RBAViewTransition>(va->getViewActionType(),
+                                              va->getArea(),
+                                              va->getFromContentState(),
+                                              va->getToContentState()));
+    } else {
+      viewActions_.push_back(
+          std::make_unique<RBAViewTransition>(va->getViewActionType(),
+                                              va->getArea(),
+                                              va->getContentState()));
+    }
+  }
+}
+
+//
+// External
+//
+
+// [get VisibleArea/SoundingZone]
+
+const std::list<const RBAArea*>&
+RBAResultImpl::getVisibleAreas() const
+{
+  return curResultSet_->getVisibleAreas();
+}
+
+const std::list<const RBAArea*>&
+RBAResultImpl::getPreVisibleAreas() const
+{
+  return preResultSet_->getVisibleAreas();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getSoundingZones() const
+{
+  return curResultSet_->getSoundingZones();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getPreSoundingZones() const
+{
+  return preResultSet_->getSoundingZones();
+}
+
+// [get Visible/Sounding ContentStates]
+
+const std::list<const RBAViewContentState*>&
+RBAResultImpl::getVisibleContentStates() const
+{
+  return curResultSet_->getVisibleContentStates();
+}
+
+const std::list<const RBAViewContentState*>&
+RBAResultImpl::getPreVisibleContentStates() const
+{
+  return preResultSet_->getVisibleContentStates();
+}
+
+const std::list<const RBASoundContentState*>&
+RBAResultImpl::getSoundingContentStates() const
+{
+  return curResultSet_->getSoundingContentStates();
+}
+
+const std::list<const RBASoundContentState*>&
+RBAResultImpl::getPreSoundingContentStates() const
+{
+  return preResultSet_->getSoundingContentStates();
+}
+
+// [get Active View/Sound ContentStates]
+
+const std::list<const RBAViewContentState*>&
+RBAResultImpl::getActiveViewContentStates() const
+{
+  return curResultSet_->getActiveViewContentStates();
+}
+
+const std::list<const RBAViewContentState*>&
+RBAResultImpl::getPreActiveViewContentStates() const
+{
+  return preResultSet_->getActiveViewContentStates();
+}
+
+const std::list<const RBASoundContentState*>&
+RBAResultImpl::getActiveSoundContentStates() const
+{
+  return curResultSet_->getActiveSoundContentStates();
+}
+
+const std::list<const RBASoundContentState*>&
+RBAResultImpl::getPreActiveSoundContentStates() const
+{
+  return preResultSet_->getActiveSoundContentStates();
+}
+
+// [get etActive Scenes]
+
+const std::list<const RBAScene*>&
+RBAResultImpl::getActiveScenes() const
+{
+  return curResultSet_->getActiveScenes();
+}
+
+const std::list<const RBAScene*>&
+RBAResultImpl::getPreActiveScenes() const
+{
+  return preResultSet_->getActiveScenes();
+}
+
+// [get InvisibleAreas/UnsoundingZone]
+
+const std::list<const RBAArea*>&
+RBAResultImpl::getInvisibleAreas() const
+{
+  return curResultSet_->getInvisibleAreas();
+}
+
+const std::list<const RBAArea*>&
+RBAResultImpl::getPreInvisibleAreas() const
+{
+  return preResultSet_->getInvisibleAreas();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getUnsoundingZones() const
+{
+  return curResultSet_->getUnsoundingZones();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getPreUnsoundingZones() const
+{
+  return preResultSet_->getUnsoundingZones();
+}
+
+// [get HiddenAreas/MuteZones]
+
+const std::list<const RBAArea*>&
+RBAResultImpl::getHiddenAreas() const
+{
+  return curResultSet_->getHiddenAreas();
+}
+
+const std::list<const RBAArea*>&
+RBAResultImpl::getPreHiddenAreas() const
+{
+  return preResultSet_->getHiddenAreas();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getMuteZones() const
+{
+  return curResultSet_->getMuteZones();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getPreMuteZones() const
+{
+  return preResultSet_->getMuteZones();
+}
+
+// [get Attenuated]
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getAttenuatedZones() const
+{
+  return curResultSet_->getAttenuatedZones();
+}
+
+const std::list<const RBAZone*>&
+RBAResultImpl::getPreAttenuatedZones() const
+{
+  return preResultSet_->getAttenuatedZones();
+}
+
+// [get Canceled Contents]
+
+const std::list<const RBAViewContent*>&
+RBAResultImpl::getCanceledViewContents() const
+{
+  return curResultSet_->getCanceledViewContents();
+}
+
+const std::list<const RBAViewContent*>&
+RBAResultImpl::getPreCanceledViewContents() const
+{
+  return preResultSet_->getCanceledViewContents();
+}
+
+const std::list<const RBASoundContent*>&
+RBAResultImpl::getCanceledSoundContents() const
+{
+  return curResultSet_->getCanceledSoundContents();
+}
+
+const std::list<const RBASoundContent*>&
+RBAResultImpl::getPreCanceledSoundContents() const
+{
+  return preResultSet_->getCanceledSoundContents();
+}
+
+// [get Standby Contents]
+
+const std::list<const RBAViewContent*>&
+RBAResultImpl::getStandbyViewContents() const
+{
+  return curResultSet_->getStandbyViewContents();
+}
+
+const std::list<const RBAViewContent*>&
+RBAResultImpl::getPreStandbyViewContents() const
+{
+  return preResultSet_->getStandbyViewContents();
+}
+
+const std::list<const RBASoundContent*>&
+RBAResultImpl::getStandbySoundContents() const
+{
+  return curResultSet_->getStandbySoundContents();
+}
+
+const std::list<const RBASoundContent*>&
+RBAResultImpl::getPreStandbySoundContents() const
+{
+  return preResultSet_->getStandbySoundContents();
+}
+
+// [get ContentStates]
+
+const RBAViewContentState*
+RBAResultImpl::getContentState(const RBAArea* area) const
+{
+  return dynamic_cast<const RBAViewContentState*>(
+          curResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(area)));
+}
+
+const RBAViewContentState*
+RBAResultImpl::getPreContentState(const RBAArea* area) const
+{
+  return dynamic_cast<const RBAViewContentState*>(
+          preResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(area)));
+}
+
+const RBASoundContentState*
+RBAResultImpl::getContentState(const RBAZone* zone) const
+{
+  return dynamic_cast<const RBASoundContentState*>(
+          curResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(zone)));
+}
+
+const RBASoundContentState*
+RBAResultImpl::getPreContentState(const RBAZone* zone) const
+{
+  return dynamic_cast<const RBASoundContentState*>(
+          preResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(zone)));
+}
+
+// [get Areas/Zones by ConentState]
+
+const std::list<const RBAArea*>
+RBAResultImpl::getArea(const RBAViewContentState* state) const
+{
+  std::list<const RBAArea*> areaList;
+  curResultSet_->getArea(state, areaList);
+  return areaList;
+}
+
+const std::list<const RBAArea*>
+RBAResultImpl::getPreArea(const RBAViewContentState* state) const
+{
+  std::list<const RBAArea*> areaList;
+  preResultSet_->getArea(state, areaList);
+  return areaList;
+}
+
+const std::list<const RBAZone*>
+RBAResultImpl::getZone(const RBASoundContentState* state) const
+{
+  std::list<const RBAZone*> zoneList;
+  curResultSet_->getZone(state, zoneList);
+  return zoneList;
+}
+
+const std::list<const RBAZone*>
+RBAResultImpl::getPreZone(const RBASoundContentState* state) const
+{
+  std::list<const RBAZone*> zoneList;
+  preResultSet_->getZone(state, zoneList);
+  return zoneList;
+}
+
+// [get Areas/Zones by Content]
+
+const std::list<const RBAArea*>
+RBAResultImpl::getArea(const RBAViewContent* content) const
+{
+  std::list<const RBAArea*> areaList;
+  curResultSet_->getArea(content, areaList);
+  return areaList;
+}
+
+const std::list<const RBAArea*>
+RBAResultImpl::getPreArea(const RBAViewContent* content) const
+{
+  std::list<const RBAArea*> areaList;
+  preResultSet_->getArea(content, areaList);
+  return areaList;
+}
+
+const std::list<const RBAZone*>
+RBAResultImpl::getZone(const RBASoundContent* content) const
+{
+  std::list<const RBAZone*> zoneList;
+  curResultSet_->getZone(content, zoneList);
+  return zoneList;
+}
+
+const std::list<const RBAZone*>
+RBAResultImpl::getPreZone(const RBASoundContent* content) const
+{
+  std::list<const RBAZone*> zoneList;
+  preResultSet_->getZone(content, zoneList);
+  return zoneList;
+}
+
+// [get Size]
+
+const RBASize*
+RBAResultImpl::getSize(const RBAArea* area) const
+{
+  return curResultSet_->getSize(area);
+}
+
+const RBASize*
+RBAResultImpl::getPreSize(const RBAArea* area) const
+{
+  return preResultSet_->getSize(area);
+}
+
+// [check Active Scene]
+bool
+RBAResultImpl::isActive(const RBAScene* scene) const
+{
+  return curResultSet_->isActive(scene);
+}
+
+bool
+RBAResultImpl::isPreActive(const RBAScene* scene) const
+{
+  return preResultSet_->isActive(scene);
+}
+
+// [check Active Content]
+bool
+RBAResultImpl::isActive(const RBAContent* const content) const
+{
+  return curResultSet_->isActive(content);
+}
+bool
+RBAResultImpl::isActive(const RBAViewContent* content) const
+{
+  return curResultSet_->isActive(dynamic_cast<const RBAContent*>(content));
+}
+
+bool
+RBAResultImpl::isActive(const RBASoundContent* content) const
+{
+  return curResultSet_->isActive(dynamic_cast<const RBAContent*>(content));
+}
+bool
+RBAResultImpl::isPreActive(const RBAContent* const content) const
+{
+  return preResultSet_->isActive(content);
+}
+bool
+RBAResultImpl::isPreActive(const RBAViewContent* content) const
+{
+  return preResultSet_->isActive(dynamic_cast<const RBAContent*>(content));
+}
+
+bool
+RBAResultImpl::isPreActive(const RBASoundContent* content) const
+{
+  return preResultSet_->isActive(dynamic_cast<const RBAContent*>(content));
+}
+
+// [check Active ContentState]
+bool
+RBAResultImpl::isActive(const RBAContentState* const state) const
+{
+  return curResultSet_->isActive(state);
+}
+
+bool
+RBAResultImpl::isActive(const RBAViewContentState* const state) const
+{
+  return isActive(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isActive(const RBASoundContentState* const state) const
+{
+  return isActive(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isPreActive(const RBAContentState* const state) const
+{
+  return preResultSet_->isActive(state);
+}
+
+bool
+RBAResultImpl::isPreActive(const RBAViewContentState* const state) const
+{
+  return isPreActive(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isPreActive(const RBASoundContentState* const state) const
+{
+  return isPreActive(dynamic_cast<const RBAContentState*>(state));
+}
+
+const RBAContentState*
+RBAResultImpl::getActiveState(const RBAContent* const content) const
+{
+  if (curResultSet_->isActive(content)){
+    return curResultSet_->getReqestState(content);
+  }
+  return nullptr;
+}
+
+const RBAContentState*
+RBAResultImpl::getPreActiveState(const RBAContent* const content) const
+{
+  if (preResultSet_->isActive(content)){
+    return preResultSet_->getReqestState(content);
+  }
+  return nullptr;
+}
+
+// [check Visible/Sounding Alloc ContentState]
+
+bool
+RBAResultImpl::isOutputting(const RBAAllocatable* const alloc) const
+{
+  return curResultSet_->isOutputting(alloc);
+}
+
+bool
+RBAResultImpl::isPreOutputting(const RBAAllocatable* const alloc) const
+{
+  return preResultSet_->isOutputting(alloc);
+}
+
+bool
+RBAResultImpl::isOutputting(const RBAContentState* const state) const
+{
+  return curResultSet_->isOutputting(state);
+}
+
+bool
+RBAResultImpl::isPreOutputting(const RBAContentState* const state) const
+{
+  return preResultSet_->isOutputting(state);
+}
+
+bool
+RBAResultImpl::isVisible(const RBAViewContentState* state) const
+{
+  return isOutputting(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isPreVisible(const RBAViewContentState* state) const
+{
+  return isPreOutputting(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isSounding(const RBASoundContentState* state) const
+{
+  return isOutputting(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isPreSounding(const RBASoundContentState* state) const
+{
+  return isPreOutputting(dynamic_cast<const RBAContentState*>(state));
+}
+
+// [get View/Sound ContentState]
+
+const RBAContentState*
+RBAResultImpl::getAllocatedContentState(const RBAAllocatable* const allocatable) const
+{
+  return curResultSet_->getContentState(allocatable);
+}
+
+const RBAContentState*
+RBAResultImpl::getPreAllocatedContentState(const RBAAllocatable* const allocatable) const
+{
+  return preResultSet_->getContentState(allocatable);
+}
+
+const RBAViewContentState*
+RBAResultImpl::getViewContentState(const RBAArea* area) const
+{
+  return dynamic_cast<const RBAViewContentState*>(
+          curResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(area)));
+}
+
+const RBAViewContentState*
+RBAResultImpl::getPreViewContentState(const RBAArea* area) const
+{
+  return dynamic_cast<const RBAViewContentState*>(
+          preResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(area)));
+}
+
+const RBASoundContentState*
+RBAResultImpl::getSoundContentState(const RBAZone* zone) const
+{
+  return dynamic_cast<const RBASoundContentState*>(
+          curResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(zone)));
+}
+
+const RBASoundContentState*
+RBAResultImpl::getPreSoundContentState(const RBAZone* zone) const
+{
+  return dynamic_cast<const RBASoundContentState*>(
+          preResultSet_->getContentState(dynamic_cast<const RBAAllocatable*>(zone)));
+}
+
+// [check Hidden/Mute]
+
+bool
+RBAResultImpl::isHidden(const RBAArea* area) const
+{
+  return isHidden(dynamic_cast<const RBAAllocatable*>(area));
+}
+
+bool
+RBAResultImpl::isPreHidden(const RBAArea* area) const
+{
+  return isPreHidden(dynamic_cast<const RBAAllocatable*>(area));
+}
+
+bool
+RBAResultImpl::isMute(const RBAZone* zone) const
+{
+  return isHidden(dynamic_cast<const RBAAllocatable*>(zone));
+}
+
+bool
+RBAResultImpl::isPreMute(const RBAZone* zone) const
+{
+  return isPreHidden(dynamic_cast<const RBAAllocatable*>(zone));
+}
+
+// [check Attenuated]
+bool
+RBAResultImpl::isAttenuated(const RBAZone* zone) const
+{
+  return curResultSet_->isAttenuated(zone);
+}
+
+bool
+RBAResultImpl::isPreAttenuated(const RBAZone* zone) const
+{
+  return preResultSet_->isAttenuated(zone);
+}
+
+// [common]
+
+const std::list<const RBAViewAction*>&
+RBAResultImpl::getViewActions() const
+{
+  viewActionsForPublicUse_.clear();
+  for (auto& va :viewActions_) {
+    viewActionsForPublicUse_.push_back(va.get());
+  }
+  return viewActionsForPublicUse_;
+}
+
+RBAResultStatusType
+RBAResultImpl::getStatusType() const
+{
+  return statusType_;
+}
+
+bool
+RBAResultImpl::isLater(const RBAContent* const target,
+                       const RBAContent* const comparisonTarget) const
+{
+  return curResultSet_->isLater(target, comparisonTarget);
+}
+
+std::string
+RBAResultImpl::getLog() const
+{
+  return log_;
+}
+
+void
+RBAResultImpl::setLog(const std::string& log)
+{
+  log_ = log;
+}
+
+bool
+RBAResultImpl::hasDisplayingArea(const RBADisplay* display) const
+{
+  if (display == nullptr) {
+    return false;
+  } else {
+    return curResultSet_->hasDisplayingArea(display);
+  }
+}
+
+bool
+RBAResultImpl::satisfiesConstraints() const
+{
+  if(statusType_ != RBAResultStatusType::SUCCESS) {
+    return false;
+  }
+  return arb_->satisfiesConstraints();
+}
+
+void
+RBAResultImpl::setSceneProperty(const RBASceneImpl* const scene,
+                                const std::string& propertyName,
+                                const std::int32_t value)
+{
+  curResultSet_->setSceneProperty(scene->getProperty(propertyName), value);
+}
+
+void
+RBAResultImpl::setSceneProperty(const RBAAbstractProperty* const property,
+                                const std::int32_t value)
+{
+  curResultSet_->setSceneProperty(property, value);
+}
+
+std::int32_t
+RBAResultImpl::getSceneProperty(const RBAScene* scene,
+				const std::string& propertyName) const
+{
+  if(scene == nullptr) {
+    return -99;
+  }
+
+  const RBAAbstractProperty* const prop
+    {dynamic_cast<const RBASceneImpl*>(scene)->getProperty(propertyName)};
+  if(prop == nullptr) {
+    return -99;
+  }
+
+  return curResultSet_->getSceneProperty(prop);
+}
+
+std::int32_t
+RBAResultImpl::getSceneProperty(const RBAAbstractProperty* const property) const
+{
+  return curResultSet_->getSceneProperty(property);
+}
+
+std::int32_t
+RBAResultImpl::getPreSceneProperty(const RBAAbstractProperty* const property) const
+{
+  return preResultSet_->getSceneProperty(property);
+}
+
+//
+// Internal
+//
+
+// Impl [VisibleArea/SoundingZone]
+
+const std::set<const RBAAllocatable*>&
+RBAResultImpl::getOutputtingAllocatables() const
+{
+  return curResultSet_->getOutputtingAllocatables();
+}
+
+// Impl [get Active View/Sound ContentStates]
+
+const std::set<const RBAContentState*>&
+RBAResultImpl::getActiveContentStates() const
+{
+  return curResultSet_->getActiveContentStates();
+}
+
+// Impl [get ContentStates]
+const RBAContentState*
+RBAResultImpl::getContentState(const RBAAllocatable* const allocatable) const
+{
+  return curResultSet_->getContentState(allocatable);
+}
+
+const RBAContentState*
+RBAResultImpl::getDirectContentState(const RBAAllocatable* const allocatable) const
+{
+  return curResultSet_->getDirectContentState(allocatable);
+}
+
+const RBAContentState*
+RBAResultImpl::getPreContentState(const RBAAllocatable* const allocatable) const
+{
+  return preResultSet_->getContentState(allocatable);
+}
+
+const RBAContentState*
+RBAResultImpl::getDirectPreContentState(const RBAAllocatable* const allocatable) const
+{
+  return preResultSet_->getDirectContentState(allocatable);
+}
+
+// Impl [get Areas/Zones by ConentState]
+
+std::list<const RBAAllocatable*>
+RBAResultImpl::getAllocatable(const RBAContentState* const state) const
+{
+  std::list<const RBAAllocatable*> allocatables;
+  if(state->isViewContentState()) {
+    std::list<const RBAArea*> areaList;
+    curResultSet_->getArea(dynamic_cast<const RBAViewContentState*>(state),
+			   areaList);
+    for (const auto& area : areaList) {
+      allocatables.push_back(dynamic_cast<const RBAAllocatable*>(area));
+    }
+  }
+  else {
+    std::list<const RBAZone*> zoneList;
+    curResultSet_->getZone(dynamic_cast<const RBASoundContentState*>(state),
+			   zoneList);
+    for (const auto& zone : zoneList) {
+      allocatables.push_back(dynamic_cast<const RBAAllocatable*>(zone));
+    }
+  }
+  return allocatables;
+}
+
+// Impl [check Aleady Visible/Sounding]
+bool
+RBAResultImpl::isAlreadyOutputting(const RBAContentState* const state) const
+{
+  return curResultSet_->isAlreadyOutputting(state);
+}
+
+// Impl [set Active Scene]
+
+void
+RBAResultImpl::setActive(const RBAScene* const scene, const bool newActive)
+{
+  curResultSet_->setActive(scene, newActive);
+}
+
+// Impl [set Active ContentState]
+
+void
+RBAResultImpl::setActive(const RBAContentState* const state, const bool newActive)
+{
+  curResultSet_->setActive(state, newActive);
+}
+
+// Impl [add Standby Content]
+
+void
+RBAResultImpl::addStandbyContent(const RBAContent* const content)
+{
+  curResultSet_->addStandbyContent(content);
+}
+
+// Impl [check Visible/Sounding Area/Zone]
+
+bool
+RBAResultImpl::isVisible(const RBAArea* area) const
+{
+  return curResultSet_->isOutputting(dynamic_cast<const RBAAllocatable*>(area));
+}
+
+bool
+RBAResultImpl::isPreVisible(const RBAArea* area) const
+{
+  return preResultSet_->isOutputting(dynamic_cast<const RBAAllocatable*>(area));
+}
+
+bool
+RBAResultImpl::isSounding(const RBAZone* zone) const
+{
+  return curResultSet_->isOutputting(dynamic_cast<const RBAAllocatable*>(zone));
+}
+
+bool
+RBAResultImpl::isPreSounding(const RBAZone* zone) const
+{
+  return preResultSet_->isOutputting(dynamic_cast<const RBAAllocatable*>(zone));
+}
+
+// Impl [set View/Sound ContentState]
+
+void RBAResultImpl::setContentState(const RBAAllocatable* const allocatable,
+                                    const RBAContentState* const state)
+{
+  curResultSet_->setContentState(allocatable, state);
+}
+
+// Impl [check Hidden/Mute Area/Zone]
+
+bool
+RBAResultImpl::isHidden(const RBAAllocatable* const allocatable) const
+{
+  return curResultSet_->isHidden(allocatable);
+}
+
+bool
+RBAResultImpl::isPreHidden(const RBAAllocatable* const allocatable) const
+{
+  return preResultSet_->isHidden(allocatable);
+}
+
+// Impl [set Cancel ContentState]
+
+void
+RBAResultImpl::setCancel(const RBAContentState* const state, const bool checked)
+{
+  curResultSet_->setCancel(state, checked);
+}
+
+// Impl [check Cancel ContentState]
+
+bool
+RBAResultImpl::isCancel(const RBAContentState* const state) const
+{
+  return curResultSet_->isCancel(state);
+}
+
+bool
+RBAResultImpl::isPreCancel(const RBAContentState* const state) const
+{
+  return preResultSet_->isCancel(state);
+}
+
+bool
+RBAResultImpl::isCancel(const RBAViewContentState* state) const
+{
+  return isCancel(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isPreCancel(const RBAViewContentState* state) const
+{
+  return isPreCancel(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isCancel(const RBASoundContentState* state) const
+{
+  return isCancel(dynamic_cast<const RBAContentState*>(state));
+}
+
+bool
+RBAResultImpl::isPreCancel(const RBASoundContentState* state) const
+{
+  return isPreCancel(dynamic_cast<const RBAContentState*>(state));
+}
+
+// Impl [add Visible/Sounding ContentState]
+
+void
+RBAResultImpl::addOutputtingContentState(const RBAContentState* const state)
+{
+  curResultSet_->addOutputtingContentState(state);
+}
+
+// Impl [cancel ContentState]
+
+void
+RBAResultImpl::cancelContentState(const RBAContentState* const state)
+{
+  curResultSet_->cancelContentState(state);
+}
+
+// Impl [common]
+
+std::unique_ptr<RBAResultSet>
+RBAResultImpl::createBackupCurrentResultSet()
+{
+  return std::make_unique<RBAResultSet>(*curResultSet_);
+}
+
+std::unique_ptr<RBAResultSet>
+RBAResultImpl::createNextCurrentResultSet()
+{
+  std::unique_ptr<RBAResultSet> nextResultSet {std::make_unique<RBAResultSet>()};
+  nextResultSet->copyActives(curResultSet_);
+  nextResultSet->copyProperties(curResultSet_);
+  return nextResultSet;
+}
+
+void
+RBAResultImpl::addViewAction(std::unique_ptr<RBAViewAction>& newViewAction)
+{
+  viewActions_.push_back(move(newViewAction));
+}
+
+void
+RBAResultImpl::setStatusType(const RBAResultStatusType newStatusType)
+{
+  statusType_ = newStatusType;
+}
+
+void
+RBAResultImpl::updateActiveContentStates()
+{
+  curResultSet_->updateActiveContentStates();
+}
+
+void
+RBAResultImpl::setContentOfEventProcessing(const RBAEventProcessing* const eventProcessing,
+					                                 const RBAContent* const viewContent)
+{
+  curResultSet_->setContentOfEventProcessing(eventProcessing, viewContent);
+}
+
+std::unique_ptr<RBAResultSet>&
+RBAResultImpl::getCurResultSet()
+{
+  return curResultSet_;
+}
+
+std::unique_ptr<RBAResultSet>&
+RBAResultImpl::getPreResultSet()
+{
+  return preResultSet_;
+}
+
+RBAContentStatusType RBAResultImpl::getStatusType(const RBAContent* const content) const
+{
+  return curResultSet_->getStatusType(content);
+}
+bool RBAResultImpl::isStandby(const RBAContent* const content) const
+{
+  return curResultSet_->isStandby(content);
+}
+
+bool RBAResultImpl::hasBeenCanceled(const RBAContent* const content) const
+{
+  return curResultSet_->hasBeenCanceled(content);
+}
+
+bool RBAResultImpl::hasBeenPreCanceled(const RBAContent* const content) const
+{
+  return preResultSet_->hasBeenCanceled(content);
+}
+
+bool RBAResultImpl::hasBeenDisplayed(const RBAContent* const content) const
+{
+  return curResultSet_->hasBeenDisplayed(content);
+}
+bool RBAResultImpl::hasBeenPreDisplayed(const RBAContent* const content) const
+{
+  return preResultSet_->hasBeenDisplayed(content);
+}
+
+void RBAResultImpl::updateStatus(const RBAContent* const content)
+{
+  const RBAContentState* const s {getActiveState(content)};
+  if (s != nullptr) {
+    if (isOutputting(s)) {
+      curResultSet_->setStatusType(content, RBAContentStatusType::Displayed);
+    } else if (isCancel(s)) {
+      curResultSet_->setStatusType(content, RBAContentStatusType::Canceled);
+    } else if (curResultSet_->getStatusType(content) != RBAContentStatusType::Undisplayed) {
+      curResultSet_->setStatusType(content, RBAContentStatusType::StandBy);
+    } else {
+      ;
+    }
+  }
+}
+
+std::unordered_map<const RBAContent*, RBAContentStatus>* RBAResultImpl::getCurStatus() const
+{
+  return curResultSet_->getStatus();
+}
+
+std::set<const RBASceneImpl*>& RBAResultImpl::getDifferentConditionScenes() const
+{
+  return (curResultSet_->getDifferentConditionScenes(*preResultSet_.get()));
+}
+#ifdef RBA_USE_LOG
+void
+RBAResultImpl::addFailedConstraint(const RBAConstraint* constraint)
+{
+  curResultSet_->addFailedConstraint(constraint);
+}
+
+const std::list<const RBAConstraint*>&
+RBAResultImpl::getFailedConstraints() const
+{
+  return curResultSet_->getFailedConstraints();
+}
+#endif
+
+}
diff --git a/src/core/logic/RBAResultImpl.hpp b/src/core/logic/RBAResultImpl.hpp
new file mode 100644
index 0000000..d7a1aa1
--- /dev/null
+++ b/src/core/logic/RBAResultImpl.hpp
@@ -0,0 +1,343 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAResultImpl (result of arbitration implementation) class header
+ */
+
+#ifndef RBARESULTIMPL_HPP
+#define RBARESULTIMPL_HPP
+
+#include <memory>
+#include <unordered_map>
+#include <set>
+#include "RBAResult.hpp"
+#include "RBAResultStatusType.hpp"
+#include "RBAContentStatusType.hpp"
+
+namespace rba {
+
+class RBAArbitrator;
+class RBAArea;
+class RBAViewContent;
+class RBAViewContentState;
+class RBASize;
+class RBAScene;
+class RBAAbstractProperty;
+class RBAAreaImpl;
+class RBAContentStateImpl;
+class RBAViewContentImpl;
+class RBAViewContentStateImpl;
+class RBASizeImpl;
+class RBASceneImpl;
+class RBAResultSet;
+class RBAViewAction;
+class RBAZoneImpl;
+class RBASoundContentImpl;
+class RBASoundContentStateImpl;
+class RBASoundContent;
+class RBASoundContentState;
+class RBAContentState;
+class RBAAllocatable;
+class RBAContent;
+class RBAEventProcessing;
+class RBAConstraint;
+class RBAContentStatus;
+
+class DLL_EXPORT RBAResultImpl : public RBAResult
+{
+public:
+  RBAResultImpl(const RBAArbitrator* const arb,
+                std::unique_ptr<RBAResultSet> newPrevResultSet);
+  RBAResultImpl(const RBAArbitrator* const arb,
+                std::unique_ptr<RBAResultSet> newPrevResultSet,
+                std::unique_ptr<RBAResultSet> newCurResultSet);
+  RBAResultImpl(const RBAResultImpl* const replicationTarget);
+  RBAResultImpl(const RBAResultImpl&)=delete;
+  RBAResultImpl(const RBAResultImpl&&)=delete;
+  RBAResultImpl& operator=(const RBAResultImpl&)=delete;
+  RBAResultImpl& operator=(const RBAResultImpl&&)=delete;
+  virtual ~RBAResultImpl()=default;
+
+public:
+
+  //
+  // External
+  //
+
+  // [get VisibleArea/SoundingZone]
+  const std::list<const RBAArea*>& getVisibleAreas() const override;
+  const std::list<const RBAArea*>& getPreVisibleAreas() const override;
+  const std::list<const RBAZone*>& getSoundingZones() const override;
+  const std::list<const RBAZone*>& getPreSoundingZones() const override;
+
+  // [get Visible/Sounding ContentStates]
+  const std::list<const RBAViewContentState*>& getVisibleContentStates() const override;
+  const std::list<const RBAViewContentState*>& getPreVisibleContentStates() const override;
+  const std::list<const RBASoundContentState*>& getSoundingContentStates() const override;
+  const std::list<const RBASoundContentState*>& getPreSoundingContentStates() const override;
+
+  // [get Active View/Sound ContentStates]
+  const std::list<const RBAViewContentState*>& getActiveViewContentStates() const override;
+  const std::list<const RBAViewContentState*>& getPreActiveViewContentStates() const override;
+  const std::list<const RBASoundContentState*>& getActiveSoundContentStates() const override;
+  const std::list<const RBASoundContentState*>& getPreActiveSoundContentStates() const override;
+
+  // [get Active Scenes]
+  const std::list<const RBAScene*>& getActiveScenes() const override;
+  const std::list<const RBAScene*>& getPreActiveScenes() const override;
+
+  // [get InvisibleAreas/UnsoundingZone]
+  const std::list<const RBAArea*>& getInvisibleAreas() const override;
+  const std::list<const RBAArea*>& getPreInvisibleAreas() const override;
+  const std::list<const RBAZone*>& getUnsoundingZones() const override;
+  const std::list<const RBAZone*>& getPreUnsoundingZones() const override;
+
+  // [get HiddenAreas/MuteZones]
+  const std::list<const RBAArea*>& getHiddenAreas() const override;
+  const std::list<const RBAArea*>& getPreHiddenAreas() const override;
+  const std::list<const RBAZone*>& getMuteZones() const override;
+  const std::list<const RBAZone*>& getPreMuteZones() const override;
+
+  // [get Attenuated]
+  const std::list<const RBAZone*>& getAttenuatedZones() const override;
+  const std::list<const RBAZone*>& getPreAttenuatedZones() const override;
+
+  // [get Canceled Contents]
+  const std::list<const RBAViewContent*>& getCanceledViewContents() const override;
+  const std::list<const RBAViewContent*>& getPreCanceledViewContents() const override;
+  const std::list<const RBASoundContent*>& getCanceledSoundContents() const override;
+  const std::list<const RBASoundContent*>& getPreCanceledSoundContents() const override;
+
+  // [get Standby Contents]
+  const std::list<const RBAViewContent*>& getStandbyViewContents() const override;
+  const std::list<const RBAViewContent*>& getPreStandbyViewContents() const override;
+  const std::list<const RBASoundContent*>& getStandbySoundContents() const override;
+  const std::list<const RBASoundContent*>& getPreStandbySoundContents() const override;
+
+  // [get ContentStates]
+  const RBAViewContentState* getContentState(const RBAArea* area) const override;
+  const RBAViewContentState* getPreContentState(const RBAArea* area) const override;
+  const RBASoundContentState* getContentState(const RBAZone* zone) const override;
+  const RBASoundContentState* getPreContentState(const RBAZone* zone) const override;
+
+  // [get Areas/Zones by ConentState]
+  const std::list<const RBAArea*> getArea(const RBAViewContentState* state) const override;
+  const std::list<const RBAArea*> getPreArea(const RBAViewContentState* state) const override;
+  const std::list<const RBAZone*> getZone(const RBASoundContentState* state) const override;
+  const std::list<const RBAZone*> getPreZone(const RBASoundContentState* state) const override;
+
+  // [get Areas/Zones by Content]
+  const std::list<const RBAArea*> getArea(const RBAViewContent* content) const override;
+  const std::list<const RBAArea*> getPreArea(const RBAViewContent* content) const override;
+  const std::list<const RBAZone*> getZone(const RBASoundContent* content) const override;
+  const std::list<const RBAZone*> getPreZone(const RBASoundContent* content) const override;
+
+  // [get Size]
+  const RBASize* getSize(const RBAArea* area) const override;
+  const RBASize* getPreSize(const RBAArea* area) const override;
+
+  // [check Active Scene]
+  bool isActive(const RBAScene* scene) const override;
+  bool isPreActive(const RBAScene* scene) const override;
+
+  // [check Active Content]
+  bool isActive(const RBAContent* const content) const;
+  bool isPreActive(const RBAContent* const content) const;
+  bool isActive(const RBAViewContent* content) const override;
+  bool isActive(const RBASoundContent* content) const override;
+  bool isPreActive(const RBAViewContent* content) const override;
+  bool isPreActive(const RBASoundContent* content) const override;
+
+  // [check Visible/Sounding Area/Zone]
+  bool isVisible(const RBAArea* area) const override;
+  bool isPreVisible(const RBAArea* area) const override;
+  bool isSounding(const RBAZone* zone) const override;
+  bool isPreSounding(const RBAZone* zone) const override;
+
+  // [check Visible/Sounding ContentState]
+  bool isVisible(const RBAViewContentState* state) const override;
+  bool isPreVisible(const RBAViewContentState* state) const override;
+  bool isSounding(const RBASoundContentState* state) const override;
+  bool isPreSounding(const RBASoundContentState* state) const override;
+
+  // [get View/Sound ContentState]
+  const RBAViewContentState* getViewContentState(const RBAArea* area) const override;
+  virtual const RBAViewContentState* getPreViewContentState(const RBAArea* area) const;
+  const RBASoundContentState* getSoundContentState(const RBAZone* zone) const override;
+  const RBASoundContentState* getPreSoundContentState(const RBAZone* zone) const override;
+
+  // [check Hidden/Mute]
+  bool isHidden(const RBAArea* area) const override;
+  bool isPreHidden(const RBAArea* area) const override;
+  bool isMute(const RBAZone* zone) const override;
+  bool isPreMute(const RBAZone* zone) const override;
+
+  // [check Attenuated]
+  bool isAttenuated(const RBAZone* zone) const override;
+  bool isPreAttenuated(const RBAZone* zone) const override;
+
+  // [check Cancel]
+  bool isCancel(const RBAViewContentState* state) const override;
+  bool isPreCancel(const RBAViewContentState* state) const override;
+  bool isCancel(const RBASoundContentState* state) const override;
+  bool isPreCancel(const RBASoundContentState* state) const override;
+
+  // [common]
+  const std::list<const RBAViewAction*>& getViewActions() const override;
+  RBAResultStatusType getStatusType() const override;
+  bool isLater(const RBAContent* const target,
+               const RBAContent* const comparisonTarget) const;
+
+  std::string getLog() const override;
+  void setLog(const std::string& log);
+
+  bool hasDisplayingArea(const RBADisplay* display) const override;
+
+  bool satisfiesConstraints() const override;
+
+  std::int32_t getSceneProperty(const RBAScene* scene,
+					            const std::string& propertyName) const override;
+  //
+  // Internal
+  //
+
+  // Impl [get VisibleArea/SoundingZone]
+  const std::set<const RBAAllocatable*>& getOutputtingAllocatables() const;
+
+  // Impl [get Active View/Sound ContentStates]
+  const std::set<const RBAContentState*>& getActiveContentStates() const;
+
+  // Impl [get ContentStates]
+  const RBAContentState* getContentState(const RBAAllocatable* const allocatable) const;
+  const RBAContentState* getDirectContentState(const RBAAllocatable* const allocatable) const;
+  const RBAContentState* getPreContentState(const RBAAllocatable* const allocatable) const;
+  const RBAContentState* getDirectPreContentState(const RBAAllocatable* const allocatable) const;
+
+  // Impl [get Areas/Zones by ConentState]
+  std::list<const RBAAllocatable*> getAllocatable(const RBAContentState* const state) const;
+
+  // Impl [check Aleady Outputting]
+  bool isAlreadyOutputting(const RBAContentState* const state) const;
+
+  // Impl [set Active Scene]
+  void setActive(const RBAScene* const scene, const bool newActive);
+
+  // Impl [check Active ContentState]
+  bool isActive(const RBAContentState* const state) const;
+  bool isActive(const RBAViewContentState* const state) const;
+  bool isActive(const RBASoundContentState* const state) const;
+  bool isPreActive(const RBAContentState* const state) const;
+  bool isPreActive(const RBAViewContentState* const state) const;
+  bool isPreActive(const RBASoundContentState* const state) const;
+  const RBAContentState* getActiveState(const RBAContent* const content) const;
+  const RBAContentState* getPreActiveState(const RBAContent* const content) const;
+
+  // Impl [set Active ContentState]
+  void setActive(const RBAContentState* const state, const bool newActive);
+
+  // Impl [add Standby Content]
+  void addStandbyContent(const RBAContent* const content);
+
+  // Impl [check Visible/Sounding Alloc ContentState]
+  bool isOutputting(const RBAAllocatable* const alloc) const;
+  bool isPreOutputting(const RBAAllocatable* const alloc) const;
+  bool isOutputting(const RBAContentState* const state) const;
+  bool isPreOutputting(const RBAContentState* const state) const;
+
+  // Impl [get View/Sound ContentState by Allocatable]
+  const RBAContentState* getAllocatedContentState(const RBAAllocatable* const allocatable) const;
+  const RBAContentState* getPreAllocatedContentState(const RBAAllocatable* const allocatable) const;
+
+  // Impl [set View/Sound ContentState]
+  void setContentState(const RBAAllocatable* const allocatable, const RBAContentState* const state);
+
+  // Impl [check Hidden/Mute Area/Zone]
+  bool isHidden(const RBAAllocatable* const allocatable) const;
+  bool isPreHidden(const RBAAllocatable* const allocatable) const;
+
+  // Impl [set Cancel ContentState]
+  void setCancel(const RBAContentState* const state, const bool checked);
+
+  // Impl [check Cancel ContentState]
+  bool isCancel(const RBAContentState* const state) const;
+  bool isPreCancel(const RBAContentState* const state) const;
+
+  // Impl [add Visible/Sounding ContentState]
+  void addOutputtingContentState(const RBAContentState* const state);
+
+  // Impl [cancel ContentState]
+  void cancelContentState(const RBAContentState* const state);
+  
+  // Impl [common]
+  std::unique_ptr<RBAResultSet> createBackupCurrentResultSet();
+  std::unique_ptr<RBAResultSet> createNextCurrentResultSet();
+  void addViewAction(std::unique_ptr<RBAViewAction>& newViewAction);
+  void setStatusType(const RBAResultStatusType newStatusType);
+  void updateActiveContentStates();
+  void setSceneProperty(const RBASceneImpl* const scene,
+                        const std::string& propertyName,
+                        const std::int32_t value);
+  void setSceneProperty(const RBAAbstractProperty* const property,
+                        const std::int32_t value);
+  std::int32_t getSceneProperty(const RBAAbstractProperty* const property) const;
+  std::int32_t getPreSceneProperty(const RBAAbstractProperty* const property) const;
+  void setContentOfEventProcessing(const RBAEventProcessing* const eventProcessing,
+				                           const RBAContent* const viewContent);
+  std::unique_ptr<RBAResultSet>& getCurResultSet();
+  std::unique_ptr<RBAResultSet>& getPreResultSet();
+  RBAContentStatusType getStatusType(const RBAContent* const content) const;
+  bool isStandby(const RBAContent* const content) const;
+  bool hasBeenCanceled(const RBAContent* const content) const;
+  bool hasBeenPreCanceled(const RBAContent* const content) const;
+  bool hasBeenDisplayed(const RBAContent* const content) const;
+  bool hasBeenPreDisplayed(const RBAContent* const content) const;
+
+  /// @brief Update status of Content
+  /// @details Update the status based on the request status, 
+  ///          output status, and status at the time of request of the content
+  /// @param[in] content Content to be updated
+  void updateStatus(const RBAContent* const content);
+
+  std::unordered_map<const RBAContent*, RBAContentStatus>* getCurStatus() const;
+  std::set<const RBASceneImpl*>& getDifferentConditionScenes() const;
+#ifdef RBA_USE_LOG
+  void addFailedConstraint(const RBAConstraint* constraint);
+  const std::list<const RBAConstraint*>& getFailedConstraints() const;
+#endif
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::unique_ptr<RBAResultSet> curResultSet_;
+  std::unique_ptr<RBAResultSet> preResultSet_;
+  mutable std::list<std::unique_ptr<RBAViewAction>> viewActions_;
+  mutable std::list<const RBAViewAction*> viewActionsForPublicUse_;
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  const RBAArbitrator* arb_;
+  RBAResultStatusType statusType_;
+  std::string log_;
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAResultSet.cpp b/src/core/logic/RBAResultSet.cpp
new file mode 100644
index 0000000..bcc9892
--- /dev/null
+++ b/src/core/logic/RBAResultSet.cpp
@@ -0,0 +1,996 @@
+/**
+ * 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.
+ */
+
+/**
+ * ResultSet (set arbitration result) class
+ */
+
+#include <algorithm>
+#include <unordered_map>
+#include "RBAResultSet.hpp"
+
+#include "RBAContentStatusType.hpp"
+#include "RBAAreaImpl.hpp"
+#include "RBAViewContentImpl.hpp"
+#include "RBAViewContentState.hpp"
+#include "RBASizeImpl.hpp"
+#include "RBAZone.hpp"
+#include "RBAZoneImpl.hpp"
+#include "RBASoundContent.hpp"
+#include "RBASoundContentState.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBAContentState.hpp"
+#include "RBAContent.hpp"
+#include "RBAAbstractAllocatable.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAConstraint.hpp"
+#include "RBADisplay.hpp"
+#include "RBAAbstractProperty.hpp"
+
+namespace rba {
+
+RBAResultSet::RBAResultSet(const RBAResultSet& resultSet)
+  : outputtingAllocs_{resultSet.outputtingAllocs_}
+  , hiddenAllocs_{resultSet.hiddenAllocs_}
+  , activeContentStates_{resultSet.activeContentStates_}
+  , canceledContentStates_{resultSet.canceledContentStates_}
+  , allocToContentState_{resultSet.allocToContentState_}
+  , visibleAreas_{resultSet.visibleAreas_}
+  , soundingZones_{resultSet.soundingZones_}
+  , invisibleAreas_{resultSet.invisibleAreas_}
+  , unsoundingZones_{resultSet.unsoundingZones_}
+  , hiddenAreas_{resultSet.hiddenAreas_}
+  , muteZones_{resultSet.muteZones_}
+  , attenuatedZones_{resultSet.attenuatedZones_}
+  , canceledViewContents_{resultSet.canceledViewContents_}
+  , canceledSoundContents_{resultSet.canceledSoundContents_}
+  , standbyViewContents_{resultSet.standbyViewContents_}
+  , standbySoundContents_{resultSet.standbySoundContents_}
+  , visibleContentStates_{resultSet.visibleContentStates_}
+  , soundingContentStates_{resultSet.soundingContentStates_}
+  , activeViewContentStates_{resultSet.activeViewContentStates_}
+  , activeSoundContentStates_{resultSet.activeSoundContentStates_}
+  , requestOrderView_{resultSet.requestOrderView_}
+  , requestOrderSound_{resultSet.requestOrderSound_}
+  , activeScenes_{resultSet.activeScenes_}
+  , propertyMap_{resultSet.propertyMap_}
+  , event_content_{resultSet.event_content_}
+  , contentToStatus_{resultSet.contentToStatus_}
+  , requestContentStateMap_{resultSet.requestContentStateMap_}
+#ifdef RBA_USE_LOG
+  , failedConstraints_{resultSet.failedConstraints_}
+#endif
+{
+}
+
+// Impl [get VisibleArea/SoundingZone]
+
+const std::set<const RBAAllocatable*>&
+RBAResultSet::getOutputtingAllocatables() const
+{
+  return outputtingAllocs_;
+}
+
+const std::list<const RBAArea*>&
+RBAResultSet::getVisibleAreas() const
+{
+  return visibleAreas_;
+}
+  
+const std::list<const RBAZone*>&
+RBAResultSet::getSoundingZones() const
+{
+  return soundingZones_;
+}
+
+// Impl [get Visible/Sounding ContentStates]
+
+const std::list<const RBAViewContentState*>&
+RBAResultSet::getVisibleContentStates() const
+{
+  return visibleContentStates_;
+}
+
+const std::list<const RBASoundContentState*>&
+RBAResultSet::getSoundingContentStates() const
+{
+  return soundingContentStates_;
+}
+
+// Impl [get Active View/Sound ContentStates]
+
+const std::set<const RBAContentState*>&
+RBAResultSet::getActiveContentStates() const
+{
+  return activeContentStates_;
+}
+
+const std::list<const RBAViewContentState*>&
+RBAResultSet::getActiveViewContentStates() const
+{
+  return activeViewContentStates_;
+}
+
+const std::list<const RBASoundContentState*>&
+RBAResultSet::getActiveSoundContentStates() const
+{
+  return activeSoundContentStates_;
+}
+
+// Impl [get Active Scenes]
+
+const std::list<const RBAScene*>&
+RBAResultSet::getActiveScenes() const
+{
+  return activeScenes_;
+}
+
+// Impl [get InvisibleAreas/UnsoundingZone]
+
+const std::list<const RBAArea*>&
+RBAResultSet::getInvisibleAreas() const
+{
+  return invisibleAreas_;
+}
+
+const std::list<const RBAZone*>&
+RBAResultSet::getUnsoundingZones() const
+{
+  return unsoundingZones_;
+}
+
+// Impl [get HiddenAreas/MuteZones]
+
+const std::list<const RBAArea*>&
+RBAResultSet::getHiddenAreas() const
+{
+  return hiddenAreas_;
+}
+
+const std::list<const RBAZone*>&
+RBAResultSet::getMuteZones() const
+{
+  return muteZones_;
+}
+
+// Impl [get Attenuated]
+const std::list<const RBAZone*>&
+RBAResultSet::getAttenuatedZones() const
+{
+  return attenuatedZones_;
+}
+
+// Impl [get Canceled Contents]
+
+const std::list<const RBAViewContent*>&
+RBAResultSet::getCanceledViewContents() const
+{
+  return canceledViewContents_;
+}
+
+const std::list<const RBASoundContent*>&
+RBAResultSet::getCanceledSoundContents() const
+{
+  return canceledSoundContents_;
+}
+
+// Impl [get Standby Contents]
+
+const std::list<const RBAViewContent*>&
+RBAResultSet::getStandbyViewContents() const
+{
+  return standbyViewContents_;
+}
+
+const std::list<const RBASoundContent*>&
+RBAResultSet::getStandbySoundContents() const
+{
+  return standbySoundContents_;
+}
+
+// Impl [get ContentStates]
+
+const RBAContentState*
+RBAResultSet::getContentState(const RBAAllocatable* const alloc) const
+{
+  if(alloc != nullptr) {
+    auto it = allocToContentState_.find(alloc);
+    if(it != allocToContentState_.end()) {
+      auto state = it->second;
+      // If the content(state) assigned to the "alloc" has the 
+      // allocatable function (such as cyclic), the contentState assigned to it 
+      // is the contentState assigned to the "alloc".
+      // Search this until it is not allocatable content. 
+      while ((state != nullptr) 
+              && (dynamic_cast<RBAAllocatable*>(state->getOwner()) != nullptr)) {
+        it = allocToContentState_.find(dynamic_cast<RBAAllocatable*>(state->getOwner()));
+        state = it->second;
+      }
+      return state;
+    }
+  }
+  return nullptr;
+}
+
+const RBAContentState*
+RBAResultSet::getDirectContentState(const RBAAllocatable* const alloc) const
+{
+  if(alloc != nullptr) {
+    auto it = allocToContentState_.find(alloc);
+    if(it != allocToContentState_.end()) {
+      return it->second;
+    }
+  }
+  return nullptr;
+}
+
+// Impl [get Areas/Zones by ConentState]
+
+void
+RBAResultSet::getAlloc(const RBAContentState* const state,
+	                     std::list<const RBAAllocatable*>& allocList) const
+{
+  if(state != nullptr) {
+    for(const auto& it : allocToContentState_) {
+      if(it.second == state) {
+	      allocList.push_back(it.first);
+      }
+    }
+  }
+}
+
+void
+RBAResultSet::getArea(const RBAViewContentState* const state,
+		                  std::list<const RBAArea*>& areaList) const
+{
+  if(state != nullptr) {
+    for(const auto& it : allocToContentState_) {
+      if(dynamic_cast<const RBAViewContentState*>(it.second) == state) {
+        const RBAContent* const content {dynamic_cast<const RBAContent*>(it.first)};
+        if (content != nullptr) { // In case of CyclicContent
+          // Get ViewContentState assigned to CyclicContent
+          const RBAViewContentState* const ownerState
+            {dynamic_cast<const RBAViewContentState*>(getReqestState(content))};
+          // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+          //  [Contents that deviate from the rules]
+          //   calling getArea() recursively
+          // 　[Reason that there is no problem if the rule is deviated]
+          //   When getArea() is performed on CyclicContent, at that time, 
+          //   respond Area where ViewContent assigned to CyclicContent 
+          //   is assigned. When CyclicContent is assigned to CyclicContent, 
+          //   multiple recursive calls may be made, but the rule model 
+          //   definition is finite. 
+          //   Therefore, stack overflow will not be occured, no problem.
+          getArea(ownerState, areaList);
+        } else {
+  	      areaList.push_back(dynamic_cast<const RBAArea*>(it.first));
+        }
+      }
+    }
+  }
+}
+
+void
+RBAResultSet::getZone(const RBASoundContentState* const state,
+		                  std::list<const RBAZone*>& zoneList) const
+{
+  if(state != nullptr) {
+    for(const auto& it : allocToContentState_) {
+      if (dynamic_cast<const RBASoundContentState*>(it.second) == state) {
+        const RBAContent* const content {dynamic_cast<const RBAContent*>(it.first)};
+        if (content != nullptr) {
+          const RBASoundContentState* const ownerState
+            {dynamic_cast<const RBASoundContentState*>(getReqestState(content))};
+          // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+          //  [Contents that deviate from the rules]
+          //   Function '::rba::RBAResultSet::getZone=(_,
+          //                  p={c::rba::RBASoundContentState},
+          //                  &{c::std::__cxx11::list<p={c::rba::RBAZone},
+          //                  {c::std::allocator<p={c::rba::RBAZone}>}>})' 
+          //   is recursive. 
+          // 　[Reason that there is no problem if the rule is deviated]
+          //   Recursive call is required as a feature
+          getZone(ownerState, zoneList);
+        } else {
+	        zoneList.push_back(dynamic_cast<const RBAZone*>(it.first));
+        }
+      }
+    }
+  }
+}
+
+// Impl [get Areas/Zones by Content]
+
+void
+RBAResultSet::getArea(const RBAViewContent* const content,
+		                  std::list<const RBAArea*>& areaList) const
+{
+  if(content != nullptr) {
+    for(auto& state : content->getContentStates()) {
+      getArea(state, areaList);
+      if(!areaList.empty()) {
+	      break;
+      }
+    }
+  }
+}
+
+void
+RBAResultSet::getZone(const RBASoundContent* const content,
+		                  std::list<const RBAZone*>& zoneList) const
+{
+  if(content != nullptr) {
+    for(auto& state : content->getContentStates()) {
+      getZone(state, zoneList);
+      if(!zoneList.empty()) {
+	      break;
+      }
+    }
+  }
+}
+
+// Impl [get Size]
+
+const RBASize*
+RBAResultSet::getSize(const RBAArea* const area) const
+{
+  if(area == nullptr) {
+    return nullptr;
+  }
+  const RBAAreaImpl* const areaImpl {dynamic_cast<const RBAAreaImpl*>(area)};
+  auto it = allocToContentState_.find(areaImpl);
+  if(it == allocToContentState_.end() || (it->second == nullptr)) {
+    return nullptr;
+  }
+  const RBAContent* const content {dynamic_cast<RBAContent*>(it->second->getOwner())};
+  const RBASize* backupAreaSize {nullptr};
+  std::int32_t backupDiffVal {-1};
+  for(auto& areaSize : areaImpl->getSizes()) {
+    const RBASizeImpl* const areaSizeImpl {dynamic_cast<const RBASizeImpl*>(areaSize)};
+    for(auto& contentSize : content->getSizes()) {
+      const RBASizeImpl* const contentSizeImpl {dynamic_cast<const RBASizeImpl*>(contentSize)};
+      const auto diffVal = areaSizeImpl->diff(contentSizeImpl);
+      if(diffVal == 0) {
+	      return areaSizeImpl;
+      }
+      else if((backupDiffVal < 0) || (backupDiffVal > diffVal)) {
+	      backupAreaSize = areaSizeImpl;
+	      backupDiffVal = diffVal;
+      } else {
+        ;
+      }
+    }
+  }
+
+  return backupAreaSize;
+}
+
+// Impl [check Active Scene]
+
+bool
+RBAResultSet::isActive(const RBAScene* const scene) const
+{
+  return (std::find(activeScenes_.begin(), activeScenes_.end(), scene)
+          != activeScenes_.end());
+}
+
+// Impl [check Active ContentState]
+bool
+RBAResultSet::isActive(const RBAContent* const content) const
+{
+  if (contentToStatus_.find(content) != contentToStatus_.end()) {
+    return contentToStatus_[content].isActive();
+  }
+  return false;
+}
+
+bool
+RBAResultSet::isActive(const RBAContentState* const state) const
+{
+  const RBAContent* const content {dynamic_cast<RBAContent*>(state->getOwner())};
+  return (isActive(content) && (getReqestState(content) == state));
+}
+
+const RBAContentState*
+RBAResultSet::getReqestState(const RBAContent* const content) const
+{
+  if (requestContentStateMap_.find(content) != requestContentStateMap_.end()) {
+    return requestContentStateMap_[content];
+  }
+  return nullptr;
+}
+
+// Impl [check Outputting Allocatable]
+
+bool
+RBAResultSet::isOutputting(const RBAAllocatable* const alloc) const
+{
+  return outputtingAllocs_.find(alloc) != outputtingAllocs_.end();
+}
+
+// Impl [check Outputting ContentState]
+
+bool
+RBAResultSet::isOutputting(const RBAContentState* const state) const
+{
+  std::list<const RBAAllocatable*> allocList;
+  getAlloc(state, allocList);
+  for(auto& alloc : allocList) {
+    if(isOutputting(alloc)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Impl [check Hidden/Mute Area/Zone]
+
+bool
+RBAResultSet::isHidden(const RBAAllocatable* const alloc) const
+{
+  return hiddenAllocs_.find(alloc) != hiddenAllocs_.end();
+}
+
+// Impl [check Attenuated Zone]
+
+bool
+RBAResultSet::isAttenuated(const RBAZone* const zone) const
+{
+  return std::find(attenuatedZones_.begin(), attenuatedZones_.end(), zone) != attenuatedZones_.end();
+}
+
+// Impl [check Cancel ContentState]
+
+bool
+RBAResultSet::isCancel(const RBAContentState* const state) const
+{
+  return canceledContentStates_.find(state) != canceledContentStates_.end();
+}
+
+// Impl [check Aleady OutPutting]
+
+bool
+RBAResultSet::isAlreadyOutputting(const RBAContentState* const state) const
+{
+  const auto content = dynamic_cast<const RBAContent*>(state->getOwner());
+  for(auto& alloc : content->getAllocatables()) {
+    if((getContentState(alloc) == state) && !alloc->isHidden()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Impl [set Active Scene]
+
+/**
+ * @brief Set display request or display withdrawal request, for Scene 
+ * @param scene Scene
+ * @param newActive true: display request, false: display withdrawal request
+ */
+void
+RBAResultSet::setActive(const RBAScene* const scene, const bool newActive)
+{
+  const auto it = std::find(activeScenes_.begin(), activeScenes_.end(), scene);
+  if(it == activeScenes_.end()) {
+    if(newActive) {
+      activeScenes_.push_back(scene);
+    }
+  }
+  else {
+    if(!newActive) {
+      static_cast<void>(activeScenes_.erase(it));
+    }
+  }
+}
+
+// Impl [set Active ContentState]
+
+/**
+ * @brief Set display request or display withdrawal request, for Content state
+ * @details If the content has already been registered, 
+            delete the registered content.
+ * @param contentState Content state
+ * @param newActive true: display request, false: display withdrawal request
+ */
+void
+RBAResultSet::setActive(const RBAContentState* const state, const bool newActive)
+{
+  updateRequestStatus(dynamic_cast<RBAContent*>(state->getOwner()), newActive);
+
+  // Check if Content is already active
+  const RBAContentState* temp {nullptr};
+  for(auto& cs : activeContentStates_) {
+    if(cs->getOwner() == state->getOwner()) {
+      temp = cs;
+      break;
+    }
+  }
+  // Delete if Content is active
+  if (temp != nullptr) {
+    setOrder(temp, 0);
+    static_cast<void>(activeContentStates_.erase(temp));
+    if (temp->isViewContentState()) {
+      activeViewContentStates_.remove(dynamic_cast<const RBAViewContentState*>(temp));
+    } else {
+      activeSoundContentStates_.remove(dynamic_cast<const RBASoundContentState*>(temp));
+    }
+  }
+
+  // Rgistre active
+  if(newActive) {
+    requestContentStateMap_[dynamic_cast<const RBAContent*>(state->getOwner())] = state;
+    static_cast<void>(activeContentStates_.insert(state));
+    if (state->isViewContentState()) {
+      setOrder(state, requestOrderView_);
+      requestOrderView_++;
+      activeViewContentStates_.push_back(dynamic_cast<const RBAViewContentState*>(state));
+    } else {
+      setOrder(state, requestOrderSound_);
+      requestOrderSound_++;
+      activeSoundContentStates_.push_back(dynamic_cast<const RBASoundContentState*>(state));
+    }
+  }
+  else {
+    setOrder(state, 0);
+    static_cast<void>(requestContentStateMap_.erase(dynamic_cast<const RBAContent*>(state->getOwner())));
+  }
+}
+
+// [cancel ContentState]
+
+void
+RBAResultSet::cancelContentState(const RBAContentState* const state)
+{
+  setOrder(state, 0);
+  if (state->isViewContentState()) {
+    canceledViewContents_.push_back(dynamic_cast<const RBAViewContent*>(state->getOwner()));
+  } else {
+    canceledSoundContents_.push_back(dynamic_cast<const RBASoundContent*>(state->getOwner()));
+  }
+}
+
+// Impl [set Cancel ContentState]
+
+void
+RBAResultSet::setCancel(const RBAContentState* const state, const bool checked)
+{
+  if(checked) {
+    static_cast<void>(canceledContentStates_.insert(state));
+  }
+  else {
+    static_cast<void>(canceledContentStates_.erase(state));
+  }
+}
+
+// Impl [set ContentState]
+
+void
+RBAResultSet::setContentState(const RBAAllocatable* const alloc, const RBAContentState* const state)
+{
+  //alloc
+  allocToContentState_[alloc] = state;
+  const bool isHiddenRes {alloc->isHidden()};
+  const bool existsState {(state != nullptr)};
+  const RBAAreaImpl* area {dynamic_cast<const RBAAreaImpl*>(alloc)};
+  const RBAZoneImpl* zone {dynamic_cast<const RBAZoneImpl*>(alloc)};
+
+  if (isHiddenRes) {
+	static_cast<void>(hiddenAllocs_.insert(alloc));
+  } else {
+    // Currently, there is no case to delete the Allocable stored in 
+    // hiddenAllocs_. In the future, since hiding may be forcibly released,
+    // implement it.
+	static_cast<void>(hiddenAllocs_.erase(alloc));
+  }
+
+  if (!isHiddenRes && existsState) {
+    if (alloc->isArea() || alloc->isZone()) {
+      static_cast<void>(outputtingAllocs_.insert(alloc));
+    }
+    if (isOutputting(alloc)) {
+      const RBAContentState* s {state};
+      while ((s != nullptr) && (dynamic_cast<RBAAllocatable*>(s->getOwner()) != nullptr)) {
+        RBAAllocatable* extAlloc {dynamic_cast<RBAAllocatable*>(s->getOwner())};
+        static_cast<void>(outputtingAllocs_.insert(extAlloc));
+        s = extAlloc->getState();
+      }
+    }
+
+    if (alloc->isArea()) {
+      if (std::find(visibleAreas_.begin(), visibleAreas_.end(), area) == visibleAreas_.end()) {
+        visibleAreas_.push_back(area);
+      }
+      invisibleAreas_.remove(area);
+    } else if (alloc->isZone()) {
+      if (std::find(soundingZones_.begin(), soundingZones_.end(), zone) == soundingZones_.end()) {
+        soundingZones_.push_back(zone);
+      }
+      unsoundingZones_.remove(zone);
+    } else {
+      ;
+    }
+  } else {
+	static_cast<void>(outputtingAllocs_.erase(alloc));
+    if (alloc->isArea()) {
+      // Currently, there is no case to delete the Area stored in visibleAreas_.
+      // In the future, it may happen that content allocation is 
+      // forcibly released, so implement thes.
+      visibleAreas_.remove(area);
+      if (std::find(invisibleAreas_.begin(), invisibleAreas_.end(), area) == invisibleAreas_.end()) {
+        invisibleAreas_.push_back(area);
+      }
+    } else if (alloc->isZone()) {
+      // Currently, there is no case to delete the Area stored in soundingZones_.
+      // In the future, it may happen that content allocation is 
+      // forcibly released, so implement thes.
+      soundingZones_.remove(zone);
+      if (std::find(unsoundingZones_.begin(), unsoundingZones_.end(), zone) == unsoundingZones_.end()) {
+        unsoundingZones_.push_back(zone);
+      }
+    } else {
+      ;
+    }
+  }
+
+  if (isHiddenRes && existsState) {
+    if (alloc->isArea()) {
+      if (std::find(hiddenAreas_.begin(), hiddenAreas_.end(), area) == hiddenAreas_.end()) {
+        hiddenAreas_.push_back(area);
+      }
+    } else if (alloc->isZone()) {
+      if (std::find(muteZones_.begin(), muteZones_.end(), zone) == muteZones_.end()) {
+        muteZones_.push_back(zone);
+      }
+    } else {
+      ;
+    }
+  } else {
+    if (alloc->isArea()) {
+      hiddenAreas_.remove(area);
+    } else if (alloc->isZone()) {
+      muteZones_.remove(zone);
+    } else {
+      ;
+    }
+  }
+
+  if (alloc->isZone()) {
+    if (existsState && !isHiddenRes && zone->isAttenuated()) {
+      if (std::find(attenuatedZones_.begin(), attenuatedZones_.end(), zone) == attenuatedZones_.end()) {
+        attenuatedZones_.push_back(zone);
+      }
+    } else {
+      // Currently, there is no case to delete the Allocatable stored in 
+      // attenuatedZones_. In the future, there may be cases in which 
+      // "attenuation" is forcibly canceled, so implement this.
+      attenuatedZones_.remove(zone);
+    }
+  }
+}
+
+// Impl [add Visible/Sounding ContentState]
+
+void
+RBAResultSet::addOutputtingContentState(const RBAContentState* const state)
+{
+  if (state->isViewContentState()) {
+    visibleContentStates_.push_back(dynamic_cast<const RBAViewContentState*>(state));
+  }
+  else if (state->isSoundContentState()) {
+    soundingContentStates_.push_back(dynamic_cast<const RBASoundContentState*>(state));
+  }
+  else {
+    ;
+  }
+}
+
+// Impl [add Standby Content]
+
+void
+RBAResultSet::addStandbyContent(const RBAContent* const content)
+{
+  if (content->isViewContent()) {
+    standbyViewContents_.push_back(dynamic_cast<const RBAViewContent*>(content));
+  }
+  else if (content->isSoundContent()) {
+    standbySoundContents_.push_back(dynamic_cast<const RBASoundContent*>(content));
+  }
+  else {
+    ;
+  }
+}
+
+// [activeView]
+
+void
+RBAResultSet::copyActives(const std::unique_ptr<RBAResultSet>& resultSet)
+{
+  activeContentStates_ = resultSet->activeContentStates_;
+  activeViewContentStates_ = resultSet->activeViewContentStates_;
+  activeSoundContentStates_ = resultSet->activeSoundContentStates_;
+  activeScenes_ = resultSet->activeScenes_;
+  contentToStatus_ = resultSet->contentToStatus_;
+  requestContentStateMap_ = resultSet->requestContentStateMap_;
+
+  // Reset order
+  requestOrderView_ = 1;
+  requestOrderSound_ = 1;
+  for(const RBAViewContentState* const viewState : activeViewContentStates_) {
+    setOrder(dynamic_cast<const RBAContentState*>(viewState), requestOrderView_);
+    requestOrderView_++;
+  }
+  for(const RBASoundContentState* const soundState : activeSoundContentStates_) {
+    setOrder(dynamic_cast<const RBAContentState*>(soundState), requestOrderSound_);
+    requestOrderSound_++;
+  }
+}
+
+void
+RBAResultSet::updateActiveContentStates()
+{
+  for (auto& state : canceledContentStates_) {
+	static_cast<void>(activeContentStates_.erase(state));
+    if (state->isViewContentState()) {
+      activeViewContentStates_.remove(dynamic_cast<const RBAViewContentState*>(state));
+    } else {
+      activeSoundContentStates_.remove(dynamic_cast<const RBASoundContentState*>(state));
+    }
+  }
+}
+
+void
+RBAResultSet::copyProperties(const std::unique_ptr<RBAResultSet>& resultSet)
+{
+  propertyMap_ = resultSet->propertyMap_;
+}
+
+void
+RBAResultSet::setSceneProperty(const RBAScene* const scene,
+                               const std::string& propertyName,
+                               const std::int32_t value)
+{
+  propertyMap_[dynamic_cast<const RBASceneImpl*>(scene)->getProperty(propertyName)] = value;
+}
+
+void
+RBAResultSet::setSceneProperty(const RBAAbstractProperty* const property,
+			                         const std::int32_t value)
+{
+  propertyMap_[property] = value;
+}
+
+std::int32_t
+RBAResultSet::getSceneProperty(const RBAAbstractProperty* const property) const
+{
+  auto it = propertyMap_.find(property);
+  if(it == propertyMap_.end()) {
+    // Property not registered
+    return -99;
+  }
+
+  return it->second;
+}
+
+void
+RBAResultSet::setContentOfEventProcessing(const RBAEventProcessing* const eventProcessing,
+					                                const RBAContent* const content)
+{
+  event_content_[eventProcessing] = content;
+}
+
+const RBAContent*
+RBAResultSet::getContentOfEventProcessing(const RBAEventProcessing* const eventProcessing) const
+{
+  if (event_content_.find(eventProcessing) != event_content_.end()) {
+    return event_content_.at(eventProcessing);
+  }
+  return nullptr;
+}
+
+bool
+RBAResultSet::hasDisplayingArea(const RBADisplay* const display) const
+{
+  bool displayed {false};
+  const std::list<const RBAArea*> areas {display->getAreas()};
+  const auto areasBegin = areas.begin();
+  const auto areasEnd = areas.end();
+  for(const RBAArea* const area : visibleAreas_) {
+    if (std::find(areasBegin, areasEnd, area) != areasEnd) {
+      displayed = true;
+      break;
+    }
+  }
+  return displayed;
+}
+
+bool
+RBAResultSet::isLater(const RBAContent* const target,
+                      const RBAContent* const comparisonTarget) const
+{
+  bool isLaterRes {false};
+  bool isBreak {false};
+
+  if (target->isViewContent()) {
+    const RBAViewContent* const targetContent {
+        dynamic_cast<const RBAViewContent*>(target)};
+    const RBAViewContent* const comparisonTargetContent {
+        dynamic_cast<const RBAViewContent*>(comparisonTarget)};
+    for (auto it = activeViewContentStates_.rbegin();
+        (it != activeViewContentStates_.rend()) && (!isBreak) ; it++) {
+      if ((*it)->getOwner() == targetContent) {
+        isLaterRes = true;
+        isBreak = true;
+      } else if ((*it)->getOwner() == comparisonTargetContent) {
+        isBreak = true;
+      } else {
+        ;
+      }
+    }
+  } else {
+    const RBASoundContent* const targetContent {
+        dynamic_cast<const RBASoundContent*>(target)};
+    const RBASoundContent* const comparisonTargetContent {
+        dynamic_cast<const RBASoundContent*>(comparisonTarget)};
+    for (auto it = activeSoundContentStates_.rbegin();
+        (it != activeSoundContentStates_.rend()) && (!isBreak); it++) {
+      if ((*it)->getOwner() == targetContent) {
+        isLaterRes = true;
+        isBreak = true;
+      } else if ((*it)->getOwner() == comparisonTargetContent) {
+        isBreak = true;
+      } else {
+        ;
+      }
+    }
+  }
+  return isLaterRes;
+}
+
+std::set<const RBASceneImpl*>&
+RBAResultSet::getDifferentConditionScenes(const RBAResultSet& target)
+{
+  // Detect the difference from the target scene On state
+  const std::list<const RBAScene*> targetScenes {target.getActiveScenes()};
+  for (auto& s : activeScenes_) {
+    if (std::find(targetScenes.begin(), targetScenes.end(), s)
+        == targetScenes.end()) {
+      static_cast<void>(differentConditionScenes_.insert(dynamic_cast<const RBASceneImpl*>(s)));
+    }
+  }
+  for (auto& s : targetScenes) {
+    if (std::find(activeScenes_.begin(), activeScenes_.end(), s)
+        == activeScenes_.end()) {
+      static_cast<void>(differentConditionScenes_.insert(dynamic_cast<const RBASceneImpl*>(s)));
+    }
+  }
+
+  // Detect the difference from the target scene property state
+  for (auto& p : propertyMap_) {
+    if (target.getSceneProperty(p.first) != p.second) {
+      static_cast<void>(differentConditionScenes_.insert(p.first->getScene()));
+    }
+  }
+  for (auto& p : target.getScenePropertyMap()) {
+    if (getSceneProperty(p.first) != p.second) {
+      static_cast<void>(differentConditionScenes_.insert(p.first->getScene()));
+    }
+  }
+  return differentConditionScenes_;
+}
+
+void
+RBAResultSet::updateRequestStatus(const RBAContent* const content, const bool isOnRequest)
+{
+  if (isOnRequest) {
+    contentToStatus_[content].onRequest();
+  } else {
+    // When a content "off request" comes in, turn off the content request 
+    // even if the requested state is different from Active state at that time.
+    static_cast<void>(contentToStatus_.erase(content));
+  }
+}
+
+void
+RBAResultSet::setStatusType(const RBAContent* const content, const RBAContentStatusType type)
+{
+  contentToStatus_[content].setStatusType(type);
+}
+
+RBAContentStatusType
+RBAResultSet::getStatusType(const RBAContent* const content) const
+{
+  if (contentToStatus_.find(content) != contentToStatus_.end()) {
+    return contentToStatus_[content].getStatusType();
+  }else {
+    return RBAContentStatusType::NoRequest;
+  }
+}
+
+bool
+RBAResultSet::isOutput(const RBAContent* const content) const
+{
+  if (contentToStatus_.find(content) != contentToStatus_.end()) {
+    return contentToStatus_[content].isDisplayed();
+  } else {
+    return false;
+  }
+}
+
+bool
+RBAResultSet::isStandby(const RBAContent* const content) const
+{
+  if (contentToStatus_.find(content)
+      != contentToStatus_.end()) {
+    return contentToStatus_[content].isStandby();
+  } else {
+    return false;
+  }
+}
+
+bool
+RBAResultSet::hasBeenCanceled(const RBAContent* const content) const
+{
+  if (contentToStatus_.find(content) != contentToStatus_.end()) {
+    return contentToStatus_[content].hasBeenCanceled();
+  } else {
+    return false;
+  }
+}
+
+bool
+RBAResultSet::hasBeenDisplayed(const RBAContent* const content) const
+{
+  if (contentToStatus_.find(content) != contentToStatus_.end()) {
+    return contentToStatus_[content].hasBeenDisplayed();
+  } else {
+    return false;
+  }
+}
+
+std::unordered_map<const RBAContent*, RBAContentStatus>*
+RBAResultSet::getStatus() const
+{
+  return &contentToStatus_;
+}
+
+#ifdef RBA_USE_LOG
+void
+RBAResultSet::addFailedConstraint(const RBAConstraint* constraint)
+{
+  failedConstraints_.push_back(constraint);
+}
+
+const std::list<const RBAConstraint*>&
+RBAResultSet::getFailedConstraints()
+{
+  return failedConstraints_;
+}
+#endif
+
+const std::unordered_map<const RBAAbstractProperty*, std::int32_t>&
+RBAResultSet::getScenePropertyMap() const
+{
+  return propertyMap_;
+}
+
+void
+RBAResultSet::setOrder(const RBAContentState* const state, const std::int32_t newOrder) const
+{
+  const_cast<RBAContentState*>(state)->setOrder(newOrder);
+}
+
+}
diff --git a/src/core/logic/RBAResultSet.hpp b/src/core/logic/RBAResultSet.hpp
new file mode 100644
index 0000000..3aca4e9
--- /dev/null
+++ b/src/core/logic/RBAResultSet.hpp
@@ -0,0 +1,246 @@
+/**
+ * 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.
+ */
+
+/**
+ * ResultSet (set arbitration result) class header
+ */
+
+#ifndef RBARESULTSET_HPP
+#define RBARESULTSET_HPP
+
+#include <cstdint>
+#include <list>
+#include <memory>
+#include <set>
+#include <unordered_map>
+#include <mutex>
+
+#include "RBAContentStatusType.hpp"
+#include "RBAContentStatus.hpp"
+
+namespace rba
+{
+
+class RBADisplay;
+class RBASize;
+class RBAAllocatable;
+class RBAArea;
+class RBAZone;
+class RBAContent;
+class RBAViewContent;
+class RBASoundContent;
+class RBAContentState;
+class RBAViewContentState;
+class RBASoundContentState;
+class RBAScene;
+class RBASceneImpl;
+class RBAAbstractProperty;
+class RBAEventProcessing;
+class RBAConstraint;
+
+class RBAResultSet
+{
+public:
+  RBAResultSet()=default;
+  RBAResultSet(const RBAResultSet& resultSet);
+  RBAResultSet(const RBAResultSet&&)=delete;
+  RBAResultSet& operator=(const RBAResultSet&)=delete;
+  RBAResultSet& operator=(const RBAResultSet&&)=delete;
+  virtual ~RBAResultSet()=default;
+
+public:
+  // Impl [get VisibleArea/SoundingZone]
+  const std::set<const RBAAllocatable*>& getOutputtingAllocatables() const;
+  const std::list<const RBAArea*>& getVisibleAreas() const;
+  const std::list<const RBAZone*>& getSoundingZones() const;
+  
+  // Impl [get Visible/Sounding ContentStates]
+  const std::list<const RBAViewContentState*>& getVisibleContentStates() const;
+  const std::list<const RBASoundContentState*>& getSoundingContentStates() const;
+
+  // Impl [get Active View/Sound ContentStates]
+  const std::set<const RBAContentState*>& getActiveContentStates() const;
+  const std::list<const RBAViewContentState*>& getActiveViewContentStates() const;
+  const std::list<const RBASoundContentState*>& getActiveSoundContentStates() const;
+ 
+  // Impl [get Active Scenes]
+  const std::list<const RBAScene*>& getActiveScenes() const;
+
+  // Impl [get InvisibleAreas/UnsoundingZone]
+  const std::list<const RBAArea*>& getInvisibleAreas() const;
+  const std::list<const RBAZone*>& getUnsoundingZones() const;
+
+  // Impl [get HiddenAreas/MuteZones]
+  const std::list<const RBAArea*>& getHiddenAreas() const;
+  const std::list<const RBAZone*>& getMuteZones() const;
+
+  // Impl [get Attenuated]
+  const std::list<const RBAZone*>& getAttenuatedZones() const;
+
+  // Impl [get Canceled Contents]
+  const std::list<const RBAViewContent*>& getCanceledViewContents() const;
+  const std::list<const RBASoundContent*>& getCanceledSoundContents() const;
+
+  // Impl [get Standby Contents]
+  const std::list<const RBAViewContent*>& getStandbyViewContents() const;
+  const std::list<const RBASoundContent*>& getStandbySoundContents() const;
+
+  // Impl [get ContentStates]
+  const RBAContentState* getContentState(const RBAAllocatable* const alloc) const;
+  const RBAContentState* getDirectContentState(const RBAAllocatable* const alloc) const;
+
+  // Impl [get Areas/Zones by ConentState]
+  void getAlloc(const RBAContentState* const state,
+	              std::list<const RBAAllocatable*>& allocList) const;
+  void getArea(const RBAViewContentState* const state,
+	             std::list<const RBAArea*>& areaList) const;
+  void getZone(const RBASoundContentState* const state,
+	             std::list<const RBAZone*>& zoneList) const;
+
+  // Impl [get Areas/Zones by Content]
+  void getArea(const RBAViewContent* const content,
+	             std::list<const RBAArea*>& areaList) const;
+  void getZone(const RBASoundContent* const content,
+	             std::list<const RBAZone*>& zoneList) const;
+
+  // Impl [get Size]
+  const RBASize* getSize(const RBAArea* const area) const;
+
+  // Impl [check Active Scene/Content/ContentState]
+  bool isActive(const RBAScene* const scene) const;
+  bool isActive(const RBAContent* const content) const;
+  bool isActive(const RBAContentState* const state) const;
+  const RBAContentState* getReqestState(const RBAContent* const content) const;
+ 
+  // Impl [check Outputting Allocatable/ContentState]
+  bool isOutputting(const RBAAllocatable* const alloc) const;
+  bool isOutputting(const RBAContentState* const state) const;
+
+  // Impl [check Hidden]
+  bool isHidden(const RBAAllocatable* const alloc) const;
+
+  // Impl [check Attenuated Zone]
+  bool isAttenuated(const RBAZone* const zone) const;
+
+  // Impl [check Cancel ContentState]
+  bool isCancel(const RBAContentState* const state) const;
+
+  // Impl [check Aleady OutPutting]
+  bool isAlreadyOutputting(const RBAContentState* const state) const;
+
+  // Impl [set Active Scene/ContentState]
+  void setActive(const RBAScene* const scene, const bool newActive);
+  void setActive(const RBAContentState* const state, const bool newActive);
+
+  // [cancel ContentState]
+  void cancelContentState(const RBAContentState* const state);
+
+  // Impl [set Cancel ContentState]
+  void setCancel(const RBAContentState* const state, const bool checked);
+
+  // Impl [set ContentState]
+  void setContentState(const RBAAllocatable* const alloc, const RBAContentState* const state);
+
+  // Impl [add Outputting ContentState]
+  void addOutputtingContentState(const RBAContentState* const state);
+
+  // Impl [add Standby Content]
+  void addStandbyContent(const RBAContent* const content);
+
+  // [activeView]
+  void copyActives(const std::unique_ptr<RBAResultSet>& resultSet);
+  void updateActiveContentStates();
+
+  // [Property]
+  void copyProperties(const std::unique_ptr<RBAResultSet>& resultSet);
+  void setSceneProperty(const RBAScene* const scene,
+                        const std::string& propertyName,
+			                  const std::int32_t value);
+  void setSceneProperty(const RBAAbstractProperty* const property,
+			                  const std::int32_t value);
+  std::int32_t getSceneProperty(const RBAAbstractProperty* const property) const;
+
+  // [EventProcessing]
+  void setContentOfEventProcessing(const RBAEventProcessing* const eventProcessing,
+                                   const RBAContent* const content);
+  const RBAContent* getContentOfEventProcessing(const RBAEventProcessing* const eventProcessing) const;
+
+  // [DisplayContents]
+  bool hasDisplayingArea(const RBADisplay* const display) const;
+
+  // common
+  bool isLater(const RBAContent* const target, const RBAContent* const comparisonTarget) const;
+  std::set<const RBASceneImpl*>& getDifferentConditionScenes(const RBAResultSet& target);
+  void updateRequestStatus(const RBAContent* const content, const bool isOnRequest);
+  void setStatusType(const RBAContent* const content, const RBAContentStatusType type);
+  RBAContentStatusType getStatusType(const RBAContent* const content) const;
+  bool isOutput(const RBAContent* const content) const;
+  bool isStandby(const RBAContent* const content) const;
+  bool hasBeenCanceled(const RBAContent* const content) const;
+  bool hasBeenDisplayed(const RBAContent* const content) const;
+  std::unordered_map<const RBAContent*, RBAContentStatus>* getStatus() const;
+#ifdef RBA_USE_LOG
+  void addFailedConstraint(const RBAConstraint* constraint);
+  const std::list<const RBAConstraint*>& getFailedConstraints();
+#endif
+
+private:
+  const std::unordered_map<const RBAAbstractProperty*, std::int32_t>& getScenePropertyMap() const;
+  void setOrder(const RBAContentState* const state, const std::int32_t newOrder) const;
+
+  std::set<const RBAAllocatable*> outputtingAllocs_;
+  std::set<const RBAAllocatable*> hiddenAllocs_;
+  std::set<const RBAContentState*> activeContentStates_;
+  std::set<const RBAContentState*> canceledContentStates_;
+  std::unordered_map<const RBAAllocatable*, const RBAContentState*> allocToContentState_;
+
+  // The lists for getList type acquisition function
+  std::list<const RBAArea*> visibleAreas_;
+  std::list<const RBAZone*> soundingZones_;
+  std::list<const RBAArea*> invisibleAreas_;
+  std::list<const RBAZone*> unsoundingZones_;
+  std::list<const RBAArea*> hiddenAreas_;
+  std::list<const RBAZone*> muteZones_;
+  std::list<const RBAZone*> attenuatedZones_;
+  std::list<const RBAViewContent*> canceledViewContents_;
+  std::list<const RBASoundContent*> canceledSoundContents_;
+  std::list<const RBAViewContent*> standbyViewContents_;
+  std::list<const RBASoundContent*> standbySoundContents_;
+  std::list<const RBAViewContentState*> visibleContentStates_;
+  std::list<const RBASoundContentState*> soundingContentStates_;
+  std::list<const RBAViewContentState*> activeViewContentStates_;
+  std::list<const RBASoundContentState*> activeSoundContentStates_;
+
+  // common
+  std::int32_t requestOrderView_ {1};
+  std::int32_t requestOrderSound_ {1};
+  std::list<const RBAScene*> activeScenes_;
+  std::unordered_map<const RBAAbstractProperty*, std::int32_t> propertyMap_;
+  std::unordered_map<const RBAEventProcessing*, const RBAContent*> event_content_;
+  mutable std::unordered_map<const RBAContent*, RBAContentStatus> contentToStatus_;
+  std::set<const RBASceneImpl*> differentConditionScenes_;
+
+  mutable std::unordered_map<const RBAContent*, const RBAContentState*> requestContentStateMap_;
+
+  mutable std::mutex mutex_;
+#ifdef RBA_USE_LOG
+  std::list<const RBAConstraint*> failedConstraints_;
+#endif
+
+};
+
+}
+#endif
diff --git a/src/core/logic/RBARollbacker.cpp b/src/core/logic/RBARollbacker.cpp
new file mode 100644
index 0000000..9870fa9
--- /dev/null
+++ b/src/core/logic/RBARollbacker.cpp
@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+/**
+ * Rollbacker (rollback of arbitration results) class implementation
+ */
+
+#include "RBARollbacker.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBABackUpAllocatable.hpp"
+#include "RBAArbitrator.hpp"
+
+namespace rba
+{
+
+RBARollbacker::~RBARollbacker() noexcept
+{
+  children_.clear();
+}
+
+void
+RBARollbacker::addChild(const std::shared_ptr<RBARollbacker> child)
+{
+  children_.push_back(child);
+}
+
+void
+RBARollbacker::removeChild(const std::shared_ptr<RBARollbacker> child)
+{
+  children_.remove(child);
+}
+
+void
+RBARollbacker::backup(std::list<const RBAAllocatable*>& backuplist)
+{
+  backupMap_.clear();
+  for(const RBAAllocatable* const original : backuplist) {
+    std::unique_ptr<RBAAllocatable> backupObj
+      {std::make_unique<RBABackUpAllocatable>("backup_"
+                                               + original->getElementName())};
+    copyAllocatable(original, backupObj.get());
+    backupMap_[original] = std::move(backupObj);
+  }
+}
+
+void
+RBARollbacker::rollback()
+{
+  for (auto& Child : children_) {
+    // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+    // [Contents that deviate from the rules]
+    //  rollback() is called recursively
+    // [Explanation that there is no problem if you deviate from the rules]
+    //  RBARollbacker is created each time the re-arbitration nest becomes 
+    //  deeper, but since the infinite loop prevention process is implemented 
+    //  in re-arbitration, stack overflow does not occur.
+    Child->rollback();
+  }
+  for(auto itr = backupMap_.begin(); itr != backupMap_.end(); ++itr) {
+    const RBAAllocatable* const original {itr->first};
+    const RBAAllocatable* const backupVal {itr->second.get()};
+    copyAllocatable(backupVal, const_cast<RBAAllocatable*>(original));
+  }
+}
+
+void
+RBARollbacker::copyAllocatable(const RBAAllocatable* const from,
+			       RBAAllocatable* const to)
+{
+  to->setHiddenChecked(from->isHiddenChecked());
+  to->setHidden(from->isHidden());
+  to->setChecked(from->isChecked());
+  to->setState(from->getState());
+  to->clearAllocatablesAffectedByYou();
+  for(const RBAAllocatable* const allocatable : from->getAllocatablesAffectedByYou()) {
+    to->addAllocatableWhichHasBeenAffectedByYou(allocatable);
+  }
+  to->setAttenuateChecked(from->isAttenuateChecked());
+  to->setAttenuated(from->isAttenuated());
+}
+
+}
diff --git a/src/core/logic/RBARollbacker.hpp b/src/core/logic/RBARollbacker.hpp
new file mode 100644
index 0000000..08ee4e9
--- /dev/null
+++ b/src/core/logic/RBARollbacker.hpp
@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+
+/**
+ * Rollbacker (rollback of arbitration results) class header
+ */
+
+#ifndef RBARROLLBACKER_HPP
+#define RBARROLLBACKER_HPP
+
+#include <unordered_map>
+#include <memory>
+#include <list>
+
+namespace rba
+{
+class RBAModel;
+class RBAAllocatable;
+class RBAArbitrator;
+
+class RBARollbacker
+{
+ public:
+  RBARollbacker()=default;
+  RBARollbacker(const RBARollbacker&)=delete;
+  RBARollbacker(const RBARollbacker&&)=delete;
+  RBARollbacker& operator=(const RBARollbacker&)=delete;
+  RBARollbacker& operator=(const RBARollbacker&&)=delete;
+  virtual ~RBARollbacker() noexcept;
+
+  /**
+   * Register a backup for child re-arbitration when execute re-arbitration 
+   * during re-arbitration.
+   * Restore child backup when rolling back
+   */
+  void addChild(const std::shared_ptr<RBARollbacker> child);
+
+  void removeChild(const std::shared_ptr<RBARollbacker> child);
+
+  /**
+   * Back up arbitration status and impact information.
+   * (Only "Allocatable" that directly arbitration is backed up)
+   * Child will back up re-arbitraion during execution of re-aribitration.
+   *
+   * Backing up all "Allocatable" on a model is inefficient, 
+   * so back up only those that execute re-arbitration
+   */
+  void backup(std::list<const RBAAllocatable*>& backuplist);
+
+  /**
+   * Roll back the arbitration state and impact information to 
+   * the state when the instance was created
+   */
+  void rollback();
+
+ private:
+  /**
+   * @brief Copy Allocable arbitration state
+   * @param from source of copy
+   * @param to destination of copy
+   */
+  void copyAllocatable(const RBAAllocatable* const from, RBAAllocatable* const to);
+
+  std::list<std::shared_ptr<RBARollbacker>> children_;
+  // Rollback information when arbitration fails
+  std::unordered_map<const RBAAllocatable*, std::unique_ptr<RBAAllocatable>> backupMap_; 
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAViewAction.cpp b/src/core/logic/RBAViewAction.cpp
new file mode 100644
index 0000000..54553dc
--- /dev/null
+++ b/src/core/logic/RBAViewAction.cpp
@@ -0,0 +1,88 @@
+/**
+ * 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.
+ */
+
+/**
+ * ViewAction Class implementation
+ */
+
+#include "RBAArea.hpp"
+#include "RBAViewContent.hpp"
+#include "RBAViewContentState.hpp"
+#include "RBAViewAction.hpp"
+#include "RBAViewMove.hpp"
+#include "RBAViewTransition.hpp"
+
+namespace rba {
+
+const RBAArea*
+RBAViewAction::getArea() const
+{
+  return nullptr;
+}
+
+const RBAViewContent*
+RBAViewAction::getFromContent() const
+{
+  return nullptr;
+}
+
+const RBAViewContent*
+RBAViewAction::getToContent() const
+{
+  return nullptr;
+}
+
+const RBAViewContentState*
+RBAViewAction::getFromContentState() const
+{
+  return nullptr;
+}
+
+const RBAViewContentState*
+RBAViewAction::getToContentState() const
+{
+  return nullptr;
+}
+
+const RBAArea*
+RBAViewAction::getFromArea() const
+{
+  return nullptr;
+}
+
+const RBAArea*
+RBAViewAction::getToArea() const
+{
+  return nullptr;
+}
+
+const RBAViewContent*
+RBAViewAction::getContent() const
+{
+  // This function is never called because the function of the derived class 
+  // is always called
+  return nullptr;
+}
+
+const RBAViewContentState*
+RBAViewAction::getContentState() const
+{
+  // This function is never called because the function of the derived class 
+  // is always called
+  return nullptr;
+}
+
+}
diff --git a/src/core/logic/RBAViewMove.cpp b/src/core/logic/RBAViewMove.cpp
new file mode 100644
index 0000000..7e40043
--- /dev/null
+++ b/src/core/logic/RBAViewMove.cpp
@@ -0,0 +1,89 @@
+/**
+ * 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.
+ */
+
+ /**
+ * RBAViewMove.cpp
+ */
+
+#include "RBAArea.hpp"
+#include "RBAViewContent.hpp"
+#include "RBAViewContentState.hpp"
+#include "RBAViewMove.hpp"
+
+namespace rba {
+
+RBAViewMove::RBAViewMove(const RBAArea* const newFromArea, const RBAArea* const newToArea,
+			 const RBAViewContentState* const newContentState)
+  : RBAViewAction{}
+{
+  fromArea_ = newFromArea;
+  toArea_ = newToArea;
+  contentState_ = newContentState;
+}
+
+RBAViewMove::RBAViewMove(const RBAViewMove& viewMove)
+  : RBAViewAction{viewMove}
+{
+  fromArea_ = viewMove.fromArea_;
+  toArea_ = viewMove.toArea_;
+  contentState_ = viewMove.contentState_;
+}
+
+bool
+RBAViewMove::operator==(const RBAViewAction& viewAction)
+{
+  if(getViewActionType() != viewAction.getViewActionType()) {
+    // False if the view action types do not match
+    return false;
+  }
+
+  const RBAViewMove* const viewMove {dynamic_cast<const RBAViewMove*>(&viewAction)};
+  return ((fromArea_ == viewMove->fromArea_) &&
+          (toArea_ == viewMove->toArea_) &&
+          (contentState_ == viewMove->contentState_));
+}
+
+const RBAArea*
+RBAViewMove::getFromArea() const
+{
+  return fromArea_;
+}
+
+const RBAArea*
+RBAViewMove::getToArea() const
+{
+  return toArea_;
+}
+
+const RBAViewContent*
+RBAViewMove::getContent() const
+{
+  return contentState_->getOwner();
+}
+
+const RBAViewContentState*
+RBAViewMove::getContentState() const
+{
+  return contentState_;
+}
+
+RBAViewActionType
+RBAViewMove::getViewActionType() const
+{
+  return RBAViewActionType::MOVE;
+}
+
+}
diff --git a/src/core/logic/RBAViewMove.hpp b/src/core/logic/RBAViewMove.hpp
new file mode 100644
index 0000000..2b8db08
--- /dev/null
+++ b/src/core/logic/RBAViewMove.hpp
@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAViewMove.hpp
+ */
+
+#ifndef RBAVIEWMOVE_HPP
+#define RBAVIEWMOVE_HPP
+
+#include "RBAViewActionType.hpp"
+#include "RBAViewAction.hpp"
+
+namespace rba {
+
+class RBAArea;
+class RBAViewContent;
+class RBAViewContentState;
+
+class DLL_EXPORT RBAViewMove : public RBAViewAction
+{
+public:
+  RBAViewMove(const RBAArea* const newFromArea, const RBAArea* const newToArea,
+	      const RBAViewContentState* const newContentState);
+  RBAViewMove(const RBAViewMove& viewMove);
+  RBAViewMove(const RBAViewMove&&)=delete;
+  RBAViewMove& operator=(const RBAViewMove&)=delete;
+  RBAViewMove& operator=(const RBAViewMove&&)=delete;
+  virtual ~RBAViewMove()=default;
+
+  bool operator==(const RBAViewAction& viewAction) override;
+
+public:
+  const RBAArea* getFromArea() const override;
+  const RBAArea* getToArea() const override;
+  const RBAViewContent* getContent() const override;
+  const RBAViewContentState* getContentState() const override;
+  RBAViewActionType getViewActionType() const override;
+
+private:
+  const RBAArea* fromArea_ {nullptr};
+  const RBAArea* toArea_ {nullptr};
+  const RBAViewContentState* contentState_ {nullptr};
+
+};
+
+}
+
+#endif
diff --git a/src/core/logic/RBAViewTransition.cpp b/src/core/logic/RBAViewTransition.cpp
new file mode 100644
index 0000000..93b86a7
--- /dev/null
+++ b/src/core/logic/RBAViewTransition.cpp
@@ -0,0 +1,137 @@
+/**
+ * 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.
+ */
+
+/**
+ * RBAViewTransition.cpp
+ */
+
+#include "RBAArea.hpp"
+#include "RBAViewContent.hpp"
+#include "RBAViewContentState.hpp"
+#include "RBAViewTransition.hpp"
+
+namespace rba {
+
+RBAViewTransition::RBAViewTransition(
+    const RBAViewActionType newViewActionType, const RBAArea* const newArea,
+    const RBAViewContentState* const newContentState1,
+    const RBAViewContentState* const newContentState2)
+    : RBAViewAction(),
+      viewActionType_{newViewActionType},
+      area_{newArea},
+      contentState1_{newContentState1},
+      contentState2_{newContentState2}
+{
+}
+
+RBAViewTransition::RBAViewTransition(const RBAViewTransition& viewTrans)
+  : RBAViewAction{viewTrans}
+{
+  viewActionType_ = viewTrans.viewActionType_;
+  area_ = viewTrans.area_;
+  contentState1_ = viewTrans.contentState1_;
+  contentState2_ = viewTrans.contentState2_;
+}
+
+bool
+RBAViewTransition::operator==(const RBAViewAction& viewAction)
+{
+  if(getViewActionType() != viewAction.getViewActionType()) {
+    // False if the view action types do not match
+    return false;
+  }
+
+  const RBAViewTransition* const viewTran
+    {dynamic_cast<const RBAViewTransition*>(&viewAction)};
+  return ((area_ == viewTran->area_) &&
+          (contentState1_ == viewTran->contentState1_) &&
+          (contentState2_ == viewTran->contentState2_));
+}
+
+const RBAArea*
+RBAViewTransition::getArea() const
+{
+  return area_;
+}
+
+const RBAViewContent*
+RBAViewTransition::getFromContent() const
+{
+  if((contentState1_ == nullptr) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_ADD) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_REMOVE)) {
+    return nullptr;
+  }
+  return contentState1_->getOwner();
+}
+
+const RBAViewContent*
+RBAViewTransition::getToContent() const
+{
+  if((contentState2_ == nullptr) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_ADD) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_REMOVE)) {
+    return nullptr;
+  }
+  return contentState2_->getOwner();
+}
+
+const RBAViewContentState*
+RBAViewTransition::getFromContentState() const
+{
+  if((viewActionType_ == RBAViewActionType::TRANSITION_ADD) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_REMOVE)) {
+    return nullptr;
+  }
+  return contentState1_;
+}
+  
+const RBAViewContentState*
+RBAViewTransition::getToContentState() const
+{
+  if((viewActionType_ == RBAViewActionType::TRANSITION_ADD) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_REMOVE)) {
+    return nullptr;
+  }
+  return contentState2_;
+}
+
+const RBAViewContent*
+RBAViewTransition::getContent() const
+{
+  if((contentState1_ == nullptr) ||
+     (viewActionType_ == RBAViewActionType::TRANSITION_REPLACE)) {
+    return nullptr;
+  }
+  return contentState1_->getOwner();
+}
+
+const RBAViewContentState*
+RBAViewTransition::getContentState() const
+{
+  if(viewActionType_ == RBAViewActionType::TRANSITION_REPLACE) {
+    return nullptr;
+  }
+  return contentState1_;
+}
+
+RBAViewActionType
+RBAViewTransition::getViewActionType() const
+{
+  return viewActionType_;
+}
+
+}
diff --git a/src/core/logic/RBAViewTransition.hpp b/src/core/logic/RBAViewTransition.hpp
new file mode 100644
index 0000000..1b9338f
--- /dev/null
+++ b/src/core/logic/RBAViewTransition.hpp
@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+ /**
+ * RBAViewTransition.hpp
+ */
+
+#ifndef RBAVIEWTRANSITION_HPP
+#define RBAVIEWTRANSITION_HPP
+
+#include "RBAViewAction.hpp"
+
+namespace rba {
+
+class RBAArea;
+
+class DLL_EXPORT RBAViewTransition : public RBAViewAction
+{
+public:
+  RBAViewTransition(const RBAViewActionType newViewActionType, const RBAArea* const newArea,
+                    const RBAViewContentState* const newContentState1,
+                    const RBAViewContentState* const newContentState2 = nullptr);
+  RBAViewTransition(const RBAViewTransition& viewTrans);
+  RBAViewTransition(const RBAViewTransition&&)=delete;
+  RBAViewTransition& operator=(const RBAViewTransition&)=delete;
+  RBAViewTransition& operator=(const RBAViewTransition&&)=delete;
+  virtual ~RBAViewTransition()=default;
+
+  bool operator==(const RBAViewAction& viewAction) override;
+
+public:
+  const RBAArea* getArea() const override;
+
+  const RBAViewContent* getFromContent() const override;
+  const RBAViewContent* getToContent() const override;
+  const RBAViewContentState* getFromContentState() const override;
+  const RBAViewContentState* getToContentState() const override;
+  const RBAViewContent* getContent() const override;
+  const RBAViewContentState* getContentState() const override;
+  RBAViewActionType getViewActionType() const override;
+
+private:
+  RBAViewActionType viewActionType_;
+  const RBAArea* area_;
+  const RBAViewContentState* contentState1_;
+  const RBAViewContentState* contentState2_;
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractAllocatable.cpp b/src/core/model/RBAAbstractAllocatable.cpp
new file mode 100644
index 0000000..c0dfb4f
--- /dev/null
+++ b/src/core/model/RBAAbstractAllocatable.cpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * AbstractAllocatable class implementation
+ */
+
+#include "RBAAbstractAllocatable.hpp"
+
+#include "RBAModelElementType.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAViewContentSet.hpp"
+#include "RBASoundContentSet.hpp"
+
+namespace rba
+{
+
+RBAAbstractAllocatable::RBAAbstractAllocatable(const std::string& name)
+  : RBARuleObject{name},
+    contentSet_{std::make_unique<RBAContentSet>()}
+{
+}
+
+const std::list<const RBAContent*>&
+RBAAbstractAllocatable::getInternalContents() const
+{
+  return contentSet_->getLeafContent();
+}
+
+void
+RBAAbstractAllocatable::addContent(const RBAContent* const content)
+{
+  contentSet_->addTarget(content);
+}
+
+const RBAContentSet*
+RBAAbstractAllocatable::getContentSet() const
+{
+  return contentSet_.get();
+}
+
+}
diff --git a/src/core/model/RBAAbstractAllocatable.hpp b/src/core/model/RBAAbstractAllocatable.hpp
new file mode 100644
index 0000000..b8b7acb
--- /dev/null
+++ b/src/core/model/RBAAbstractAllocatable.hpp
@@ -0,0 +1,65 @@
+/**
+ * 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.
+ */
+
+/**
+ * AbstractAllocatable class header
+ */
+
+#ifndef RBAABSTRACTALLOCATABLE_HPP
+#define RBAABSTRACTALLOCATABLE_HPP
+
+#include <memory>
+#include <list>
+#include "RBARuleObject.hpp"
+#include "RBAContentSet.hpp"
+
+namespace rba
+{
+
+class RBAContent;
+
+class DLL_EXPORT RBAAbstractAllocatable : virtual public RBARuleObject
+{
+protected:
+  explicit RBAAbstractAllocatable(const std::string& name="");
+  RBAAbstractAllocatable(const RBAAbstractAllocatable&)=delete;
+  RBAAbstractAllocatable(const RBAAbstractAllocatable&&)=delete;
+  RBAAbstractAllocatable& operator=(const RBAAbstractAllocatable&)=delete;
+  RBAAbstractAllocatable& operator=(const RBAAbstractAllocatable&&)=delete;
+
+public:
+  virtual ~RBAAbstractAllocatable()=default;
+
+public:
+  const std::list<const RBAContent*>& getInternalContents() const;
+  void addContent(const RBAContent* const content);
+  const RBAContentSet* getContentSet() const;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::unique_ptr<RBAContentSet> contentSet_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractAllocatableMaker.cpp b/src/core/model/RBAAbstractAllocatableMaker.cpp
new file mode 100644
index 0000000..793336a
--- /dev/null
+++ b/src/core/model/RBAAbstractAllocatableMaker.cpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAbstractAllocatableMaker.cpp
+/// @brief AbstractAllocatable generator class implementation
+
+#include "RBAAbstractAllocatableMaker.hpp"
+#include "RBAAbstractAllocatable.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAAbstractAllocatableMaker::RBAAbstractAllocatableMaker(const std::string& label)
+  : RBARuleObjectMaker{label}
+{
+}
+
+RBAModelElement*
+RBAAbstractAllocatableMaker::setProperty(RBAModelElement* element,
+                                         const RBAJsonElement* jsonElem,
+                                         RBAModelImpl* model,
+                                         RBAModelElement* owner)
+{
+  static_cast<void>(RBARuleObjectMaker::setProperty(element, jsonElem, model, owner));
+  
+  const auto abstAllo = dynamic_cast<RBAAbstractAllocatable*>(element);
+
+  // Currently, there is no member set by RBAAbstractAllocatableMaker 
+  // as model information, but this process is implemented 
+  // because it may be added in the future.
+
+  return abstAllo;
+}
+
+}
diff --git a/src/core/model/RBAAbstractAllocatableMaker.hpp b/src/core/model/RBAAbstractAllocatableMaker.hpp
new file mode 100644
index 0000000..845acd2
--- /dev/null
+++ b/src/core/model/RBAAbstractAllocatableMaker.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAbstractAllocatableMaker.hpp
+/// @brief AbstractAllocatable generator class header
+
+#ifndef RBAABSTRACTALLOCATABLEMAKER_HPP
+#define RBAABSTRACTALLOCATABLEMAKER_HPP
+
+#include "RBARuleObjectMaker.hpp"
+
+namespace rba
+{
+
+/// @brief AbstractAllocatable generator class
+class DLL_EXPORT RBAAbstractAllocatableMaker : virtual public RBARuleObjectMaker
+{
+public:
+  explicit RBAAbstractAllocatableMaker(const std::string& label="");
+  RBAAbstractAllocatableMaker(const RBAAbstractAllocatableMaker&)=delete;
+  RBAAbstractAllocatableMaker(const RBAAbstractAllocatableMaker&&)=delete;
+  RBAAbstractAllocatableMaker& operator=(const RBAAbstractAllocatableMaker&)=delete;
+  RBAAbstractAllocatableMaker& operator=(const RBAAbstractAllocatableMaker&&)=delete;
+  virtual ~RBAAbstractAllocatableMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractConstraint.cpp b/src/core/model/RBAAbstractConstraint.cpp
new file mode 100644
index 0000000..3c8ba73
--- /dev/null
+++ b/src/core/model/RBAAbstractConstraint.cpp
@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+
+/**
+ * AbstractConstraint class implementation
+ */
+
+#include "RBAAbstractConstraint.hpp"
+
+#include "RBAExpression.hpp"
+#include "RBALogManager.hpp"
+
+namespace rba
+{
+
+RBAAbstractConstraint::RBAAbstractConstraint(const std::string& name)
+  : RBANamedElement{name}
+{
+}
+
+bool
+RBAAbstractConstraint::isConstraint() const
+{
+  return false;
+}
+
+bool
+RBAAbstractConstraint::isRule() const
+{
+  return false;
+}
+
+void
+RBAAbstractConstraint::clearInfo()
+{
+  info_->clear();
+}
+
+void
+RBAAbstractConstraint::setExpression(RBAExpression* newExpr)
+{
+  expression_ = newExpr;
+}
+
+RBAExpression* const
+RBAAbstractConstraint::getExpression() const
+{
+  return expression_;
+}
+
+RBAConstraintInfo*
+RBAAbstractConstraint::getInfo() const
+{
+  return info_.get();
+}
+
+#ifdef RBA_USE_LOG
+void
+RBAAbstractConstraint::createHierarchy()
+{
+  LOG_initConstraintHierarchy();
+  LOG_coverageHierarchyOfConstraintStartLog(this);
+  getExpression()->createHierarchy();
+  LOG_coverageHierarchyOfConstraintEndLog(this);
+}
+#endif
+
+}
diff --git a/src/core/model/RBAAbstractConstraint.hpp b/src/core/model/RBAAbstractConstraint.hpp
new file mode 100644
index 0000000..d19bba5
--- /dev/null
+++ b/src/core/model/RBAAbstractConstraint.hpp
@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+
+/**
+ * AbstractConstraint class header
+ */
+
+#ifndef RBAABSTRACTCONSTRAINT_HPP
+#define RBAABSTRACTCONSTRAINT_HPP
+
+#include <memory>
+#include "RBANamedElement.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+class RBAExpression;
+
+class DLL_EXPORT RBAAbstractConstraint : public RBANamedElement
+{
+protected:
+  explicit RBAAbstractConstraint(const std::string& name);
+  RBAAbstractConstraint(const RBAAbstractConstraint&)=delete;
+  RBAAbstractConstraint(const RBAAbstractConstraint&&)=delete;
+  RBAAbstractConstraint& operator=(const RBAAbstractConstraint&)=delete;
+  RBAAbstractConstraint& operator=(const RBAAbstractConstraint&&)=delete;
+  void clearInfo();
+
+public:
+  virtual ~RBAAbstractConstraint()=default;
+  virtual bool isConstraint() const;
+  virtual bool isRule() const;
+  virtual void setExpression(RBAExpression*);
+  virtual RBAExpression* const getExpression() const;
+  RBAConstraintInfo* getInfo() const;
+
+  // Log
+#ifdef RBA_USE_LOG
+  virtual void createHierarchy();
+#endif
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::unique_ptr<RBAConstraintInfo> info_ {std::make_unique<RBAConstraintInfo>()};
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+  RBAExpression* expression_ {nullptr};
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractConstraintMaker.cpp b/src/core/model/RBAAbstractConstraintMaker.cpp
new file mode 100644
index 0000000..5de0ae3
--- /dev/null
+++ b/src/core/model/RBAAbstractConstraintMaker.cpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAbstractConstraintMaker.cpp
+/// @brief Abstract Constraint expresion generator class
+
+#include "RBAAbstractConstraintMaker.hpp"
+#include "RBAAbstractConstraint.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAAbstractConstraintMaker::RBAAbstractConstraintMaker(const std::string& label)
+  : RBAModelElementMaker{label}
+{
+}
+
+RBAModelElement*
+RBAAbstractConstraintMaker::setProperty(RBAModelElement* element,
+                                        const RBAJsonElement* jsonElem,
+                                        RBAModelImpl* model,
+                                        RBAModelElement* owner)
+{
+  const auto abstConstraint = dynamic_cast<RBAAbstractConstraint*>(element);
+
+  // Set expression
+  const RBAJsonElement* const childElem {jsonElem->findChildren("expression")};
+  RBAModelElement* const expr {getFactory()->createElement(childElem->getClassName(),
+                                                  childElem)};
+  abstConstraint->setExpression(dynamic_cast<RBAExpression*>(expr));
+
+  return abstConstraint;
+}
+
+}
diff --git a/src/core/model/RBAAbstractConstraintMaker.hpp b/src/core/model/RBAAbstractConstraintMaker.hpp
new file mode 100644
index 0000000..916408e
--- /dev/null
+++ b/src/core/model/RBAAbstractConstraintMaker.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAbstractConstraintMaker.hpp
+/// @brief Abstract Constraint expresion generator class header
+
+#ifndef RBAABSTRACTCONSTRAINTMAKER_HPP
+#define RBAABSTRACTCONSTRAINTMAKER_HPP
+
+#include "RBAModelElementMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Abstract Constraint expresion generator class
+class DLL_EXPORT RBAAbstractConstraintMaker
+  : public RBAModelElementMaker
+{
+public:
+  explicit RBAAbstractConstraintMaker(const std::string& label);
+  RBAAbstractConstraintMaker(const RBAAbstractConstraintMaker&)=delete;
+  RBAAbstractConstraintMaker(const RBAAbstractConstraintMaker&&)=delete;
+  RBAAbstractConstraintMaker& operator=(const RBAAbstractConstraintMaker&)=delete;
+  RBAAbstractConstraintMaker& operator=(const RBAAbstractConstraintMaker&&)=delete;
+  virtual ~RBAAbstractConstraintMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractContent.cpp b/src/core/model/RBAAbstractContent.cpp
new file mode 100644
index 0000000..d8f025f
--- /dev/null
+++ b/src/core/model/RBAAbstractContent.cpp
@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+
+/**
+ * Abstract Content class implementation
+ */
+
+#include "RBAAbstractContent.hpp"
+
+namespace rba
+{
+
+RBAAbstractContent::RBAAbstractContent(const std::string& name)
+  : RBARuleObject{name}
+{
+}
+
+}
diff --git a/src/core/model/RBAAbstractContent.hpp b/src/core/model/RBAAbstractContent.hpp
new file mode 100644
index 0000000..c2d72b1
--- /dev/null
+++ b/src/core/model/RBAAbstractContent.hpp
@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+
+/**
+ * Abstract Content class header
+ */
+
+#ifndef RBAABSTRACTCONTENT_HPP
+#define RBAABSTRACTCONTENT_HPP
+
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAAbstractContent : virtual public RBARuleObject
+{
+protected:
+  explicit RBAAbstractContent(const std::string& name="");
+  RBAAbstractContent(const RBAAbstractContent&)=delete;
+  RBAAbstractContent(const RBAAbstractContent&&)=delete;
+  RBAAbstractContent& operator=(const RBAAbstractContent&)=delete;
+  RBAAbstractContent& operator=(const RBAAbstractContent&&)=delete;
+
+public:
+  virtual ~RBAAbstractContent()=default;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractContentMaker.cpp b/src/core/model/RBAAbstractContentMaker.cpp
new file mode 100644
index 0000000..b0ff0be
--- /dev/null
+++ b/src/core/model/RBAAbstractContentMaker.cpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAbstractContentMaker.cpp
+/// @brief Abstract Content generator class implementation
+
+#include "RBAAbstractContentMaker.hpp"
+#include "RBAAbstractContent.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAAbstractContentMaker::RBAAbstractContentMaker(const std::string& label)
+  : RBARuleObjectMaker{label}
+{
+}
+
+RBAModelElement*
+RBAAbstractContentMaker::setProperty(RBAModelElement* element,
+                                     const RBAJsonElement* jsonElem,
+                                     RBAModelImpl* model,
+                                     RBAModelElement* owner)
+{
+  static_cast<void>(RBARuleObjectMaker::setProperty( element, jsonElem, 
+  	                                                 model, owner));
+  
+  const auto abstContent = dynamic_cast<RBAAbstractContent*>(element);
+
+  // Currently, there is no member set by RBAAbstractContentMaker
+  // as model information, but this process is implemented 
+  // because it may be added in the future.
+
+  return abstContent;
+}
+
+}
diff --git a/src/core/model/RBAAbstractContentMaker.hpp b/src/core/model/RBAAbstractContentMaker.hpp
new file mode 100644
index 0000000..df311a8
--- /dev/null
+++ b/src/core/model/RBAAbstractContentMaker.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAbstractContentMaker.cpp
+/// @brief Abstract Content generator class header
+
+#ifndef RBAABSTRACTCONTENTMAKER_HPP
+#define RBAABSTRACTCONTENTMAKER_HPP
+
+#include "RBARuleObjectMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Abstract Content generator class 
+class DLL_EXPORT RBAAbstractContentMaker : virtual public RBARuleObjectMaker
+{
+public:
+  explicit RBAAbstractContentMaker(const std::string& label="");
+  RBAAbstractContentMaker(const RBAAbstractContentMaker&)=delete;
+  RBAAbstractContentMaker(const RBAAbstractContentMaker&&)=delete;
+  RBAAbstractContentMaker& operator=(const RBAAbstractContentMaker&)=delete;
+  RBAAbstractContentMaker& operator=(const RBAAbstractContentMaker&&)=delete;
+  virtual ~RBAAbstractContentMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAbstractProperty.cpp b/src/core/model/RBAAbstractProperty.cpp
new file mode 100644
index 0000000..a90fa4d
--- /dev/null
+++ b/src/core/model/RBAAbstractProperty.cpp
@@ -0,0 +1,46 @@
+/**
+ * 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.
+ */
+
+/**
+ * Abstract property class implementation
+ */
+
+#include "RBAAbstractProperty.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+RBAAbstractProperty::RBAAbstractProperty(const RBASceneImpl* const scene, const std::string& name)
+  : RBARuleObject{name},
+    scene_{scene}
+{
+}
+
+RBAModelElementType
+RBAAbstractProperty::getModelElementType() const
+{
+  return RBAModelElementType::Property;
+}
+
+const RBASceneImpl*
+RBAAbstractProperty::getScene() const
+{
+  return scene_;
+}
+
+}
diff --git a/src/core/model/RBAAbstractProperty.hpp b/src/core/model/RBAAbstractProperty.hpp
new file mode 100644
index 0000000..15ecc2d
--- /dev/null
+++ b/src/core/model/RBAAbstractProperty.hpp
@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+/**
+ * Abstract property class header
+ */
+
+#ifndef RBAABSTRACTPROPERTY_HPP
+#define RBAABSTRACTPROPERTY_HPP
+
+#include <cstdint>
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+class RBASceneImpl;
+
+class RBAAbstractProperty : public RBARuleObject
+{
+protected:
+  RBAAbstractProperty(const RBASceneImpl* const scene, const std::string& name);
+  RBAAbstractProperty(const RBAAbstractProperty&)=delete;
+  RBAAbstractProperty(const RBAAbstractProperty&&)=delete;
+  RBAAbstractProperty& operator=(const RBAAbstractProperty&)=delete;
+  RBAAbstractProperty& operator=(const RBAAbstractProperty&&)=delete;
+
+public:
+  virtual ~RBAAbstractProperty()=default;
+
+public:
+  RBAModelElementType getModelElementType() const override;
+  virtual std::int32_t getValue() const=0;
+  virtual const RBASceneImpl* getScene() const;
+
+  // Log
+#ifdef RBA_USE_LOG
+  virtual const std::string getExpressionText() const=0;
+#endif
+
+private:
+  const RBASceneImpl* scene_;
+
+};
+
+}
+
+#endif
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);
+  }
+}
+
+}
diff --git a/src/core/model/RBAAllocatable.hpp b/src/core/model/RBAAllocatable.hpp
new file mode 100644
index 0000000..c44d643
--- /dev/null
+++ b/src/core/model/RBAAllocatable.hpp
@@ -0,0 +1,131 @@
+/**
+ * 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 header
+ */
+
+#ifndef RBAALLOCATABLE_HPP
+#define RBAALLOCATABLE_HPP
+
+#include "RBAAbstractAllocatable.hpp"
+#include "RBAArbitrationPolicy.hpp"
+
+namespace rba
+{
+
+class RBAViewContent;
+class RBANotificationChain;
+class RBAContentState;
+class RBAConstraintImpl;
+enum class RBAConstraintMap : std::uint8_t;
+
+class DLL_EXPORT RBAAllocatable : public RBAAbstractAllocatable
+{
+public:
+  explicit RBAAllocatable(const std::string& name="");
+  RBAAllocatable(const RBAAllocatable&)=delete;
+  RBAAllocatable(const RBAAllocatable&&)=delete;
+  RBAAllocatable& operator=(const RBAAllocatable&)=delete;
+  RBAAllocatable& operator=(const RBAAllocatable&&)=delete;
+  virtual ~RBAAllocatable()=default;
+
+public:
+  void clearStatus() override;
+  virtual bool isArea() const;
+  virtual bool isZone() const;
+  RBAArbitrationPolicy getAllocatableArbitrationPolicy() const;
+  void setArbitrationPolicy(const RBAArbitrationPolicy newPolicy);
+  std::int32_t getVisibility() const;
+  void setVisibility(const std::int32_t newVisibility);
+  const std::list<const RBAAllocatable*>& getAllocatablesAffectedByYou() const;
+  void clearAllocatablesAffectedByYou();
+  void addAllocatableWhichHasBeenAffectedByYou(const RBAAllocatable* const allocatable);
+  void removeAffectAllocatable(const RBAAllocatable* const allocatable);
+  void clearAffectAllocatable();
+  virtual void clearChecked();
+  std::int32_t getIndex() const;
+  void setIndex(const std::int32_t newIndex);
+
+  static bool compare(const RBAAllocatable* const arg0, const RBAAllocatable* const arg1);
+  static bool compareIndex(const RBAAllocatable* const arg0, const RBAAllocatable* const arg1);
+  const static RBAArbitrationPolicy ARBITRATION_POLICY_EDEFAULT =
+                                    RBAArbitrationPolicy::DEFAULT;
+  void addConstraint(RBAConstraintImpl* const constraint, const RBAConstraintMap& kind);
+  std::list<RBAConstraintImpl*>& getConstraints();
+  std::list<RBAConstraintImpl*>& getHiddenTrueCheckConstraints();
+  std::list<RBAConstraintImpl*>& getHiddenFalseCheckConstraints();
+  std::list<RBAConstraintImpl*>& getAttenuateTrueCheckConstraints();
+  std::list<RBAConstraintImpl*>& getAttenuateFalseCheckConstraints();
+  bool hasConstraint(const RBAConstraintImpl* const constraint) const;
+
+  bool isChecked() const;
+  void setChecked(const bool checked);
+  bool isHiddenChecked() const;
+  void setHiddenChecked(const bool hiddenChecked);
+  bool isAttenuateChecked() const;
+  void setAttenuateChecked(const bool attenuateChecked=false);
+  bool isAttenuated() const;
+  void setAttenuated(const bool attenuated=false);
+  bool isHidden() const;
+  void setHidden(const bool hidden=false);
+  const RBAContentState* getState() const;
+  void setState(const RBAContentState* const state);
+
+  // Log
+#ifdef RBA_USE_LOG
+  virtual std::string getSymbol() const;
+  virtual std::string getHiddenSymbol() const;
+  std::string getArbitrationPolicyString() const;
+  std::string getVisibilityString() const;
+#endif
+
+ private:
+  void addConstraintImpl(RBAConstraintImpl* const constraint,
+                         std::list<RBAConstraintImpl*>& constraints);
+
+protected:
+  // Zone should be a Z-order below the minimum Area
+  const static std::int32_t ZONE_ZORDER = -2;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::list<const RBAAllocatable*> allocatablesAffectedByThisAllocatable_;
+  std::list<RBAConstraintImpl*> constraints_;
+  std::list<RBAConstraintImpl*> hiddenTrueCheckConstraints_;
+  std::list<RBAConstraintImpl*> hiddenFalseCheckConstraints_;
+  std::list<RBAConstraintImpl*> attenuateTrueCheckConstraints_;
+  std::list<RBAConstraintImpl*> attenuateFalseCheckConstraints_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+  RBAArbitrationPolicy arbitrationPolicy_{ARBITRATION_POLICY_EDEFAULT};
+  std::int32_t visibility_ {0};
+  std::int32_t index_ {0};
+  const RBAContentState * state_ {nullptr};
+  bool hiddenChecked_ {false};
+  bool checked_ {false};
+  bool attenuateChecked_ {false};
+  bool hidden_ {false};
+  bool attenuated_ {false};
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAllocatableMaker.cpp b/src/core/model/RBAAllocatableMaker.cpp
new file mode 100644
index 0000000..f59813b
--- /dev/null
+++ b/src/core/model/RBAAllocatableMaker.cpp
@@ -0,0 +1,82 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAllocatableMaker.cpp
+/// @brief Allocatable object generator abstract class implementation
+
+#include <iostream>
+#include "RBAAllocatableMaker.hpp"
+#include "RBAAllocatable.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAAllocatableMaker::RBAAllocatableMaker(const std::string& label)
+  : RBARuleObjectMaker{label},
+    RBAAbstractAllocatableMaker{label}
+{
+}
+
+RBAModelElement*
+RBAAllocatableMaker::setProperty(RBAModelElement* element,
+                                 const RBAJsonElement* jsonElem,
+                                 RBAModelImpl* model,
+                                 RBAModelElement* owner)
+{
+  static_cast<void>(RBAAbstractAllocatableMaker::setProperty(element, jsonElem, model, owner));
+
+  const auto alloc = dynamic_cast<RBAAllocatable*>(element);
+
+  // Set policy
+  const RBAJsonElement* const policy {jsonElem->findChildren("arbitrationPolicy")};
+  if(policy == nullptr) {
+    std::cerr << alloc->getElementName()
+              << ": arbitrationPolicy not found" << &std::endl;
+    return nullptr;
+  }
+  alloc->setArbitrationPolicy(policy->getArbitrationPolicy());
+
+  // Set visibility or priority
+  if (alloc->isArea()) {
+    const RBAJsonElement* const visibility {jsonElem->findChildren("visibility")};
+    if(visibility == nullptr) {
+    	std::cerr << alloc->getElementName()
+                << ": visibility not found" << &std::endl;
+      return nullptr;
+    }
+    alloc->setVisibility(visibility->getInt());
+  } else if (alloc->isZone()) {
+    const RBAJsonElement* const priority {jsonElem->findChildren("priority")};
+    if(priority == nullptr) {
+      std::cerr << alloc->getElementName()
+                << ": priority not found" << &std::endl;
+      return nullptr;
+    }
+    alloc->setVisibility(priority->getInt());
+  } else {
+    ;
+  }
+
+  model->addAllocatable(alloc);
+
+  return alloc;
+}
+
+}
diff --git a/src/core/model/RBAAllocatableMaker.hpp b/src/core/model/RBAAllocatableMaker.hpp
new file mode 100644
index 0000000..f4393cb
--- /dev/null
+++ b/src/core/model/RBAAllocatableMaker.hpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAllocatableMaker.cpp
+/// @brief Allocatable object generator abstract class header
+
+#ifndef RBAALLOCATABLEMAKER_HPP
+#define RBAALLOCATABLEMAKER_HPP
+
+#include "RBAAbstractAllocatableMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Allocatable object generator abstract class
+class DLL_EXPORT RBAAllocatableMaker
+  : public RBAAbstractAllocatableMaker
+{
+public:
+  explicit RBAAllocatableMaker(const std::string& label="");
+  RBAAllocatableMaker(const RBAAllocatableMaker&)=delete;
+  RBAAllocatableMaker(const RBAAllocatableMaker&&)=delete;
+  RBAAllocatableMaker& operator=(const RBAAllocatableMaker&)=delete;
+  RBAAllocatableMaker& operator=(const RBAAllocatableMaker&&)=delete;
+  virtual ~RBAAllocatableMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAAllocatableSet.cpp b/src/core/model/RBAAllocatableSet.cpp
new file mode 100644
index 0000000..c545417
--- /dev/null
+++ b/src/core/model/RBAAllocatableSet.cpp
@@ -0,0 +1,65 @@
+/**
+ * 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.
+ */
+
+/**
+ * AllocatableSet class implementation
+ */
+
+#include "RBAAllocatableSet.hpp"
+#include "RBAAllocatable.hpp"
+
+namespace rba
+{
+
+RBAAllocatableSet::RBAAllocatableSet(const std::string& name)
+  : RBARuleObject{name},
+    RBAAbstractAllocatable{name}
+{
+}
+
+void
+RBAAllocatableSet::addTarget(const RBAAllocatable* alloc)
+{
+  leafAllocatable_.push_back(alloc);
+#ifdef RBA_USE_LOG
+  std::string newName = "[";
+  for (auto& a : leafAllocatable_) {
+    newName += a->getElementName() + ",";
+  }
+  if (newName.size() != 1U) {
+    newName.erase(newName.end() - 1);  // Remove the trailing ",".
+  }
+  newName += "]";
+  setDynamicName(newName);
+#endif
+}
+
+void
+RBAAllocatableSet::clear()
+{
+  leafAllocatable_.clear();
+#ifdef RBA_USE_LOG
+  setDynamicName("[]");
+#endif
+}
+
+const std::list<const RBAAllocatable*>&
+RBAAllocatableSet::getLeafAllocatable() const
+{
+  return leafAllocatable_;
+}
+
+}
diff --git a/src/core/model/RBAAllocatableSet.hpp b/src/core/model/RBAAllocatableSet.hpp
new file mode 100644
index 0000000..1c02155
--- /dev/null
+++ b/src/core/model/RBAAllocatableSet.hpp
@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+
+/**
+ * AllocatableSet class header
+ */
+
+#ifndef RBAALLOCATABLESET_HPP
+#define RBAALLOCATABLESET_HPP
+
+#include "RBAAbstractAllocatable.hpp"
+
+namespace rba
+{
+
+class RBAAllocatable;
+
+class DLL_EXPORT RBAAllocatableSet : public RBAAbstractAllocatable
+{
+public:
+  explicit RBAAllocatableSet(const std::string& name="");
+  RBAAllocatableSet(const RBAAllocatableSet&)=delete;
+  RBAAllocatableSet(const RBAAllocatableSet&&)=delete;
+  RBAAllocatableSet& operator=(const RBAAllocatableSet&)=delete;
+  RBAAllocatableSet& operator=(const RBAAllocatableSet&&)=delete;
+  virtual ~RBAAllocatableSet()=default;
+
+public:
+  virtual void addTarget(const RBAAllocatable* alloc);
+  virtual void clear();
+  const std::list<const RBAAllocatable*>& getLeafAllocatable() const;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::list<const RBAAllocatable*> leafAllocatable_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+#endif
diff --git a/src/core/model/RBAAllocatableSetMaker.cpp b/src/core/model/RBAAllocatableSetMaker.cpp
new file mode 100644
index 0000000..9b9922a
--- /dev/null
+++ b/src/core/model/RBAAllocatableSetMaker.cpp
@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAllocatableSetMaker.cpp
+/// @brief AllocatableSet object genartor abstract class implementation
+
+#include <iostream>
+#include "RBAAllocatableSetMaker.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAAllocatableSetMaker::RBAAllocatableSetMaker(const std::string& label)
+  : RBARuleObjectMaker{label},
+    RBAAbstractAllocatableMaker{label}
+{
+}
+
+RBAModelElement*
+RBAAllocatableSetMaker::setProperty(RBAModelElement* element,
+                                    const RBAJsonElement* jsonElem,
+                                    RBAModelImpl* model,
+                                    RBAModelElement* owner)
+{
+  static_cast<void>(RBAAbstractAllocatableMaker::setProperty(element, jsonElem, model, owner));
+
+  const auto allocSet = dynamic_cast<RBAAllocatableSet*>(element);
+
+  // Set target
+  const RBAJsonElement* const target {jsonElem->findChildren("target")};
+  for(const auto& targetElem : target->getChildren()) {
+    const auto alloc = model->findAllocatable(targetElem->getName());
+    allocSet->addTarget(alloc);
+  }
+
+  return allocSet;
+}
+
+}
diff --git a/src/core/model/RBAAllocatableSetMaker.hpp b/src/core/model/RBAAllocatableSetMaker.hpp
new file mode 100644
index 0000000..619d220
--- /dev/null
+++ b/src/core/model/RBAAllocatableSetMaker.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAAllocatableSetMaker.cpp
+/// @brief AllocatableSet object genartor abstract class header
+
+#ifndef RBAALLOCATABLESETMAKER_HPP
+#define RBAALLOCATABLESETMAKER_HPP
+
+#include "RBAAbstractAllocatableMaker.hpp"
+
+namespace rba
+{
+
+/// @brief AllocatableSet object genartor abstract class
+class RBAAllocatableSetMaker : public RBAAbstractAllocatableMaker
+{
+public:
+  explicit RBAAllocatableSetMaker(const std::string& label="");
+  RBAAllocatableSetMaker(const RBAAllocatableSetMaker&)=delete;
+  RBAAllocatableSetMaker(const RBAAllocatableSetMaker&&)=delete;
+  RBAAllocatableSetMaker& operator=(const RBAAllocatableSetMaker&)=delete;
+  RBAAllocatableSetMaker& operator=(const RBAAllocatableSetMaker&&)=delete;
+  virtual ~RBAAllocatableSetMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAConstraint.hpp b/src/core/model/RBAConstraint.hpp
new file mode 100644
index 0000000..312bedc
--- /dev/null
+++ b/src/core/model/RBAConstraint.hpp
@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+
+/**
+ * Constraint class
+ */
+
+#ifndef RBACONSTRAINT_HPP
+#define RBACONSTRAINT_HPP
+
+#include <string>
+#include "RBADllExport.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAConstraint
+{
+ public:
+  RBAConstraint()=default;
+  RBAConstraint(const RBAConstraint&)=delete;
+  RBAConstraint(const RBAConstraint&&)=delete;
+  RBAConstraint& operator=(const RBAConstraint&)=delete;
+  RBAConstraint& operator=(const RBAConstraint&&)=delete;
+  virtual ~RBAConstraint() = default;
+  virtual std::string getName() const =0;
+  const static bool RUNTIME_EDEFAULT = true;
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAConstraintImpl.cpp b/src/core/model/RBAConstraintImpl.cpp
new file mode 100644
index 0000000..a634621
--- /dev/null
+++ b/src/core/model/RBAConstraintImpl.cpp
@@ -0,0 +1,96 @@
+/**
+ * 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.
+ */
+
+/**
+ * Constraint Implementation class
+ */
+
+#include "RBAConstraintImpl.hpp"
+
+#include "RBAExpression.hpp"
+#include "RBALogManager.hpp"
+
+namespace rba
+{
+
+RBAConstraintImpl::RBAConstraintImpl(const std::string& name)
+  : RBAConstraint(),
+    RBAAbstractConstraint{name}
+{
+}
+
+void
+RBAConstraintImpl::setRuntime(const bool newRuntime)
+{
+  runtime_ = newRuntime;
+}
+
+std::string
+RBAConstraintImpl::getName() const
+{
+  return RBANamedElement::getElementName();
+}
+
+bool
+RBAConstraintImpl::isConstraint() const
+{
+  return true;
+}
+
+bool
+RBAConstraintImpl::isRuntime() const
+{
+  return runtime_;
+}
+
+bool
+RBAConstraintImpl::execute(RBAArbitrator* const arb)
+{
+  LOG_arbitrateConstraintLogicLogLine("    constraint expression["
+						 + getExpression()->LOG_getExpressionText()
+						 + "] check start");
+  LOG_initConstraintHierarchy();
+  LOG_coverageConstraintStartLog(this);
+
+  clearInfo();
+
+  bool res {getExpression()->execute(getInfo(), arb)};
+#ifdef RBA_USE_LOG
+  std::string log = "    constraint expression[" + getExpression()->getExpressionText();
+
+  if (res == true) {
+    log += "] true";
+  } else {
+#endif
+    if (getInfo()->isExceptionBeforeArbitrate() == true) {
+#ifdef RBA_USE_LOG
+      log += "] before arbitrate skip";
+#endif
+      res = true;
+#ifdef RBA_USE_LOG
+    } else {
+      log += "] false";
+    }
+#endif
+  }
+  LOG_arbitrateConstraintLogicLogLine(log + "\n");
+
+  LOG_coverageConstraintEndLog(this);
+
+  return res;
+}
+
+}
diff --git a/src/core/model/RBAConstraintImpl.hpp b/src/core/model/RBAConstraintImpl.hpp
new file mode 100644
index 0000000..eb4d6ab
--- /dev/null
+++ b/src/core/model/RBAConstraintImpl.hpp
@@ -0,0 +1,56 @@
+/**
+ * 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.
+ */
+
+/**
+ * Constraint Implementation class header
+ */
+
+#ifndef RBACONSTRAINTIMPL_HPP
+#define RBACONSTRAINTIMPL_HPP
+
+#include "RBAConstraint.hpp"
+#include "RBAAbstractConstraint.hpp"
+
+namespace rba
+{
+
+class RBAArbitrator;
+
+class DLL_EXPORT RBAConstraintImpl : public RBAConstraint,
+                                     public RBAAbstractConstraint
+{
+public:
+  explicit RBAConstraintImpl(const std::string& name="");
+  RBAConstraintImpl(const RBAConstraintImpl&)=delete;
+  RBAConstraintImpl(const RBAConstraintImpl&&)=delete;
+  RBAConstraintImpl& operator=(const RBAConstraintImpl&)=delete;
+  RBAConstraintImpl& operator=(const RBAConstraintImpl&&)=delete;
+  virtual ~RBAConstraintImpl()=default;
+
+public:
+  void setRuntime(const bool newRuntime);
+  std::string getName() const override;
+  bool isConstraint() const override;
+  bool isRuntime() const;
+  bool execute(RBAArbitrator* const arb);
+
+private:
+  bool runtime_ {RUNTIME_EDEFAULT};
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAConstraintMaker.cpp b/src/core/model/RBAConstraintMaker.cpp
new file mode 100644
index 0000000..7363c16
--- /dev/null
+++ b/src/core/model/RBAConstraintMaker.cpp
@@ -0,0 +1,63 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAConstraintMaker.cpp
+/// @brief Constraint object genartor class implementation
+
+#include "RBAConstraintMaker.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAConstraintImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAConstraintMaker::RBAConstraintMaker()
+  : RBAAbstractConstraintMaker{"constraints"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBAConstraintMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBAConstraintImpl>(name);
+}
+
+RBAModelElement*
+RBAConstraintMaker::setProperty(RBAModelElement* element,
+                                const RBAJsonElement* jsonElem,
+                                RBAModelImpl* model,
+                                RBAModelElement* owner)
+{
+  static_cast<void>(RBAAbstractConstraintMaker::setProperty(element, jsonElem, model, owner));
+
+  const auto constraint = dynamic_cast<RBAConstraintImpl*>(element);
+
+  // Set runtime
+  bool runtime {false};
+  if(jsonElem->findChildren("runtime")->getString() == "true") {
+    runtime = true;
+  }
+  constraint->setRuntime(runtime);
+
+  model->addConstraint(constraint);
+
+  return constraint;
+}
+
+}
diff --git a/src/core/model/RBAConstraintMaker.hpp b/src/core/model/RBAConstraintMaker.hpp
new file mode 100644
index 0000000..4bcb250
--- /dev/null
+++ b/src/core/model/RBAConstraintMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAConstraintMaker.jhp
+/// @brief Constraint object generator class header
+
+#ifndef RBACONSTRAINTMAKER_HPP
+#define RBACONSTRAINTMAKER_HPP
+
+#include "RBAAbstractConstraintMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Constraint object generator class
+class RBAConstraintMaker : public RBAAbstractConstraintMaker
+{
+public:
+  RBAConstraintMaker();
+  RBAConstraintMaker(const RBAConstraintMaker&)=delete;
+  RBAConstraintMaker(const RBAConstraintMaker&&)=delete;
+  RBAConstraintMaker& operator=(const RBAConstraintMaker&)=delete;
+  RBAConstraintMaker& operator=(const RBAConstraintMaker&&)=delete;
+  virtual ~RBAConstraintMaker()=default;
+
+protected:
+  /// @brief Create an empty instance
+  /// @details Create an empty class of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContent.cpp b/src/core/model/RBAContent.cpp
new file mode 100644
index 0000000..e2e3c9f
--- /dev/null
+++ b/src/core/model/RBAContent.cpp
@@ -0,0 +1,107 @@
+/**
+ * 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.
+ */
+
+/**
+ * Content class 
+ */
+
+#include "RBAContent.hpp"
+#include "RBAResultImpl.hpp"
+#include "RBAResultSet.hpp"
+#include "RBAExpression.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+RBAContent::RBAContent(const std::string& name)
+  : RBARuleObject{name},
+    RBAAbstractContent{name}
+{
+}
+
+bool
+RBAContent::isViewContent() const
+{
+  return false;
+}
+
+bool
+RBAContent::isSoundContent() const
+{
+  return false;
+}
+
+const std::list<const RBAContentState*>&
+RBAContent::getStates() const
+{
+  return states_;
+}
+
+void
+RBAContent::addState(const RBAContentState* const state)
+{
+  states_.push_back(state);
+}
+
+const std::list<const RBAAllocatable*>&
+RBAContent::getAllocatables() const
+{
+  return allocatableSet_->getLeafAllocatable();
+}
+
+void
+RBAContent::addAllocatable(const RBAAllocatable* const alloc)
+{
+  allocatableSet_->addTarget(alloc);
+}
+
+RBAContentLoserType
+RBAContent::getContentLoserType() const
+{
+  return loserType_;
+}
+
+void
+RBAContent::setLoserType(const RBAContentLoserType newLoserType)
+{
+  loserType_ = newLoserType;
+}
+
+const RBAAllocatableSet*
+RBAContent::getAllocatableSet() const
+{
+  return allocatableSet_.get();
+}
+
+void RBAContent::updateRequestStatus(RBAResultSet* const resultset, const bool isOnRequest)
+{
+  resultset->updateRequestStatus(this, isOnRequest);
+}
+
+void RBAContent::updateStatus(RBAResultImpl* const result)
+{
+  result->updateStatus(this);
+}
+
+const std::list<const RBASize*>&
+RBAContent::getSizes() const
+{
+  static const std::list<const RBASize*> sizes;
+  return sizes;
+}
+
+}
diff --git a/src/core/model/RBAContent.hpp b/src/core/model/RBAContent.hpp
new file mode 100644
index 0000000..17e912c
--- /dev/null
+++ b/src/core/model/RBAContent.hpp
@@ -0,0 +1,87 @@
+/**
+ * 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.
+ */
+
+/**
+ * Content class header
+ */
+
+#ifndef RBACONTENT_HPP
+#define RBACONTENT_HPP
+
+#include <memory>
+#include <set>
+#include "RBAAbstractContent.hpp"
+#include "RBAAllocatableSet.hpp"
+#include "RBAContentLoserType.hpp"
+
+namespace rba
+{
+
+class RBAArbitrator;
+class RBAAllocatable;
+class RBAContentState;
+class RBAResultImpl;
+class RBAResultSet;
+class RBAExpression;
+class RBASize;
+
+class DLL_EXPORT RBAContent : public RBAAbstractContent
+{
+public:
+  explicit RBAContent(const std::string& name="");
+  RBAContent(const RBAContent&)=delete;
+  RBAContent(const RBAContent&&)=delete;
+  RBAContent& operator=(const RBAContent&)=delete;
+  RBAContent& operator=(const RBAContent&&)=delete;
+  virtual ~RBAContent()=default;
+
+public:
+  virtual bool isViewContent() const;
+  virtual bool isSoundContent() const;
+
+  const std::list<const RBAContentState*>& getStates() const;
+  void addState(const RBAContentState* const state);
+  const std::list<const RBAAllocatable*>& getAllocatables() const;
+  void addAllocatable(const RBAAllocatable* const alloc);
+  RBAContentLoserType getContentLoserType() const;
+  void setLoserType(const RBAContentLoserType newLoserType);
+  const RBAAllocatableSet* getAllocatableSet() const;
+  void updateRequestStatus(RBAResultSet* const resultset, const bool isOnRequest);
+  void updateStatus(RBAResultImpl* const result);
+  virtual const std::list<const RBASize*>& getSizes() const;
+
+#ifdef RBA_USE_LOG
+  virtual std::string getSymbol() const = 0;
+  virtual std::string getVisibleSymbol() const = 0;
+#endif
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::list<const RBAContentState*> states_;
+  std::unique_ptr<RBAAllocatableSet> allocatableSet_ {std::make_unique<RBAAllocatableSet>()};
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+  RBAContentLoserType loserType_ {RBAContentLoserType::DO_NOT_GIVEUP_UNTIL_WIN};
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContentMaker.cpp b/src/core/model/RBAContentMaker.cpp
new file mode 100644
index 0000000..a9828ba
--- /dev/null
+++ b/src/core/model/RBAContentMaker.cpp
@@ -0,0 +1,126 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAContentMaker.cpp
+/// @brief Content obecjt generator abstract class
+
+#include <iostream>
+#include "RBAContentMaker.hpp"
+#include "RBAContent.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAViewContentStateMaker.hpp"
+#include "RBASoundContentStateMaker.hpp"
+
+namespace rba
+{
+
+RBAContentMaker::RBAContentMaker(const std::string& label)
+  : RBARuleObjectMaker{label},
+    RBAAbstractContentMaker{label}
+{
+}
+
+RBAModelElement*
+RBAContentMaker::setProperty(RBAModelElement* element,
+                             const RBAJsonElement* jsonElem,
+                             RBAModelImpl* model,
+                             RBAModelElement* owner)
+{
+  static_cast<void>(RBAAbstractContentMaker::setProperty(element, jsonElem, model, owner));
+
+  RBAContent* const content {dynamic_cast<RBAContent*>(element)};
+
+  // loserType
+  const RBAJsonElement* const loserTypeElem {jsonElem->findChildren("loserType")};
+  if(loserTypeElem == nullptr) {
+    std::cerr << content->getElementName()
+              << ": loserType not found" << &std::endl;
+    return nullptr;
+  }
+  content->setLoserType(loserTypeElem->getLoserType());
+
+  // allocatable
+  for(auto& allocElem : jsonElem->findChildren("allocatable")->getChildren()) {
+    const auto str = allocElem->getName();
+    std::string allocName {""};
+    std::string className {""};
+    if (str.find(':') != std::string::npos) {
+      allocName = str.substr(0U, str.find(':'));
+      className = str.substr(str.find(':') + 1U);
+    } else {
+      allocName = str;
+    }
+
+    auto alloc = model->findAllocatable(allocName);
+    if (alloc == nullptr) {
+      alloc = dynamic_cast<RBAAllocatable*>(getMaker(className)->getInstance(model, allocName));
+    }
+    const_cast<RBAAllocatable*>(alloc)->addContent(content);
+    content->addAllocatable(alloc);
+  }
+
+  // state
+  if (content->isViewContent()) {
+    RBAViewContentStateMaker csMaker;
+    for(const auto& state : jsonElem->findChildren("states")->getChildren()) {
+      RBAModelElement* const s {csMaker.create(state.get(), model, content)};
+      content->addMember(dynamic_cast<RBARuleObject*>(s));
+      content->addState(dynamic_cast<RBAContentState*>(s));
+    }
+  }
+  else if (content->isSoundContent()) {
+    RBASoundContentStateMaker csMaker;
+    for(const auto& state : jsonElem->findChildren("states")->getChildren()) {
+      RBAModelElement* const s {csMaker.create(state.get(), model, content)};
+      content->addMember(dynamic_cast<RBARuleObject*>(s));
+      content->addState(dynamic_cast<RBAContentState*>(s));
+    }
+  }
+  // Expand Content
+  else {
+    auto alloc = content->getAllocatables().front();
+    // Seek until it becomes an Area or Zone
+    while (!alloc->isArea() && !alloc->isZone()) {
+      alloc = dynamic_cast<const RBAContent*>(alloc)->getAllocatables().front();
+    }
+    if (alloc->isArea()) {
+      RBAViewContentStateMaker csMaker;
+      for(const auto& state : jsonElem->findChildren("states")->getChildren()) {
+        RBAModelElement* const s {csMaker.create(state.get(), model, content)};
+        content->addMember(dynamic_cast<RBARuleObject*>(s));
+        content->addState(dynamic_cast<RBAContentState*>(s));
+      }
+    } else if (alloc->isZone()) {
+      RBASoundContentStateMaker csMaker;
+      for(const auto& state : jsonElem->findChildren("states")->getChildren()) {
+        RBAModelElement* const s {csMaker.create(state.get(), model, content)};
+        content->addMember(dynamic_cast<RBARuleObject*>(s));
+        content->addState(dynamic_cast<RBAContentState*>(s));
+      }
+    } else {
+      ;
+    }
+  }
+
+  model->addContent(content);
+
+  return content;
+}
+
+}
diff --git a/src/core/model/RBAContentMaker.hpp b/src/core/model/RBAContentMaker.hpp
new file mode 100644
index 0000000..5564fc1
--- /dev/null
+++ b/src/core/model/RBAContentMaker.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAContentMaker.hpp
+/// @brief Content obecjt generator class header
+
+#ifndef RBACONTENTMAKER_HPP
+#define RBACONTENTMAKER_HPP
+
+#include "RBAAbstractContentMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Content obecjt generator class
+class DLL_EXPORT RBAContentMaker : public RBAAbstractContentMaker
+{
+public:
+  explicit RBAContentMaker(const std::string& label="");
+  RBAContentMaker(const RBAContentMaker&)=delete;
+  RBAContentMaker(const RBAContentMaker&&)=delete;
+  RBAContentMaker& operator=(const RBAContentMaker&)=delete;
+  RBAContentMaker& operator=(const RBAContentMaker&&)=delete;
+  virtual ~RBAContentMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContentSet.cpp b/src/core/model/RBAContentSet.cpp
new file mode 100644
index 0000000..00da62e
--- /dev/null
+++ b/src/core/model/RBAContentSet.cpp
@@ -0,0 +1,66 @@
+/**
+ * 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.
+ */
+
+ /**
+ * ContentSet class
+ */
+
+#include <string>
+#include "RBAContentSet.hpp"
+#include "RBAContent.hpp"
+
+namespace rba
+{
+
+RBAContentSet::RBAContentSet(const std::string& name)
+  : RBARuleObject{name},
+    RBAAbstractContent{name}
+{
+}
+
+void
+RBAContentSet::addTarget(const RBAContent* content)
+{
+  leafContent_.push_back(content);
+#ifdef RBA_USE_LOG
+  std::string newName = "[";
+  for (auto& c : leafContent_) {
+    newName += c->getElementName() + ",";
+  }
+  if (newName.size() != 1U) {
+    newName.erase(newName.end() - 1);  // Remove the trailing ","
+  }
+  newName += "]";
+  setDynamicName(newName);
+#endif
+}
+
+void
+RBAContentSet::clear()
+{
+  leafContent_.clear();
+#ifdef RBA_USE_LOG
+  setDynamicName("[]");
+#endif
+}
+
+const std::list<const RBAContent*>&
+RBAContentSet::getLeafContent() const
+{
+  return leafContent_;
+}
+
+}
diff --git a/src/core/model/RBAContentSet.hpp b/src/core/model/RBAContentSet.hpp
new file mode 100644
index 0000000..3997f07
--- /dev/null
+++ b/src/core/model/RBAContentSet.hpp
@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+/**
+ * ContentSet class header
+ */
+
+#ifndef RBACONTENTSET_HPP
+#define RBACONTENTSET_HPP
+
+#include <list>
+#include "RBAAbstractContent.hpp"
+
+namespace rba
+{
+
+class RBAContent;
+
+class DLL_EXPORT RBAContentSet : public RBAAbstractContent
+{
+public:
+  explicit RBAContentSet(const std::string& name="");
+  RBAContentSet(const RBAContentSet&)=delete;
+  RBAContentSet(const RBAContentSet&&)=delete;
+  RBAContentSet& operator=(const RBAContentSet&)=delete;
+  RBAContentSet& operator=(const RBAContentSet&&)=delete;
+  virtual ~RBAContentSet()=default;
+
+public:
+  virtual void addTarget(const RBAContent* content);
+  virtual void clear();
+  const std::list<const RBAContent*>& getLeafContent() const;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::list<const RBAContent*> leafContent_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContentSetMaker.cpp b/src/core/model/RBAContentSetMaker.cpp
new file mode 100644
index 0000000..cbc8db9
--- /dev/null
+++ b/src/core/model/RBAContentSetMaker.cpp
@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+
+/// @file  RBAContentSetMaker.cpp
+/// @brief ContentSet object generator class
+
+#include "RBAContentSetMaker.hpp"
+#include "RBAContentSet.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBAContentSetMaker::RBAContentSetMaker(const std::string& label)
+  : RBARuleObjectMaker{label},
+    RBAAbstractContentMaker{label}
+{
+}
+
+RBAModelElement*
+RBAContentSetMaker::setProperty(RBAModelElement* element,
+                                const RBAJsonElement* jsonElem,
+                                RBAModelImpl* model,
+                                RBAModelElement* owner)
+{
+  static_cast<void>(RBAAbstractContentMaker::setProperty(element, jsonElem, model, owner));
+
+  const auto contentSet = dynamic_cast<RBAContentSet*>(element);
+
+  // content
+  for(const auto& content : jsonElem->findChildren("target")->getChildren()) {
+    const auto cont = model->findContent(content->getName());
+    contentSet->addTarget(cont);
+  }
+
+  return contentSet;
+}
+
+}
diff --git a/src/core/model/RBAContentSetMaker.hpp b/src/core/model/RBAContentSetMaker.hpp
new file mode 100644
index 0000000..182764c
--- /dev/null
+++ b/src/core/model/RBAContentSetMaker.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+/// @file  RBAContentSetMaker.hpp
+/// @brief ContentSet object generator class header
+
+#ifndef RBACONTENTSETMAKER_HPP
+#define RBACONTENTSETMAKER_HPP
+
+#include "RBAAbstractContentMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ContentSet object generator class
+class RBAContentSetMaker : public RBAAbstractContentMaker
+{
+public:
+  explicit RBAContentSetMaker(const std::string& label="");
+  RBAContentSetMaker(const RBAContentSetMaker&)=delete;
+  RBAContentSetMaker(const RBAContentSetMaker&&)=delete;
+  RBAContentSetMaker& operator=(const RBAContentSetMaker&)=delete;
+  RBAContentSetMaker& operator=(const RBAContentSetMaker&&)=delete;
+  virtual ~RBAContentSetMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContentState.cpp b/src/core/model/RBAContentState.cpp
new file mode 100644
index 0000000..f149129
--- /dev/null
+++ b/src/core/model/RBAContentState.cpp
@@ -0,0 +1,133 @@
+/**
+ * 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.
+ */
+]
+/**
+ * ContentState class
+ */
+
+#include <string>
+
+#include "RBAViewContentState.hpp"
+#include "RBAContent.hpp"
+#include "RBAContentState.hpp"
+
+namespace rba
+{
+
+RBAContentState::RBAContentState(const std::string& name)
+  : RBARuleObject{name}
+{
+}
+
+void
+RBAContentState::clearStatus()
+{
+  order_ = 0;
+}
+
+bool
+RBAContentState::isViewContentState() const
+{
+  return false;
+}
+
+bool
+RBAContentState::isSoundContentState() const
+{
+  return false;
+}
+
+std::string
+RBAContentState::getUniqueName() const
+{
+  return getOwner()->getElementName() + RBAViewContentState::CONTEXT_SEPARATER + getElementName();
+}
+
+std::int32_t
+RBAContentState::getContentStatePriority() const
+{
+  return priority_;
+}
+
+void
+RBAContentState::setPriority(const std::int32_t newPriority)
+{
+  priority_ = newPriority;
+}
+  
+std::int32_t
+RBAContentState::getContentStateOrder() const
+{
+  return order_;
+}
+
+void
+RBAContentState::setOrder(const std::int32_t newOrder)
+{
+  order_ = newOrder;
+}
+  
+bool
+RBAContentState::compareFirstComeFirst(const RBAContentState* const lhs,
+				       const RBAContentState* const rhs)
+{
+  return lhs->getContentStateOrder() < rhs->getContentStateOrder();
+}
+
+bool
+RBAContentState::compareLastComeFirst(const RBAContentState* const lhs,
+				      const RBAContentState* const rhs)
+{
+  return lhs->getContentStateOrder() > rhs->getContentStateOrder();
+}
+
+bool
+RBAContentState::comparePriorityFirstComeFirst(const RBAContentState* const lhs,
+					       const RBAContentState* const rhs)
+{
+  if(lhs->getContentStatePriority() == rhs->getContentStatePriority()) {
+    return compareFirstComeFirst(lhs, rhs);
+  }
+  else {
+    return lhs->getContentStatePriority() > rhs->getContentStatePriority();
+  }
+}
+
+bool
+RBAContentState::comparePriorityLastComeFirst(const RBAContentState* const lhs,
+					      const RBAContentState* const rhs)
+{
+  if(lhs->getContentStatePriority() == rhs->getContentStatePriority()) {
+    return compareLastComeFirst(lhs, rhs);
+  }
+  else {
+    return lhs->getContentStatePriority() > rhs->getContentStatePriority();
+  }
+}
+
+const std::string
+RBAContentState::getPriorityString() const
+{
+  return std::to_string(priority_);
+}
+
+const std::string
+RBAContentState::getOrderString() const
+{
+  return std::to_string(order_);
+}
+
+}
diff --git a/src/core/model/RBAContentState.hpp b/src/core/model/RBAContentState.hpp
new file mode 100644
index 0000000..7d4a81f
--- /dev/null
+++ b/src/core/model/RBAContentState.hpp
@@ -0,0 +1,74 @@
+/**
+ * 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.
+ */
+
+/**
+ * ContentState class header
+ */
+
+#ifndef RBACONTENTSTATE_HPP
+#define RBACONTENTSTATE_HPP
+
+#include <cstdint>
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAContentState : public RBARuleObject
+{
+protected:
+  explicit RBAContentState(const std::string& name);
+  RBAContentState(const RBAContentState&)=delete;
+  RBAContentState(const RBAContentState&&)=delete;
+  RBAContentState& operator=(const RBAContentState&)=delete;
+  RBAContentState& operator=(const RBAContentState&&)=delete;
+
+public:
+  virtual ~RBAContentState()=default;
+
+public:
+  void clearStatus() final;
+  virtual bool isViewContentState() const;
+  virtual bool isSoundContentState() const;
+
+  std::string getUniqueName() const override;
+  std::int32_t getContentStatePriority() const;
+  void setPriority(const std::int32_t newPriority);
+  std::int32_t getContentStateOrder() const;
+  void setOrder(const std::int32_t newOrder);
+
+  static bool compareFirstComeFirst(const RBAContentState* const lhs,
+				    const RBAContentState* const rhs);
+  static bool compareLastComeFirst(const RBAContentState* const lhs,
+				   const RBAContentState* const rhs);
+  static bool comparePriorityFirstComeFirst(const RBAContentState* const lhs,
+					    const RBAContentState* const rhs);
+  static bool comparePriorityLastComeFirst(const RBAContentState* const lhs,
+					   const RBAContentState* const rhs);
+
+  // Log
+  const std::string getPriorityString() const;
+  const std::string getOrderString() const;
+  
+private:
+  std::int32_t priority_ {0};
+  std::int32_t order_ {0};
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContentStateMaker.cpp b/src/core/model/RBAContentStateMaker.cpp
new file mode 100644
index 0000000..92129ef
--- /dev/null
+++ b/src/core/model/RBAContentStateMaker.cpp
@@ -0,0 +1,79 @@
+/**
+ * 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.
+ */
+/// @file  RBAContentStateMaker.cpp
+/// @brief ContentState object generator abstract class
+
+#include "RBAContentStateMaker.hpp"
+#include "RBAContentState.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAConstraintInfo.hpp"
+
+namespace rba
+{
+
+RBAContentStateMaker::RBAContentStateMaker(const std::string& label)
+  : RBARuleObjectMaker{label}
+{
+}
+
+RBAModelElement*
+RBAContentStateMaker::getInstance(RBAModelImpl* model,
+                                  const std::string& name,
+                                  RBAModelElement* owner)
+{
+  RBAModelElement* ret {nullptr};
+
+  const auto content = dynamic_cast<RBAContent*>(owner);
+  const auto uniqueName = content->getUniqueName() + "/" + name;
+
+  const auto element = model->findModelElement(uniqueName);
+  // exists in model
+  if(element != nullptr) {
+    ret = const_cast<RBAModelElement*>(element);
+  }
+  // not exists in modelmodel
+  else {
+    std::unique_ptr<RBAModelElement> inst {createInstance(name)};
+    const auto contentState = dynamic_cast<RBAContentState*>(inst.get());
+    contentState->setOwner(content);
+    ret =  model->addNamedElement(std::move(inst));
+  }
+
+  return ret;
+}
+
+RBAModelElement*
+RBAContentStateMaker::setProperty(RBAModelElement* element,
+                                  const RBAJsonElement* jsonElem,
+                                  RBAModelImpl* model,
+                                  RBAModelElement* owner)
+{
+  static_cast<void>(RBARuleObjectMaker::setProperty(element, jsonElem, model, owner));
+
+  RBAContentState* const state {dynamic_cast<RBAContentState*>(element)};
+
+  // Set priority
+  state->setPriority(jsonElem->findChildren("priority")->getInt());
+
+  model->addContentState(state);
+
+  return state;
+}
+
+}
diff --git a/src/core/model/RBAContentStateMaker.hpp b/src/core/model/RBAContentStateMaker.hpp
new file mode 100644
index 0000000..4082739
--- /dev/null
+++ b/src/core/model/RBAContentStateMaker.hpp
@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+/// @file  RBAContentStateMaker.hpp
+/// @brief ContentState object generator abstract class header
+
+#ifndef RBACONTENTSTATEMAKER_HPP
+#define RBACONTENTSTATEMAKER_HPP
+
+#include "RBARuleObjectMaker.hpp"
+
+namespace rba
+{
+
+/// @brief ContentState object generator abstract class
+class RBAContentStateMaker : public RBARuleObjectMaker
+{
+public:
+  explicit RBAContentStateMaker(const std::string& label);
+  RBAContentStateMaker(const RBAContentStateMaker&)=delete;
+  RBAContentStateMaker(const RBAContentStateMaker&&)=delete;
+  RBAContentStateMaker& operator=(const RBAContentStateMaker&)=delete;
+  RBAContentStateMaker& operator=(const RBAContentStateMaker&&)=delete;
+  virtual ~RBAContentStateMaker()=default;
+
+public:
+
+  RBAModelElement* getInstance(RBAModelImpl* model,
+                               const std::string& name="",
+                               RBAModelElement* owner=nullptr) override;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAContentStatusType.hpp b/src/core/model/RBAContentStatusType.hpp
new file mode 100644
index 0000000..d6cd161
--- /dev/null
+++ b/src/core/model/RBAContentStatusType.hpp
@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+//
+// State transition type of content
+//
+
+#ifndef RBACONTENTSTATUSTYPE_HPP
+#define RBACONTENTSTATUSTYPE_HPP
+
+namespace rba
+{
+
+enum class RBAContentStatusType : std::uint8_t
+{
+  NoRequest,
+  Undisplayed,
+  Displayed,
+  StandBy,
+  Canceled
+};
+}
+
+#endif /* RBACONTENTSTATUSTYPE_HPP */
diff --git a/src/core/model/RBAIntegerProperty.cpp b/src/core/model/RBAIntegerProperty.cpp
new file mode 100644
index 0000000..aeee3b0
--- /dev/null
+++ b/src/core/model/RBAIntegerProperty.cpp
@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+ /**
+ * Integer property class
+ */
+
+#include "RBAIntegerProperty.hpp"
+#include "RBASceneImpl.hpp"
+
+namespace rba
+{
+
+RBAIntegerProperty::RBAIntegerProperty(const RBASceneImpl* const scene,
+                                       const std::string& newName,
+                                       const std::int32_t newValue)
+  : RBAAbstractProperty{scene, newName},
+    value_{newValue}
+{
+}
+
+std::int32_t
+RBAIntegerProperty::getValue() const
+{
+  return value_;
+}
+
+#ifdef RBA_USE_LOG
+const std::string
+RBAIntegerProperty::getExpressionText() const
+{
+  return getScene()->getElementName() + "." + getElementName();
+}
+#endif
+
+}
diff --git a/src/core/model/RBAIntegerProperty.hpp b/src/core/model/RBAIntegerProperty.hpp
new file mode 100644
index 0000000..f174f0a
--- /dev/null
+++ b/src/core/model/RBAIntegerProperty.hpp
@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+ /**
+ * Integer property class header
+ */
+
+#ifndef RBAINTEGERPROPERTY_HPP
+#define RBAINTEGERPROPERTY_HPP
+
+#include "RBAAbstractProperty.hpp"
+
+namespace rba
+{
+
+class RBAIntegerProperty : public RBAAbstractProperty
+{
+public:
+  RBAIntegerProperty(const RBASceneImpl* const scene,
+                     const std::string& newName, const std::int32_t newValue);
+  RBAIntegerProperty(const RBAIntegerProperty&)=delete;
+  RBAIntegerProperty(const RBAIntegerProperty&&)=delete;
+  RBAIntegerProperty& operator=(const RBAIntegerProperty&)=delete;
+  RBAIntegerProperty& operator=(const RBAIntegerProperty&&)=delete;
+
+public:
+  std::int32_t getValue() const override;
+
+  // Log
+#ifdef RBA_USE_LOG
+  const std::string getExpressionText() const override;
+#endif
+
+private:
+  std::int32_t value_;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAModelElement.cpp b/src/core/model/RBAModelElement.cpp
new file mode 100644
index 0000000..b4308e5
--- /dev/null
+++ b/src/core/model/RBAModelElement.cpp
@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+/**
+ * ModelElment class
+ */
+
+#include "RBAModelElement.hpp"
+#include "RBAModelElementType.hpp"
+
+namespace rba
+{
+
+void RBAModelElement::clearStatus()
+{
+  // This function is called from a ModelElement that has no internal state 
+  // to clear.
+  // The overridden function is called from the ModelElement 
+  // that has the internal state to clear.
+}
+RBAModelElementType
+RBAModelElement::getModelElementType() const
+{
+  // This function is never called because the function of 
+  // the derived class is called.
+  return RBAModelElementType::None;
+}
+
+bool
+RBAModelElement::isModelElementType(const RBAModelElementType elemType) const
+{
+  return (elemType == getModelElementType());
+}
+
+}
diff --git a/src/core/model/RBAModelElement.hpp b/src/core/model/RBAModelElement.hpp
new file mode 100644
index 0000000..7ee7557
--- /dev/null
+++ b/src/core/model/RBAModelElement.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+/**
+ * ModelElment class header
+ */
+
+#ifndef RBAMODELELEMENT_HPP
+#define RBAMODELELEMENT_HPP
+
+#include <cstdint>
+#include "RBADllExport.hpp"
+
+namespace rba
+{
+
+enum class RBAModelElementType : std::uint8_t;
+
+class DLL_EXPORT RBAModelElement
+{
+protected:
+  RBAModelElement()=default;
+  RBAModelElement(const RBAModelElement&)=delete;
+  RBAModelElement(const RBAModelElement&&)=delete;
+  RBAModelElement& operator=(const RBAModelElement&)=delete;
+  RBAModelElement& operator=(const RBAModelElement&&)=delete;
+
+public:
+  virtual ~RBAModelElement()=default;
+
+public:
+  virtual void clearStatus();
+  virtual RBAModelElementType getModelElementType() const;
+  bool isModelElementType(const RBAModelElementType elemType) const;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAModelElementMaker.cpp b/src/core/model/RBAModelElementMaker.cpp
new file mode 100644
index 0000000..9d750c0
--- /dev/null
+++ b/src/core/model/RBAModelElementMaker.cpp
@@ -0,0 +1,122 @@
+/**
+ * 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.
+ */
+/// @file  RBAModelElementMaker.cpp
+/// @brief ModelElement object genartor abstract class
+
+#include "RBAModelElementMaker.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelFactory.hpp"
+#include "RBAModelImpl.hpp"
+
+namespace rba
+{
+
+std::unordered_map<std::string, std::unique_ptr<RBAModelElementMaker>> RBAModelElementMaker::makerMap_;
+
+RBAModelElementMaker::RBAModelElementMaker(const std::string& label)
+  : factory_{nullptr},
+    label_{label}
+{
+}
+
+void
+RBAModelElementMaker::setFactory(RBAModelFactory* const factory)
+{
+  factory_ = factory;
+}
+
+RBAModelFactory* RBAModelElementMaker::getFactory() const
+{
+  return factory_;
+}
+
+const std::string&
+RBAModelElementMaker::getLabel() const
+{
+  return label_;
+}
+
+RBAModelElement*
+RBAModelElementMaker::create(const RBAJsonElement* jsonElem,
+                             RBAModelImpl* model,
+                             RBAModelElement* owner)
+{
+  const auto nameElement = jsonElem->findChildren("name");
+
+  RBAModelElement* element {nullptr};
+  if (nameElement != nullptr) {
+    element = getInstance(model, nameElement->getString(), owner);
+  } else {
+    element = getInstance(model, "", owner);
+  }
+
+  return setProperty(element, jsonElem, model, owner);
+}
+
+RBAModelElement*
+RBAModelElementMaker::getInstance(RBAModelImpl* model,
+                                  const std::string& name,
+                                  RBAModelElement* owner)
+{
+  RBAModelElement* ret {nullptr};
+
+  // If there is a class name, delete the class name
+  std::string fullName {name};
+  while (fullName.find(':') != std::string::npos) {
+    const auto start = fullName.find(':');
+    const auto end = fullName.find('/', start);
+    static_cast<void>(fullName.erase(start, end - start));
+  }
+
+  // In case of Elemetn with name
+ 　 if(fullName != "") {
+    const auto elem = model->findModelElement(fullName);
+    // exists in model
+    if(elem != nullptr) {
+      ret = const_cast<RBAModelElement*>(elem);
+    }
+    // not exists in model
+    else {
+      std::unique_ptr<RBAModelElement> inst {createInstance(fullName)};
+      ret = model->addNamedElement(std::move(inst));
+    }
+  }
+  // In case of Elemetn without name
+  else {
+    std::unique_ptr<RBAModelElement> inst {createInstance()};
+    ret = model->addModelElement(std::move(inst));
+  }
+  
+  return ret;
+}
+
+void
+RBAModelElementMaker::addMaker(const std::string& typeName, std::unique_ptr<RBAModelElementMaker> maker)
+{
+  makerMap_[typeName] = std::move(maker);
+}
+
+RBAModelElementMaker*
+RBAModelElementMaker::getMaker(const std::string& typeName)
+{
+  if (makerMap_.find(typeName) == makerMap_.end()) {
+    return nullptr;
+  }
+  return makerMap_[typeName].get();
+}
+
+}
diff --git a/src/core/model/RBAModelElementMaker.hpp b/src/core/model/RBAModelElementMaker.hpp
new file mode 100644
index 0000000..c038f5a
--- /dev/null
+++ b/src/core/model/RBAModelElementMaker.hpp
@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+/// @file  RBAModelElementMaker.hpp
+/// @brief ModelElement object genartor abstract class header
+
+#ifndef RBAMODELELEMENTMAKER_HPP
+#define RBAMODELELEMENTMAKER_HPP
+
+#include <memory>
+#include <string>
+#include "RBADllExport.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+class RBAModelElement;
+class RBAJsonElement;
+class RBAModelImpl;
+
+/// @brief  ModelElement object genartor abstract class
+class DLL_EXPORT RBAModelElementMaker
+{
+public:
+  /// @brief Constructor that specifies the label
+  /// @details Set label and generate
+  /// @param[in] label labe to set
+  RBAModelElementMaker()=default;
+  explicit RBAModelElementMaker(const std::string& label);
+  virtual ~RBAModelElementMaker()=default;
+
+protected:
+  RBAModelElementMaker(const RBAModelElementMaker& maker)=delete;
+  RBAModelElementMaker& operator=(const RBAModelElementMaker& maker)=delete;
+  // Use "move" in RBAAbstractModelTable::addMaker()
+  RBAModelElementMaker(RBAModelElementMaker&&)=default;
+  RBAModelElementMaker& operator=(RBAModelElementMaker&&)=default;
+
+public:
+  /// @brief Set model factory
+  /// @param[in] factory model factory
+  void setFactory(RBAModelFactory* const factory);
+
+  /// @brief Get label
+  /// @details Returns the label of the corresponding JSON element
+  /// @return Label string
+  const std::string& getLabel() const;
+
+  /// @brief Create ModelElement object
+  /// @details create ModelElement object and register unique_ptr to model
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The moder to store created object
+  /// @param[in,out] owner Parent object (Not in use)
+  /// @return ModelElement object
+  virtual RBAModelElement* create(const RBAJsonElement* jsonElem,
+                                  RBAModelImpl* model,
+                                  RBAModelElement* owner=nullptr);
+
+  /// @brief Get instance
+  /// @details Get the element corresponding to name from model.
+  ///          If there is no name or it is not in model, 
+  ///          create an instance and register it in model.
+  /// @return ModelElement object
+  virtual RBAModelElement* getInstance(RBAModelImpl* model,
+                                       const std::string& name="",
+                                       RBAModelElement* owner=nullptr);
+
+  /// @brief Register Maker
+  /// @details Register the Maker corresponding to the class name 
+  ///          used in JSON in the map
+  /// @return void
+  static void addMaker(const std::string& typeName, 
+                        std::unique_ptr<RBAModelElementMaker> maker);
+
+  /// @brief Get Maker
+  /// @details Get the Maker corresponding to the class name from the map
+  /// @return Corresponding Maker. If it doesn't exist, return null.
+  static RBAModelElementMaker* getMaker(const std::string& typeName);
+
+protected:
+  /// @brief Create an empty instance
+  /// @details Create an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for instance
+  virtual std::unique_ptr<RBAModelElement> createInstance(const std::string& name="")=0;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  virtual RBAModelElement* setProperty(RBAModelElement* element,
+                                       const RBAJsonElement* jsonElem,
+                                       RBAModelImpl* model,
+                                       RBAModelElement* owner=nullptr)=0;
+
+  /// @brief Get model factory
+  /// @details Get model factory
+  /// @return model factory
+  RBAModelFactory* getFactory() const;
+
+private:
+  /// @brief Factory for recursively generating objects
+  RBAModelFactory* factory_;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  /// @brief Label of corresponding JSON element
+  const std::string label_;
+
+  /// @brief Correspondence map of each Maker and the character string that 
+  ///        represents the class used in JSON
+  static std::unordered_map<std::string, std::unique_ptr<RBAModelElementMaker>> makerMap_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAModelElementType.hpp b/src/core/model/RBAModelElementType.hpp
new file mode 100644
index 0000000..756f22b
--- /dev/null
+++ b/src/core/model/RBAModelElementType.hpp
@@ -0,0 +1,116 @@
+/**
+ * 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.
+ */
+/**
+ * ModelElementType class header
+ */
+
+#ifndef RBAMODELELEMENTTYPE_HPP
+#define RBAMODELELEMENTTYPE_HPP
+
+namespace rba
+{
+
+enum class RBAModelElementType : std::uint8_t
+{
+  AllInstanceOfArea,
+  AllInstanceOfViewContent,
+  AllInstanceOfZone,
+  AllInstanceOfSoundContent,
+  Allocatable,
+  AllocatedContent,
+  AndOperator,
+  Area,
+  AreaSet,
+  ArithmeticOperator,
+  Constraint,
+  ViewContent,
+  ViewContentSet,
+  ViewContentState,
+  ContentValue,
+  DisplayingContent,
+  ExistsOperator,
+  ForAllOperator,
+  GetAllocatables,
+  ActiveState,
+  ActiveContents,
+  GetContentsList,
+  IfStatement,
+  IfActionOperator,
+  ImpliesOperator,
+  IntegerValue,
+  IsActive,
+  IsDisplayed,
+  IsEqualToOperator,
+  IsGreaterThanEqualOperator,
+  IsGreaterThanOperator,
+  IsHidden,
+  IsLowerThanEqualOperator,
+  IsLowerThanOperator,
+  IsVisible,
+  LambdaContext,
+  LambdaExpression,
+  LetStatement,
+  NotOperator,
+  ObjectCompare,
+  ObjectReference,
+  MemberFeatureReference,
+  OrOperator,
+  PlusOperator,
+  PreviousModifier,
+  RuleObject,
+  Scene,
+  Property,
+  SetExpression,
+  SetOfOperator,
+  SetOperator,
+  ValueExpression,
+  Variable,
+  IsOn,
+  Zone,
+  ZoneSet,
+  SoundContent,
+  SoundContentSet,
+  SoundContentState,
+  IsAttenuated,
+  IsOutputted,
+  IsMuted,
+  IsSounding,
+  Rule,
+  OnScene,
+  OffScene,
+  GetProperty,
+  SetProperty,
+  IntegerProperty,
+  OutputtingSound,
+  StateValue,
+  HasBeenCanceled,
+  HasBeenDisplayed,
+  HasComeEarlier,
+  HasComeLater,
+  EventProcessing,
+  MaxOperator,
+  MinOperator,
+  SelectOperator,
+  SizeOperator,
+  Undisplayed,
+  IsTypeOfOperator,
+  Displayed,
+  None
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBAModelImpl.cpp b/src/core/model/RBAModelImpl.cpp
new file mode 100644
index 0000000..081607c
--- /dev/null
+++ b/src/core/model/RBAModelImpl.cpp
@@ -0,0 +1,823 @@
+/**
+ * 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.
+ */
+/// @file  RBAModelmpl.cpp
+/// @brief Model implementation class 
+
+#include "RBAModelImpl.hpp"
+#include "RBAConstraintImpl.hpp"
+
+namespace rba
+{
+
+const RBAContentState*
+RBAModelImpl::findContentState(const std::string& stateName)
+{
+  const auto elem = findModelElementImpl(stateName);
+  auto contentState = dynamic_cast<const RBAContentState*>(elem);
+  if (contentState == nullptr) {
+    const auto content = dynamic_cast<const RBAContent*>(elem);
+    if (content != nullptr) {
+      contentState = content->getStates().front();
+    }
+  }
+  return contentState;
+}
+  
+const RBAArea*
+RBAModelImpl::findArea(const std::string& areaName) const
+{
+  return findAreaImpl(areaName);
+}
+  
+const RBAViewContent*
+RBAModelImpl::findViewContent(const std::string& contName) const
+{
+  return findViewContentImpl(contName);
+}
+  
+const RBAViewContentState*
+RBAModelImpl::findViewContentState(const std::string& stateName) const
+{
+  return findViewContentStateImpl(stateName);
+}
+  
+const RBASize*
+RBAModelImpl::findSize(const std::string& sizeName) const
+{
+  return findSizeImpl(sizeName);
+}
+  
+const RBAZone*
+RBAModelImpl::findZone(const std::string& zoneName) const
+{
+  return findZoneImpl(zoneName);
+}
+  
+const RBASoundContent*
+RBAModelImpl::findSoundContent(const std::string& contName) const
+{
+  return findSoundContentImpl(contName);
+}
+  
+const RBASoundContentState*
+RBAModelImpl::findSoundContentState(const std::string& stateName) const
+{
+  return findSoundContentStateImpl(stateName);
+}
+  
+const RBAScene*
+RBAModelImpl::findScene(const std::string& sceneName) const
+{
+  return findSceneImpl(sceneName);
+}
+
+const RBADisplay*
+RBAModelImpl::findDisplay(const std::string& displayName) const
+{
+  return findDisplayImpl(displayName);
+}
+
+const RBAModelElement*
+RBAModelImpl::findModelElement(const std::string& elementName) const
+{
+  return findModelElementImpl(elementName);
+}
+
+const std::list<const RBAArea*>&
+RBAModelImpl::getAreas() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAArea is the base class of RBAAreaImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBAArea*>&>(getAreaImpls());
+}
+
+const std::list<const RBAViewContent*>&
+RBAModelImpl::getViewContents() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAViewContent is the base class of 
+  //  RBAViewContentImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBAViewContent*>&>(getViewContentImpls());
+}
+  
+const std::list<const RBAViewContentState*>&
+RBAModelImpl::getViewContentStates() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAViewContentState is the base class of 
+  //  RBAViewContentStateImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBAViewContentState*>&>(getViewContentStateImpls());
+}
+  
+const std::list<const RBASize*>&
+RBAModelImpl::getSizes() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBASize is the base class of RBASizeImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBASize*>&>(getSizeImpls());
+}
+
+const std::list<const RBAZone*>&
+RBAModelImpl::getZones() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAZone is the base class of RBAZoneImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBAZone*>&>(getZoneImpls());
+}
+
+const std::list<const RBASoundContent*>&
+RBAModelImpl::getSoundContents() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBASoundContent is the base class of 
+  //  RBASoundContentImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBASoundContent*>&>(getSoundContentImpls());
+}
+  
+const std::list<const RBASoundContentState*>&
+RBAModelImpl::getSoundContentStates() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBASoundContentState is the base class of 
+  //  RBASoundContentStateImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBASoundContentState*>&>(getSoundContentStateImpls());
+}
+  
+const std::list<const RBAScene*>&
+RBAModelImpl::getScenes() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAScene is the base class of 
+  //  RBASceneImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBAScene*>&>(getSceneImpls());
+}
+
+const std::list<const RBAAreaSet*>&
+RBAModelImpl::getAreaSets() const
+{
+  return getAreaSetImpls();
+}
+
+const std::list<const RBAViewContentSet*>&
+RBAModelImpl::getViewContentSets() const
+{
+  return getViewContentSetImpls();
+}
+
+const std::list<const RBAZoneSet*>&
+RBAModelImpl::getZoneSets() const
+{
+  return getZoneSetImpls();
+}
+
+const std::list<const RBASoundContentSet*>&
+RBAModelImpl::getSoundContentSets() const
+{
+  return getSoundContentSetImpls();
+}
+
+const std::list<const RBAPositionContainer*>&
+RBAModelImpl::getPositionContainers() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAPositionContainer is the base class of 
+  //  RBAPositionContainerImpl.
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBAPositionContainer*>&>(getPositionContainerImpls());
+}
+
+const std::list<const RBADisplay*>&
+RBAModelImpl::getDisplays() const
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBADisplay is the base class of RBADisplayImpl. 
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<const std::list<const RBADisplay*>&>(getDisplayImpls());
+}
+
+std::list<RBAConstraint*>&
+RBAModelImpl::getConstraints()
+{
+  // @Deviation (A5-2-4)
+  // [Contents that deviate from the rules]
+  //  reinterpret_cast shall not be used.
+  // [Reason that there is no problem if the rule is deviated]
+  //  There is no problem because RBAConstraint is the base class of 
+  //  RBAConstraintImpl. 
+  //  Since the conversion process is costly, it deviates because it hides 
+  //  the internal structure.
+  return reinterpret_cast<std::list<RBAConstraint*>&>(getConstraintImpls());
+}
+
+void RBAModelImpl::clearElementsStatus()
+{
+  for (auto& o : unnamedObjects_) {
+    o->clearStatus();
+  }
+  for (auto& o : nameToObject_) {
+    o.second->clearStatus();
+  }
+}
+
+const RBAAllocatable*
+RBAModelImpl::findAllocatable(const std::string& allocatableName) const
+{
+  auto it = nameToObject_.find(allocatableName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAAllocatable*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAContent*
+RBAModelImpl::findContent(const std::string& contentName) const
+{
+  auto it = nameToObject_.find(contentName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAContent*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAAreaImpl*
+RBAModelImpl::findAreaImpl(const std::string& areaName) const
+{
+  auto it = nameToObject_.find(areaName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAAreaImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+  
+const RBAViewContentImpl*
+RBAModelImpl::findViewContentImpl(const std::string& contName) const
+{
+  auto it = nameToObject_.find(contName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAViewContentImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+  
+const RBAViewContentStateImpl*
+RBAModelImpl::findViewContentStateImpl(const std::string& stateName) const
+{
+  const RBAViewContentStateImpl* ret {nullptr};
+  if(RBAViewContentState::isUniqueName(stateName)) {
+    auto it = nameToObject_.find(stateName);
+    if(it != nameToObject_.end()) {
+      ret = dynamic_cast<const RBAViewContentStateImpl*>(it->second.get());
+    }
+  }
+  else {
+    const RBAViewContentImpl* const content {findViewContentImpl(stateName)};
+    if(content != nullptr) {
+      const RBAContentState* const state {content->getStates().front()};
+      ret = dynamic_cast<const RBAViewContentStateImpl*>(state);
+    }
+  }
+
+  return ret;
+}
+  
+const RBASizeImpl*
+RBAModelImpl::findSizeImpl(const std::string& sizeName) const
+{
+  auto it = nameToObject_.find(sizeName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBASizeImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+  
+const RBAZoneImpl*
+RBAModelImpl::findZoneImpl(const std::string& zoneName) const
+{
+  auto it = nameToObject_.find(zoneName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAZoneImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+  
+const RBASoundContentImpl*
+RBAModelImpl::findSoundContentImpl(const std::string& contName) const
+{
+  auto it = nameToObject_.find(contName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBASoundContentImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+  
+const RBASoundContentStateImpl*
+RBAModelImpl::findSoundContentStateImpl(const std::string& stateName) const
+{
+  const RBASoundContentStateImpl* ret {nullptr};
+  if(RBASoundContentState::isUniqueName(stateName)) {
+    auto it = nameToObject_.find(stateName);
+    if(it != nameToObject_.end()) {
+      ret = dynamic_cast<const RBASoundContentStateImpl*>(it->second.get());
+    }
+  }
+  else {
+    const RBASoundContentImpl* const content {findSoundContentImpl(stateName)};
+    if(content != nullptr) {
+      const RBAContentState* const state {content->getStates().front()};
+      ret = dynamic_cast<const RBASoundContentStateImpl*>(state);
+    }
+  }
+
+  return ret;
+}
+  
+const RBASceneImpl*
+RBAModelImpl::findSceneImpl(const std::string& sceneName) const
+{
+  auto it = nameToObject_.find(sceneName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBASceneImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBADisplayImpl*
+RBAModelImpl::findDisplayImpl(const std::string& displayName) const
+{
+  auto it = nameToObject_.find(displayName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBADisplayImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAModelElement*
+RBAModelImpl::findModelElementImpl(const std::string& elementName) const
+{
+  auto it = nameToObject_.find(elementName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAModelElement*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const std::list<const RBAAllocatable*>&
+RBAModelImpl::getAllocatables() const
+{
+  return allocatables_;
+}
+
+const std::list<const RBAContent*>&
+RBAModelImpl::getContents() const
+{
+  return contents_;
+}
+
+const std::list<const RBAContentState*>&
+RBAModelImpl::getContentStates() const
+{
+  return contentStates_;
+}
+
+const std::list<const RBAAreaImpl*>&
+RBAModelImpl::getAreaImpls() const
+{
+  return areas_;
+}
+
+const std::list<const RBAViewContentImpl*>&
+RBAModelImpl::getViewContentImpls() const
+{
+  return viewContents_;
+}
+  
+const std::list<const RBAViewContentStateImpl*>&
+RBAModelImpl::getViewContentStateImpls() const
+{
+  return viewContentStates_;
+}
+  
+const std::list<const RBASizeImpl*>&
+RBAModelImpl::getSizeImpls() const
+{
+  return sizes_;
+}
+
+const std::list<const RBAZoneImpl*>&
+RBAModelImpl::getZoneImpls() const
+{
+  return zones_;
+}
+
+const std::list<const RBASoundContentImpl*>&
+RBAModelImpl::getSoundContentImpls() const
+{
+  return soundContents_;
+}
+  
+const std::list<const RBASoundContentStateImpl*>&
+RBAModelImpl::getSoundContentStateImpls() const
+{
+  return soundContentStates_;
+}
+
+const std::list<const RBASceneImpl*>&
+RBAModelImpl::getSceneImpls() const
+{
+  return scenes_;
+}
+
+const std::list<const RBAPositionContainerImpl*>&
+RBAModelImpl::getPositionContainerImpls() const
+{
+  return positionContainers_;
+}
+
+const std::list<const RBADisplayImpl*>&
+RBAModelImpl::getDisplayImpls() const
+{
+  return displays_;
+}
+
+void
+RBAModelImpl::createSortedAllocatables()
+{
+  if(!(sortedAllocatables_.empty())) {
+    sortedAllocatables_.clear();
+  }
+
+  for(auto& alloc : allocatables_) {
+    sortedAllocatables_.push_back(const_cast<RBAAllocatable*>(alloc));
+  }
+  sortedAllocatables_.sort(&RBAAllocatable::compare);
+
+  std::int32_t index{0};
+  for(RBAAllocatable* const allocatable : sortedAllocatables_) {
+    allocatable->setIndex(index);
+    index++;
+  }
+}
+
+std::list<RBAAllocatable*>&
+RBAModelImpl::getSortedAllocatables()
+{
+  return sortedAllocatables_;
+}
+
+RBAConstraintImpl*
+RBAModelImpl::findConstraintImpl(const std::string& consName) const
+{
+  auto it = nameToObject_.find(consName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<RBAConstraintImpl*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAAreaSet*
+RBAModelImpl::findAreaSetImpl(const std::string& areaSetName) const
+{
+  auto it = nameToObject_.find(areaSetName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAAreaSet*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAZoneSet*
+RBAModelImpl::findZoneSetImpl(const std::string& zoneSetName) const
+{
+  auto it = nameToObject_.find(zoneSetName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAZoneSet*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAViewContentSet*
+RBAModelImpl::findViewContentSetImpl(const std::string& contSetName) const
+{
+  auto it = nameToObject_.find(contSetName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBAViewContentSet*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBASoundContentSet*
+RBAModelImpl::findSoundContentSetImpl(const std::string& contSetName) const
+{
+  auto it = nameToObject_.find(contSetName);
+  if(it != nameToObject_.end()) {
+    return dynamic_cast<const RBASoundContentSet*>(it->second.get());
+  }
+
+  return nullptr;
+}
+
+const RBAPositionContainerImpl*
+RBAModelImpl::findPositionContainerImpl(const std::string& areaName) const
+{
+  auto it = areaNameToPositionContainer_.find(areaName);
+  if(it != areaNameToPositionContainer_.end()) {
+    return dynamic_cast<const RBAPositionContainerImpl*>(it->second);
+  }
+
+  return nullptr;
+}
+
+/*
+ * get list functions
+ */
+
+std::list<const RBAConstraintImpl*>&
+RBAModelImpl::getConstraintImpls()
+{
+  return constraints_;
+}
+
+const std::list<const RBAAreaSet*>&
+RBAModelImpl::getAreaSetImpls() const
+{
+  return areaSets_;
+}
+
+const std::list<const RBAZoneSet*>&
+RBAModelImpl::getZoneSetImpls() const
+{
+  return zoneSets_;
+}
+
+const std::list<const RBAViewContentSet*>&
+RBAModelImpl::getViewContentSetImpls() const
+{
+  return viewContentSets_;
+}
+
+const std::list<const RBASoundContentSet*>&
+RBAModelImpl::getSoundContentSetImpls() const
+{
+  return soundContentSets_;
+}
+
+RBAModelElement*
+RBAModelImpl::addModelElement(std::unique_ptr<RBAModelElement> newElement)
+{
+  RBAModelElement* const element {newElement.get()};
+  unnamedObjects_.push_back(std::move(newElement));
+  return element;
+}
+
+RBANamedElement*
+RBAModelImpl::addNamedElement(std::unique_ptr<RBAModelElement> newElement)
+{
+  RBANamedElement* const element {dynamic_cast<RBANamedElement*>(newElement.get())};
+  nameToObject_[element->getUniqueName()] = std::move(newElement);
+  return element;
+}
+
+void
+RBAModelImpl::addAllocatable(const RBAAllocatable* newAlloc)
+{
+  allocatables_.push_back(newAlloc);
+  if(newAlloc->isArea()) {
+    areas_.push_back(dynamic_cast<const RBAAreaImpl*>(newAlloc));
+  }
+  else if (newAlloc->isZone()) {
+    zones_.push_back(dynamic_cast<const RBAZoneImpl*>(newAlloc));
+  } else {
+    ;
+  }
+}
+
+void
+RBAModelImpl::addContent(const RBAContent* newContent)
+{
+  contents_.push_back(newContent);
+  if(newContent->isViewContent()) {
+    viewContents_.push_back(dynamic_cast<const RBAViewContentImpl*>(newContent));
+  }
+  else if (newContent->isSoundContent()) {
+    soundContents_.push_back(dynamic_cast<const RBASoundContentImpl*>(newContent));
+  } else {
+    ;
+  }
+}
+
+void
+RBAModelImpl::addContentState(const RBAContentState* newState)
+{
+  contentStates_.push_back(newState);
+  if(newState->isViewContentState()) {
+    viewContentStates_.push_back(dynamic_cast<const RBAViewContentStateImpl*>(newState));
+  }
+  else {
+    soundContentStates_.push_back(dynamic_cast<const RBASoundContentStateImpl*>(newState));
+  }
+}
+
+void
+RBAModelImpl::addAreaSet(const RBAAreaSet* newAreaSet)
+{
+  areaSets_.push_back(newAreaSet);
+}
+
+void
+RBAModelImpl::addZoneSet(const RBAZoneSet* newZoneSet)
+{
+  zoneSets_.push_back(newZoneSet);
+}
+
+void
+RBAModelImpl::addConstraint(const RBAConstraintImpl* newConstraint)
+{
+  constraints_.push_back(newConstraint);
+}
+
+void
+RBAModelImpl::addViewContentSet(const RBAViewContentSet* newContentSet)
+{
+  viewContentSets_.push_back(newContentSet);
+}
+
+void
+RBAModelImpl::addSoundContentSet(const RBASoundContentSet* newContentSet)
+{
+  soundContentSets_.push_back(newContentSet);
+}
+
+void
+RBAModelImpl::addScene(const RBASceneImpl* newScene)
+{
+  scenes_.push_back(newScene);
+}
+
+RBASizeImpl*
+RBAModelImpl::addSizeInstance(const std::string& ownerName,
+                              std::unique_ptr<RBAModelElement> newSize)
+{
+  RBASizeImpl* sizeImpl {dynamic_cast<RBASizeImpl*>(newSize.get())};
+  sizes_.push_back(sizeImpl);
+  nameToObject_[ownerName+std::string("/")+sizeImpl->getName()]
+    = std::move(newSize);
+  return sizeImpl;
+}
+
+void
+RBAModelImpl::addPositionContainer(const RBAPositionContainerImpl* newPositionContainer)
+{
+  positionContainers_.push_back(newPositionContainer);
+  areaNameToPositionContainer_[newPositionContainer->getArea()->getName()]
+    = newPositionContainer;
+}
+
+void
+RBAModelImpl::addDisplay(const RBADisplayImpl* newDisplay)
+{
+  displays_.push_back(newDisplay);
+}
+
+void
+RBAModelImpl::addLabeledElement(const std::string& label,
+                                RBAModelElement* element)
+{
+  labelToElements_[label].push_back(element);
+}
+
+void
+RBAModelImpl::addLabeledConstraint(const std::string& label,
+                                   RBAAbstractConstraint* constraint)
+{
+  labelToConstraints_[label].push_back(constraint);
+}
+
+const std::list<const RBAModelElement*>
+RBAModelImpl::getLabeledElements(const std::string& label) const
+{
+  auto it = labelToElements_.find(label);
+  if(it != labelToElements_.end()) {
+    return it->second;
+  }
+
+  const std::list<const RBAModelElement*> emp;
+  return emp;
+}
+
+const std::list<RBAAbstractConstraint*>
+RBAModelImpl::getLabeledConstraints(const std::string& label) const
+{
+  auto it = labelToConstraints_.find(label);
+  if(it != labelToConstraints_.end()) {
+    return it->second;
+  }
+
+  const std::list<RBAAbstractConstraint*> emp;
+  return emp;
+}
+
+const RBAModelElement*
+RBAModelImpl::findLabeledElement(const std::string& label,
+                                 const std::string& name) const
+{
+  const std::list<const RBAModelElement*> elems {getLabeledElements(label)};
+  for(const RBAModelElement* const elem : elems) {
+    if(dynamic_cast<const RBANamedElement*>(elem)->getElementName() == name) {
+      return elem;
+    }
+  }
+
+  return nullptr;
+}
+
+void
+RBAModelImpl::addAffectedAllocsMap(const RBAModelElement* const owner, RBAAllocatable* const alloc)
+{
+  affectedAllocsMap_[owner].push_back(alloc);
+}
+
+const std::list<RBAAllocatable*>*
+RBAModelImpl::getAffectedAllocs(const RBAModelElement* const owner)
+{
+  auto itr = affectedAllocsMap_.find(owner);
+  if (itr != affectedAllocsMap_.end()) {
+    return &itr->second;
+  }
+  return nullptr;
+}
+
+}
diff --git a/src/core/model/RBAModelImpl.hpp b/src/core/model/RBAModelImpl.hpp
new file mode 100644
index 0000000..5773506
--- /dev/null
+++ b/src/core/model/RBAModelImpl.hpp
@@ -0,0 +1,221 @@
+/**
+ * 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.
+ */
+/// @file  RBAModelImplhpp
+/// @brief Model implementaion class header
+
+#ifndef RBAMODELIMPL_HPP
+#define RBAMODELIMPL_HPP
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "RBAAreaImpl.hpp"
+#include "RBAConstraintImpl.hpp"
+#include "RBADisplayImpl.hpp"
+#include "RBAExpression.hpp"
+#include "RBAModel.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAPositionContainerImpl.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBASizeImpl.hpp"
+#include "RBASoundContentImpl.hpp"
+#include "RBASoundContentStateImpl.hpp"
+#include "RBAVariable.hpp"
+#include "RBAViewContentImpl.hpp"
+#include "RBAViewContentStateImpl.hpp"
+#include "RBAZoneImpl.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBAModelImpl : public RBAModel
+{
+public:
+  RBAModelImpl()=default;
+  RBAModelImpl(const RBAModelImpl&)=delete;
+  RBAModelImpl(const RBAModelImpl&&)=delete;
+  RBAModelImpl& operator=(const RBAModelImpl&)=delete;
+  RBAModelImpl& operator=(const RBAModelImpl&&)=delete;
+  virtual ~RBAModelImpl()=default;
+
+public:
+  const RBAArea* findArea(const std::string& areaName) const override;
+  const RBAViewContent* findViewContent(const std::string& contName) const override;
+  const RBAViewContentState* findViewContentState(const std::string& stateName) const override;
+  const RBASize* findSize(const std::string& sizeName) const override;
+  const RBAZone* findZone(const std::string& zoneName) const override;
+  const RBASoundContent* findSoundContent(const std::string& contName) const override;
+  const RBASoundContentState* findSoundContentState(const std::string& stateName) const override;
+  const RBAScene* findScene(const std::string& sceneName) const override;
+  const RBADisplay* findDisplay(const std::string& displayName) const override;
+  const RBAModelElement* findModelElement(const std::string& elementName) const override;
+
+  const std::list<const RBAArea*>& getAreas() const override;
+  const std::list<const RBAViewContent*>& getViewContents() const override;
+  const std::list<const RBAViewContentState*>& getViewContentStates() const override;
+  const std::list<const RBASize*>& getSizes() const override;
+  const std::list<const RBAZone*>& getZones() const override;
+  const std::list<const RBASoundContent*>& getSoundContents() const override;
+  const std::list<const RBASoundContentState*>& getSoundContentStates() const override;
+  const std::list<const RBAScene*>& getScenes() const override;
+  const std::list<const RBAAreaSet*>& getAreaSets() const override;
+  const std::list<const RBAViewContentSet*>& getViewContentSets() const override;
+  virtual const std::list<const RBAZoneSet*>& getZoneSets() const;
+  virtual const std::list<const RBASoundContentSet*>& getSoundContentSets() const;
+  const std::list<const RBAPositionContainer*>& getPositionContainers() const override;
+  const std::list<const RBADisplay*>& getDisplays() const override;
+  std::list<RBAConstraint*>& getConstraints() override;
+
+  virtual void clearElementsStatus();
+  virtual const RBAContentState* findContentState(const std::string& stateName);
+  const RBAAllocatable* findAllocatable(const std::string& allocatableName) const;
+  const RBAContent* findContent(const std::string& contentName) const;
+  virtual const RBAAreaImpl* findAreaImpl(const std::string& areaName) const;
+  virtual const RBAViewContentImpl* findViewContentImpl(const std::string& contName) const;
+  virtual const RBAViewContentStateImpl* findViewContentStateImpl(const std::string& stateName) const;
+  virtual const RBASizeImpl* findSizeImpl(const std::string& sizeName) const;
+  virtual const RBAZoneImpl* findZoneImpl(const std::string& zoneName) const;
+  virtual const RBASoundContentImpl* findSoundContentImpl(const std::string& contName) const;
+  virtual const RBASoundContentStateImpl* findSoundContentStateImpl(const std::string& stateName) const;
+  virtual const RBASceneImpl* findSceneImpl(const std::string& sceneName) const;
+  virtual const RBADisplayImpl* findDisplayImpl(const std::string& displayName) const;
+  virtual const RBAModelElement* findModelElementImpl(const std::string& elementName) const;
+
+  virtual const std::list<const RBAAllocatable*>& getAllocatables() const;
+  virtual const std::list<const RBAContent*>&  getContents() const;
+  virtual const std::list<const RBAContentState*>& getContentStates() const;
+
+  virtual const std::list<const RBAAreaImpl*>& getAreaImpls() const;
+  virtual const std::list<const RBAViewContentImpl*>& getViewContentImpls() const;
+  virtual const std::list<const RBAViewContentStateImpl*>& getViewContentStateImpls() const;
+  virtual const std::list<const RBASizeImpl*>& getSizeImpls() const;
+  virtual const std::list<const RBAZoneImpl*>& getZoneImpls() const;
+  virtual const std::list<const RBASoundContentImpl*>& getSoundContentImpls() const;
+  virtual const std::list<const RBASoundContentStateImpl*>& getSoundContentStateImpls() const;
+  virtual const std::list<const RBASceneImpl*>& getSceneImpls() const;
+  virtual const std::list<const RBAPositionContainerImpl*>& getPositionContainerImpls() const;
+  virtual const std::list<const RBADisplayImpl*>& getDisplayImpls() const;
+
+  virtual void createSortedAllocatables();
+
+  virtual RBAConstraintImpl* findConstraintImpl(const std::string& consName) const;
+  virtual const RBAAreaSet* findAreaSetImpl(const std::string& areaSetName) const;
+  virtual const RBAZoneSet* findZoneSetImpl(const std::string& zoneSetName) const;
+  virtual const RBAViewContentSet* findViewContentSetImpl(const std::string& contSetName) const;
+  virtual const RBASoundContentSet* findSoundContentSetImpl(const std::string& contSetName) const;
+  virtual const RBAPositionContainerImpl* findPositionContainerImpl(const std::string& areaName) const;
+
+  virtual std::list<const RBAConstraintImpl*>& getConstraintImpls();
+  virtual const std::list<const RBAAreaSet*>& getAreaSetImpls() const;
+  virtual const std::list<const RBAZoneSet*>& getZoneSetImpls() const;
+  virtual const std::list<const RBAViewContentSet*>& getViewContentSetImpls() const;
+  virtual const std::list<const RBASoundContentSet*>& getSoundContentSetImpls() const;
+  // Do not set to const because the internal state is changed by arbitration 
+  // processing
+  virtual std::list<RBAAllocatable*>& getSortedAllocatables();
+
+  virtual RBAModelElement* addModelElement(std::unique_ptr<RBAModelElement> newElement);
+  virtual RBANamedElement* addNamedElement(std::unique_ptr<RBAModelElement> newElement);
+  virtual RBASizeImpl* addSizeInstance(const std::string& ownerName,
+                                       std::unique_ptr<RBAModelElement> newSize);
+
+  virtual void addAllocatable(const RBAAllocatable* newAlloc);
+  virtual void addContent(const RBAContent* newContent);
+  virtual void addContentState(const RBAContentState* newState);
+  virtual void addAreaSet(const RBAAreaSet* newAreaSet);
+  virtual void addZoneSet(const RBAZoneSet* newZoneSet);
+  virtual void addConstraint(const RBAConstraintImpl* newConstraint);
+  virtual void addViewContentSet(const RBAViewContentSet* newContentSet);
+  virtual void addSoundContentSet(const RBASoundContentSet* newContentSet);
+  virtual void addScene(const RBASceneImpl* newScene);
+  virtual void addPositionContainer(const RBAPositionContainerImpl* newPositionContainer);
+  virtual void addDisplay(const RBADisplayImpl* newDisplay);
+  /// Add element with label
+  virtual void addLabeledElement(const std::string& label,
+                                 RBAModelElement* element);
+  /// Add constraint expression with label
+  virtual void addLabeledConstraint(const std::string& label,
+                                    RBAAbstractConstraint* constraint);
+
+  /// Add element list with label
+  virtual const std::list<const RBAModelElement*> getLabeledElements(const std::string& label) const;
+  /// Add constraint expression list with label
+  virtual const std::list<RBAAbstractConstraint*> getLabeledConstraints(const std::string& label) const;
+  /// Search element with label
+  virtual const RBAModelElement* findLabeledElement(const std::string& label,
+                                                    const std::string& name) const;
+
+  // Add to Allcatable map
+  void addAffectedAllocsMap(const RBAModelElement* const owner, RBAAllocatable* const alloc);
+  // Get affected Allocatable list
+  const std::list<RBAAllocatable*>* getAffectedAllocs(const RBAModelElement* const owner);
+  
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::list<const RBAAllocatable*> allocatables_;
+  std::list<const RBAContent*> contents_;
+  std::list<const RBAContentState*> contentStates_;
+  std::list<const RBAAreaImpl*> areas_;
+  std::list<const RBAViewContentImpl*> viewContents_;
+  std::list<const RBAViewContentStateImpl*> viewContentStates_;
+  std::list<const RBASizeImpl*> sizes_;
+  std::list<const RBAZoneImpl*> zones_;
+  std::list<const RBASoundContentImpl*> soundContents_;
+  std::list<const RBASoundContentStateImpl*> soundContentStates_;
+  std::list<const RBAConstraintImpl*> constraints_;
+  std::list<const RBAAreaSet*> areaSets_;
+  std::list<const RBAZoneSet*> zoneSets_;
+  std::list<const RBASceneImpl*> scenes_;
+  std::list<const RBAViewContentSet*> viewContentSets_;
+  std::list<const RBASoundContentSet*> soundContentSets_;
+  std::list<const RBAPositionContainerImpl*> positionContainers_;
+  std::list<const RBADisplayImpl*> displays_;
+
+  // Do not set to const because the internal state is changed by arbitration 
+  // processing
+  std::list<RBAAllocatable*> sortedAllocatables_;
+
+  // For storing objects not managed by name
+  // expression, variable are applicable.
+  std::list<std::unique_ptr<RBAModelElement>> unnamedObjects_;
+
+  // Managing RBARuleObject and RBASize
+  std::unordered_map<std::string, std::unique_ptr<RBAModelElement>> nameToObject_;
+  // Position container is managed by map paired with Area name
+  std::unordered_map<std::string, const RBAPositionContainerImpl*> areaNameToPositionContainer_;
+
+  // Managing Labeled element model for extensions
+  std::unordered_map<std::string, std::list<const RBAModelElement*>> labelToElements_;
+  // Managing Labeled Constraint Expressions for extensions
+  std::unordered_map<std::string, std::list<RBAAbstractConstraint*>> labelToConstraints_;
+
+  // Allocatable map
+  std::unordered_map<const RBAModelElement*, std::list<RBAAllocatable*>> affectedAllocsMap_; 
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBANamedElement.cpp b/src/core/model/RBANamedElement.cpp
new file mode 100644
index 0000000..9bfd1c0
--- /dev/null
+++ b/src/core/model/RBANamedElement.cpp
@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+/**
+ * NamedElement clsass 
+ */
+
+#include "RBANamedElement.hpp"
+
+namespace rba
+{
+
+RBANamedElement::RBANamedElement(const std::string& newName)
+    : RBAModelElement(),
+      name_(newName)
+{
+}
+
+std::string
+RBANamedElement::getUniqueName() const
+{
+  return getElementName();
+}
+
+const std::string&
+RBANamedElement::getElementName() const
+{
+  return name_;
+}
+
+const std::string&
+RBANamedElement::getDynamicName() const
+{
+  return dynamic_name_;
+}
+
+void
+RBANamedElement::setDynamicName(const std::string& newName)
+{
+  dynamic_name_ = newName;
+}
+}
diff --git a/src/core/model/RBANamedElement.hpp b/src/core/model/RBANamedElement.hpp
new file mode 100644
index 0000000..81db36d
--- /dev/null
+++ b/src/core/model/RBANamedElement.hpp
@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+/**
+ * NamedElement clsass header
+ */
+
+#ifndef RBANAMEDELEMENT_HPP
+#define RBANAMEDELEMENT_HPP
+
+#include <string>
+#include "RBAModelElement.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBANamedElement : public RBAModelElement
+{
+protected:
+  explicit RBANamedElement(const std::string& newName = "");
+  RBANamedElement(const RBANamedElement&)=delete;
+  RBANamedElement(const RBANamedElement&&)=delete;
+  RBANamedElement& operator=(const RBANamedElement&)=delete;
+  RBANamedElement& operator=(const RBANamedElement&&)=delete;
+
+public:
+  virtual ~RBANamedElement()=default;
+  virtual std::string getUniqueName() const;
+  const std::string& getElementName() const;
+  const std::string& getDynamicName() const;
+  void setDynamicName(const std::string& newName);
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  const std::string name_;
+  std::string dynamic_name_;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBARuleObject.cpp b/src/core/model/RBARuleObject.cpp
new file mode 100644
index 0000000..62aa1a5
--- /dev/null
+++ b/src/core/model/RBARuleObject.cpp
@@ -0,0 +1,105 @@
+/**
+ * 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.
+ */
+/**
+ * RuleObject class
+ */
+
+#include <string>
+#include <unordered_map>
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+RBARuleObject::RBARuleObject(const std::string& name)
+  : RBANamedElement{name}
+{
+}
+
+bool
+RBARuleObject::isPrevious() const
+{
+  return false;
+}
+
+const RBARuleObject*
+RBARuleObject::getRawObject() const
+{
+  return this;
+}
+
+void RBARuleObject::addTag(const std::string& tag)
+{
+  static_cast<void>(tags_.insert(tag));
+}
+  
+bool RBARuleObject::containsTag(const std::string& tag) const
+{
+  return (tags_.find(tag) != tags_.end());
+}
+
+void RBARuleObject::addMember(RBARuleObject* member)
+{
+  members_[member->getElementName()] = member;
+}
+
+const RBARuleObject* RBARuleObject::getMember(const std::string& memberName) const
+{
+  if (members_.find(memberName) != members_.end()) {
+    return (members_.at(memberName));
+  } else {
+    return nullptr;
+  }
+}
+
+void RBARuleObject::addMember(const std::string& memberName, RBARuleObject* const val)
+{
+  members_[memberName] = val;
+}
+
+RBARuleObject*
+RBARuleObject::getOwner() const
+{
+  return owner_;
+}
+  
+void
+RBARuleObject::setOwner(RBARuleObject* owner)
+{
+  owner_ = owner;
+}
+
+std::string
+RBARuleObject::getUniqueName() const
+{
+  if (owner_ != nullptr) {
+    // @Deviation (MEM05-CPP,Rule-7_5_4,A7-5-2)
+    // [Contents that deviate from the rules]
+    //  Calling getUniqueName() recursively.
+    // [Reason that there is no problem if the rule is deviated]
+    // 　Since the number of elements in the rule model is finite and 
+    //  there is no cyclic relationship, stack overflow does not occur.
+    return owner_->getUniqueName() + "/" + getElementName();
+  }
+  return getElementName();
+}
+
+const std::unordered_map<std::string, RBARuleObject*>& RBARuleObject::getMembers() const
+{
+  return members_;
+}
+
+}
diff --git a/src/core/model/RBARuleObject.hpp b/src/core/model/RBARuleObject.hpp
new file mode 100644
index 0000000..3f03ddc
--- /dev/null
+++ b/src/core/model/RBARuleObject.hpp
@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+/**
+ * RuleObject class header
+ */
+
+#ifndef RBARULEOBJECT_HPP
+#define RBARULEOBJECT_HPP
+
+#include <unordered_map>
+#include <unordered_set>
+#include <string>
+
+#include "RBANamedElement.hpp"
+
+namespace rba
+{
+
+class DLL_EXPORT RBARuleObject : public RBANamedElement
+{
+protected:
+  explicit RBARuleObject(const std::string& name="");
+  RBARuleObject(const RBARuleObject&)=delete;
+  RBARuleObject(const RBARuleObject&&)=delete;
+  RBARuleObject& operator=(const RBARuleObject&)=delete;
+  RBARuleObject& operator=(const RBARuleObject&&)=delete;
+
+public:
+  virtual ~RBARuleObject()=default;
+  virtual bool isPrevious() const;
+  virtual const RBARuleObject* getRawObject() const;
+  bool containsTag(const std::string& tag) const;
+  void addTag(const std::string& tag);
+  virtual void addMember(RBARuleObject* member);
+  virtual const RBARuleObject* getMember(const std::string& memberName) const;
+  RBARuleObject* getOwner() const;
+  virtual void setOwner(RBARuleObject* owner);
+  std::string getUniqueName() const override;
+
+protected:
+  void addMember(const std::string& memberName, RBARuleObject* const val);
+  const std::unordered_map<std::string, RBARuleObject*>& getMembers() const;
+
+private:
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4251)
+#endif
+  std::unordered_set<std::string> tags_;
+  std::unordered_map<std::string, RBARuleObject*> members_;
+  RBARuleObject* owner_ {nullptr};
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBARuleObjectMaker.cpp b/src/core/model/RBARuleObjectMaker.cpp
new file mode 100644
index 0000000..7b384e1
--- /dev/null
+++ b/src/core/model/RBARuleObjectMaker.cpp
@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+/// @file  RBARuleObjectMaker.cpp
+/// @brief RuleObject generator class 
+
+#include "RBARuleObjectMaker.hpp"
+#include "RBARuleObject.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAModelFactory.hpp"
+
+namespace rba
+{
+
+RBARuleObjectMaker::RBARuleObjectMaker(const std::string& label)
+  : RBAModelElementMaker{label}
+{  
+}
+
+RBAModelElement*
+RBARuleObjectMaker::setProperty(RBAModelElement* element,
+                                const RBAJsonElement* jsonElem,
+                                RBAModelImpl* model,
+                                RBAModelElement* owner)
+{
+  const auto ruleObj = dynamic_cast<RBARuleObject*>(element);
+
+  // Tag
+  const RBAJsonElement* const tags {jsonElem->findChildren("tags")};
+  if (tags != nullptr) {
+    for (const auto& tag : tags->getChildren()) {
+      const RBAJsonElement* const tagName {tag->findChildren("name")};
+      if (tagName != nullptr) {
+        ruleObj->addTag(tagName->getString());
+      }
+    }
+  }
+
+  // owner
+  const auto ownerRuleObj = dynamic_cast<RBARuleObject*>(owner);
+  if (ownerRuleObj != nullptr) {
+    ruleObj->setOwner(ownerRuleObj);
+  }
+
+  return ruleObj;
+}
+
+}
diff --git a/src/core/model/RBARuleObjectMaker.hpp b/src/core/model/RBARuleObjectMaker.hpp
new file mode 100644
index 0000000..661b0b7
--- /dev/null
+++ b/src/core/model/RBARuleObjectMaker.hpp
@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+/// @file  RBARuleObjectMaker.cpp
+/// @brief RuleObject generator class header
+
+#ifndef RBARULEOBJECTMAKER_HPP
+#define RBARULEOBJECTMAKER_HPP
+
+#include "RBAModelElementMaker.hpp"
+
+namespace rba
+{
+
+/// @brief RuleObject generator class header
+class DLL_EXPORT RBARuleObjectMaker : public RBAModelElementMaker
+{
+public:
+  explicit RBARuleObjectMaker(const std::string& label="");
+  RBARuleObjectMaker(const RBARuleObjectMaker&)=delete;
+  RBARuleObjectMaker(const RBARuleObjectMaker&&)=delete;
+  RBARuleObjectMaker& operator=(const RBARuleObjectMaker&)=delete;
+  RBARuleObjectMaker& operator=(const RBARuleObjectMaker&&)=delete;
+  virtual ~RBARuleObjectMaker()=default;
+
+protected:
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBASceneImpl.cpp b/src/core/model/RBASceneImpl.cpp
new file mode 100644
index 0000000..82ecab2
--- /dev/null
+++ b/src/core/model/RBASceneImpl.cpp
@@ -0,0 +1,113 @@
+/**
+ * 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.
+ */
+/**
+ * Scene implementation class
+ */
+
+#include "RBASceneImpl.hpp"
+#include "RBAModelElementType.hpp"
+#include "RBAAbstractProperty.hpp"
+#include "RBAIntegerProperty.hpp"
+
+namespace rba
+{
+
+RBASceneImpl::RBASceneImpl(const std::string& name)
+  : RBAScene(),
+    RBARuleObject{name}
+{
+}
+
+std::string
+RBASceneImpl::getName() const
+{
+  return RBARuleObject::getElementName();
+}
+
+RBAModelElementType
+RBASceneImpl::getModelElementType() const
+{
+  return RBAModelElementType::Scene;
+}
+
+bool
+RBASceneImpl::isGlobal() const
+{
+  return global_;
+}
+
+const std::list<std::string>&
+RBASceneImpl::getPropertyNames() const
+{
+  return propertyNames_;
+}
+
+std::int32_t
+RBASceneImpl::getPropertyValue(const std::string& propertyName) const
+{
+  const RBAAbstractProperty* const prop {getProperty(propertyName)};
+  if(prop == nullptr) {
+    // Returns "-1" if the property is not registered
+    return -1;
+  }
+
+  // Returns default value
+  return prop->getValue();
+}
+
+const RBARuleObject* RBASceneImpl::getMember(const std::string& memberName) const
+{
+  return getProperty(memberName);
+}
+
+const RBAAbstractProperty*
+RBASceneImpl::getProperty(const std::string& propertyName) const
+{
+  auto p = nameToProperty_.find(propertyName);
+  if(p == nameToProperty_.end()) {
+    // Returns nullptr if the property is not registered
+    return nullptr;
+  }
+
+  return p->second;
+}
+
+void
+RBASceneImpl::setGlobal(const bool newGlobal)
+{
+  global_ = newGlobal;
+}
+
+const RBAAbstractProperty*
+RBASceneImpl::addProperty(const std::string& newName, std::int32_t newValue)
+{
+  auto p = nameToProperty_.find(newName);
+  if(p != nameToProperty_.end()) {
+    // No operation if the property is registered
+    return p->second;
+  }
+
+  // Registration
+  properties_.push_back(std::make_unique<RBAIntegerProperty>(this,
+                                                             newName,
+                                                             newValue));
+  propertyNames_.push_back(newName);
+  nameToProperty_[newName] = properties_.back().get();
+
+  return properties_.back().get();
+}
+
+}
diff --git a/src/core/model/RBASceneImpl.hpp b/src/core/model/RBASceneImpl.hpp
new file mode 100644
index 0000000..dd1fe3a
--- /dev/null
+++ b/src/core/model/RBASceneImpl.hpp
@@ -0,0 +1,65 @@
+/**
+ * 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.
+ */
+/**
+ * Scene implementation class header
+ */
+
+#ifndef RBASCENEIMPL_HPP
+#define RBASCENEIMPL_HPP
+
+#include <memory>
+#include "RBAScene.hpp"
+#include "RBARuleObject.hpp"
+
+namespace rba
+{
+
+class RBAAbstractProperty;
+
+class RBASceneImpl : public RBAScene, public RBARuleObject
+{
+public:
+  explicit RBASceneImpl(const std::string& name="");
+  RBASceneImpl(const RBASceneImpl&)=delete;
+  RBASceneImpl(const RBASceneImpl&&)=delete;
+  RBASceneImpl& operator=(const RBASceneImpl&)=delete;
+  RBASceneImpl& operator=(const RBASceneImpl&&)=delete;
+  virtual ~RBASceneImpl()=default;
+
+public:
+  std::string getName() const override;
+  RBAModelElementType getModelElementType() const override;
+  bool isGlobal() const override;
+  const std::list<std::string>& getPropertyNames() const override;
+  std::int32_t getPropertyValue(const std::string& propertyName) const override;
+  const RBARuleObject* getMember(const std::string& memberName) const override;
+  const RBAAbstractProperty* getProperty(const std::string& propertyName) const;
+
+  void setGlobal(const bool newGlobal);
+  const RBAAbstractProperty* addProperty(const std::string& newName,
+                                         std::int32_t newValue);
+
+private:
+  bool global_ {false};
+  // Used to get property name in RBAScene
+  std::list<std::string> propertyNames_; 
+  std::list<std::unique_ptr<RBAAbstractProperty>> properties_;
+  std::unordered_map<std::string, RBAAbstractProperty*> nameToProperty_;
+};
+
+}
+
+#endif
diff --git a/src/core/model/RBASceneMaker.cpp b/src/core/model/RBASceneMaker.cpp
new file mode 100644
index 0000000..9c55f84
--- /dev/null
+++ b/src/core/model/RBASceneMaker.cpp
@@ -0,0 +1,74 @@
+/**
+ * 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.
+ */
+/// @file  RBASceneMaker.cpp
+/// @brief Scene　object generator class
+
+#include "RBASceneMaker.hpp"
+#include "RBASceneImpl.hpp"
+#include "RBAJsonElement.hpp"
+#include "RBAModelElement.hpp"
+#include "RBAModelImpl.hpp"
+#include "RBAAbstractProperty.hpp"
+
+namespace rba
+{
+
+RBASceneMaker::RBASceneMaker()
+  : RBARuleObjectMaker{"scenes"}
+{
+}
+
+std::unique_ptr<RBAModelElement>
+RBASceneMaker::createInstance(const std::string& name)
+{
+  return std::make_unique<RBASceneImpl>(name);
+}
+
+RBAModelElement*
+RBASceneMaker::setProperty(RBAModelElement* element,
+                           const RBAJsonElement* jsonElem,
+                           RBAModelImpl* model,
+                           RBAModelElement* owner)
+{
+  static_cast<void>(RBARuleObjectMaker::setProperty(element, jsonElem, model, owner));
+
+  RBASceneImpl* const scene {dynamic_cast<RBASceneImpl*>(element)};
+
+  // Set global
+  const std::string global {jsonElem->findChildren("global")->getString()};
+  if(global == "true") {
+    scene->setGlobal(true);
+  }
+  else {
+    scene->setGlobal(false);
+  }
+
+  // Set property
+  const RBAJsonElement* const properties {jsonElem->findChildren("property")};
+  if(properties != nullptr) {
+    for(const auto& property : properties->getChildren()) {
+      const std::string propertyName {property->findChildren("name")->getString()};
+      const std::int32_t value {property->findChildren("value")->getInt()};
+      static_cast<void>(scene->addProperty(propertyName, value));
+    }
+  }
+
+  model->addScene(scene);
+
+  return scene;
+}
+
+}
diff --git a/src/core/model/RBASceneMaker.hpp b/src/core/model/RBASceneMaker.hpp
new file mode 100644
index 0000000..6d2ea5e
--- /dev/null
+++ b/src/core/model/RBASceneMaker.hpp
@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+/// @file  RBASceneMaker.hpp
+/// @brief Scene　object generator class header
+
+#ifndef RBASCENEMAKER_HPP
+#define RBASCENEMAKER_HPP
+
+#include "RBARuleObjectMaker.hpp"
+
+namespace rba
+{
+
+/// @brief Scene　object generator class
+class RBASceneMaker : public RBARuleObjectMaker
+{
+public:
+  RBASceneMaker();
+  RBASceneMaker(const RBASceneMaker&)=delete;
+  RBASceneMaker(const RBASceneMaker&&)=delete;
+  RBASceneMaker& operator=(const RBASceneMaker&)=delete;
+  RBASceneMaker& operator=(const RBASceneMaker&&)=delete;
+  virtual ~RBASceneMaker()=default;
+
+protected:
+  /// @brief Create an empty instance
+  /// @details Create an empty instance of unique_ptr in derived class
+  /// @return unique_ptr for insitance
+  std::unique_ptr<RBAModelElement> createInstance(const std::string& name="") override;
+
+  /// @brief Set model element attributes for each derived class
+  /// @param[in] jsonElem JSON element of ModelElement
+  /// @param[in] model The model to store generated RBARuleObjectMaker
+  /// @param[in,out] owner Parent object (Not in use)
+  RBAModelElement* setProperty(RBAModelElement* element,
+                               const RBAJsonElement* jsonElem,
+                               RBAModelImpl* model,
+                               RBAModelElement* owner=nullptr) override;
+
+};
+
+}
+
+#endif