First commitjellyfish_9.99.4jellyfish/9.99.49.99.4

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

1 files changed, 1088 insertions, 0 deletions

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
+
+}