From 2b4ae7fde370bc3316ab30cc38b74d23e785b360 Mon Sep 17 00:00:00 2001 From: Kenji Hosokawa Date: Mon, 24 Aug 2020 21:58:42 +0900 Subject: First commit Signed-off-by: Kenji Hosokawa Change-Id: I381abb0a6521f5349768a76ef7ceecbce4b2d701 --- src/core/logic/RBAResultImpl.cpp | 1088 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 1088 insertions(+) create mode 100644 src/core/logic/RBAResultImpl.cpp (limited to 'src/core/logic/RBAResultImpl.cpp') 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 newPrevResultSet): + RBAResult(), + preResultSet_{std::move(newPrevResultSet)}, + arb_{arb}, + statusType_{RBAResultStatusType::SUCCESS} +{ + curResultSet_ = std::make_unique(); + curResultSet_->copyActives(preResultSet_); + curResultSet_->copyProperties(preResultSet_); +} + +RBAResultImpl::RBAResultImpl(const RBAArbitrator* const arb, + std::unique_ptr newPrevResultSet, + std::unique_ptr 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(*(replicationTarget->curResultSet_.get()))}, + preResultSet_{std::make_unique(*(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(va->getFromArea(), va->getToArea(), + va->getContentState())); + } else if (va->getViewActionType() + == RBAViewActionType::TRANSITION_REPLACE) { + viewActions_.push_back( + std::make_unique(va->getViewActionType(), + va->getArea(), + va->getFromContentState(), + va->getToContentState())); + } else { + viewActions_.push_back( + std::make_unique(va->getViewActionType(), + va->getArea(), + va->getContentState())); + } + } +} + +// +// External +// + +// [get VisibleArea/SoundingZone] + +const std::list& +RBAResultImpl::getVisibleAreas() const +{ + return curResultSet_->getVisibleAreas(); +} + +const std::list& +RBAResultImpl::getPreVisibleAreas() const +{ + return preResultSet_->getVisibleAreas(); +} + +const std::list& +RBAResultImpl::getSoundingZones() const +{ + return curResultSet_->getSoundingZones(); +} + +const std::list& +RBAResultImpl::getPreSoundingZones() const +{ + return preResultSet_->getSoundingZones(); +} + +// [get Visible/Sounding ContentStates] + +const std::list& +RBAResultImpl::getVisibleContentStates() const +{ + return curResultSet_->getVisibleContentStates(); +} + +const std::list& +RBAResultImpl::getPreVisibleContentStates() const +{ + return preResultSet_->getVisibleContentStates(); +} + +const std::list& +RBAResultImpl::getSoundingContentStates() const +{ + return curResultSet_->getSoundingContentStates(); +} + +const std::list& +RBAResultImpl::getPreSoundingContentStates() const +{ + return preResultSet_->getSoundingContentStates(); +} + +// [get Active View/Sound ContentStates] + +const std::list& +RBAResultImpl::getActiveViewContentStates() const +{ + return curResultSet_->getActiveViewContentStates(); +} + +const std::list& +RBAResultImpl::getPreActiveViewContentStates() const +{ + return preResultSet_->getActiveViewContentStates(); +} + +const std::list& +RBAResultImpl::getActiveSoundContentStates() const +{ + return curResultSet_->getActiveSoundContentStates(); +} + +const std::list& +RBAResultImpl::getPreActiveSoundContentStates() const +{ + return preResultSet_->getActiveSoundContentStates(); +} + +// [get etActive Scenes] + +const std::list& +RBAResultImpl::getActiveScenes() const +{ + return curResultSet_->getActiveScenes(); +} + +const std::list& +RBAResultImpl::getPreActiveScenes() const +{ + return preResultSet_->getActiveScenes(); +} + +// [get InvisibleAreas/UnsoundingZone] + +const std::list& +RBAResultImpl::getInvisibleAreas() const +{ + return curResultSet_->getInvisibleAreas(); +} + +const std::list& +RBAResultImpl::getPreInvisibleAreas() const +{ + return preResultSet_->getInvisibleAreas(); +} + +const std::list& +RBAResultImpl::getUnsoundingZones() const +{ + return curResultSet_->getUnsoundingZones(); +} + +const std::list& +RBAResultImpl::getPreUnsoundingZones() const +{ + return preResultSet_->getUnsoundingZones(); +} + +// [get HiddenAreas/MuteZones] + +const std::list& +RBAResultImpl::getHiddenAreas() const +{ + return curResultSet_->getHiddenAreas(); +} + +const std::list& +RBAResultImpl::getPreHiddenAreas() const +{ + return preResultSet_->getHiddenAreas(); +} + +const std::list& +RBAResultImpl::getMuteZones() const +{ + return curResultSet_->getMuteZones(); +} + +const std::list& +RBAResultImpl::getPreMuteZones() const +{ + return preResultSet_->getMuteZones(); +} + +// [get Attenuated] + +const std::list& +RBAResultImpl::getAttenuatedZones() const +{ + return curResultSet_->getAttenuatedZones(); +} + +const std::list& +RBAResultImpl::getPreAttenuatedZones() const +{ + return preResultSet_->getAttenuatedZones(); +} + +// [get Canceled Contents] + +const std::list& +RBAResultImpl::getCanceledViewContents() const +{ + return curResultSet_->getCanceledViewContents(); +} + +const std::list& +RBAResultImpl::getPreCanceledViewContents() const +{ + return preResultSet_->getCanceledViewContents(); +} + +const std::list& +RBAResultImpl::getCanceledSoundContents() const +{ + return curResultSet_->getCanceledSoundContents(); +} + +const std::list& +RBAResultImpl::getPreCanceledSoundContents() const +{ + return preResultSet_->getCanceledSoundContents(); +} + +// [get Standby Contents] + +const std::list& +RBAResultImpl::getStandbyViewContents() const +{ + return curResultSet_->getStandbyViewContents(); +} + +const std::list& +RBAResultImpl::getPreStandbyViewContents() const +{ + return preResultSet_->getStandbyViewContents(); +} + +const std::list& +RBAResultImpl::getStandbySoundContents() const +{ + return curResultSet_->getStandbySoundContents(); +} + +const std::list& +RBAResultImpl::getPreStandbySoundContents() const +{ + return preResultSet_->getStandbySoundContents(); +} + +// [get ContentStates] + +const RBAViewContentState* +RBAResultImpl::getContentState(const RBAArea* area) const +{ + return dynamic_cast( + curResultSet_->getContentState(dynamic_cast(area))); +} + +const RBAViewContentState* +RBAResultImpl::getPreContentState(const RBAArea* area) const +{ + return dynamic_cast( + preResultSet_->getContentState(dynamic_cast(area))); +} + +const RBASoundContentState* +RBAResultImpl::getContentState(const RBAZone* zone) const +{ + return dynamic_cast( + curResultSet_->getContentState(dynamic_cast(zone))); +} + +const RBASoundContentState* +RBAResultImpl::getPreContentState(const RBAZone* zone) const +{ + return dynamic_cast( + preResultSet_->getContentState(dynamic_cast(zone))); +} + +// [get Areas/Zones by ConentState] + +const std::list +RBAResultImpl::getArea(const RBAViewContentState* state) const +{ + std::list areaList; + curResultSet_->getArea(state, areaList); + return areaList; +} + +const std::list +RBAResultImpl::getPreArea(const RBAViewContentState* state) const +{ + std::list areaList; + preResultSet_->getArea(state, areaList); + return areaList; +} + +const std::list +RBAResultImpl::getZone(const RBASoundContentState* state) const +{ + std::list zoneList; + curResultSet_->getZone(state, zoneList); + return zoneList; +} + +const std::list +RBAResultImpl::getPreZone(const RBASoundContentState* state) const +{ + std::list zoneList; + preResultSet_->getZone(state, zoneList); + return zoneList; +} + +// [get Areas/Zones by Content] + +const std::list +RBAResultImpl::getArea(const RBAViewContent* content) const +{ + std::list areaList; + curResultSet_->getArea(content, areaList); + return areaList; +} + +const std::list +RBAResultImpl::getPreArea(const RBAViewContent* content) const +{ + std::list areaList; + preResultSet_->getArea(content, areaList); + return areaList; +} + +const std::list +RBAResultImpl::getZone(const RBASoundContent* content) const +{ + std::list zoneList; + curResultSet_->getZone(content, zoneList); + return zoneList; +} + +const std::list +RBAResultImpl::getPreZone(const RBASoundContent* content) const +{ + std::list 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(content)); +} + +bool +RBAResultImpl::isActive(const RBASoundContent* content) const +{ + return curResultSet_->isActive(dynamic_cast(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(content)); +} + +bool +RBAResultImpl::isPreActive(const RBASoundContent* content) const +{ + return preResultSet_->isActive(dynamic_cast(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(state)); +} + +bool +RBAResultImpl::isActive(const RBASoundContentState* const state) const +{ + return isActive(dynamic_cast(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(state)); +} + +bool +RBAResultImpl::isPreActive(const RBASoundContentState* const state) const +{ + return isPreActive(dynamic_cast(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(state)); +} + +bool +RBAResultImpl::isPreVisible(const RBAViewContentState* state) const +{ + return isPreOutputting(dynamic_cast(state)); +} + +bool +RBAResultImpl::isSounding(const RBASoundContentState* state) const +{ + return isOutputting(dynamic_cast(state)); +} + +bool +RBAResultImpl::isPreSounding(const RBASoundContentState* state) const +{ + return isPreOutputting(dynamic_cast(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( + curResultSet_->getContentState(dynamic_cast(area))); +} + +const RBAViewContentState* +RBAResultImpl::getPreViewContentState(const RBAArea* area) const +{ + return dynamic_cast( + preResultSet_->getContentState(dynamic_cast(area))); +} + +const RBASoundContentState* +RBAResultImpl::getSoundContentState(const RBAZone* zone) const +{ + return dynamic_cast( + curResultSet_->getContentState(dynamic_cast(zone))); +} + +const RBASoundContentState* +RBAResultImpl::getPreSoundContentState(const RBAZone* zone) const +{ + return dynamic_cast( + preResultSet_->getContentState(dynamic_cast(zone))); +} + +// [check Hidden/Mute] + +bool +RBAResultImpl::isHidden(const RBAArea* area) const +{ + return isHidden(dynamic_cast(area)); +} + +bool +RBAResultImpl::isPreHidden(const RBAArea* area) const +{ + return isPreHidden(dynamic_cast(area)); +} + +bool +RBAResultImpl::isMute(const RBAZone* zone) const +{ + return isHidden(dynamic_cast(zone)); +} + +bool +RBAResultImpl::isPreMute(const RBAZone* zone) const +{ + return isPreHidden(dynamic_cast(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& +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(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& +RBAResultImpl::getOutputtingAllocatables() const +{ + return curResultSet_->getOutputtingAllocatables(); +} + +// Impl [get Active View/Sound ContentStates] + +const std::set& +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 +RBAResultImpl::getAllocatable(const RBAContentState* const state) const +{ + std::list allocatables; + if(state->isViewContentState()) { + std::list areaList; + curResultSet_->getArea(dynamic_cast(state), + areaList); + for (const auto& area : areaList) { + allocatables.push_back(dynamic_cast(area)); + } + } + else { + std::list zoneList; + curResultSet_->getZone(dynamic_cast(state), + zoneList); + for (const auto& zone : zoneList) { + allocatables.push_back(dynamic_cast(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(area)); +} + +bool +RBAResultImpl::isPreVisible(const RBAArea* area) const +{ + return preResultSet_->isOutputting(dynamic_cast(area)); +} + +bool +RBAResultImpl::isSounding(const RBAZone* zone) const +{ + return curResultSet_->isOutputting(dynamic_cast(zone)); +} + +bool +RBAResultImpl::isPreSounding(const RBAZone* zone) const +{ + return preResultSet_->isOutputting(dynamic_cast(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(state)); +} + +bool +RBAResultImpl::isPreCancel(const RBAViewContentState* state) const +{ + return isPreCancel(dynamic_cast(state)); +} + +bool +RBAResultImpl::isCancel(const RBASoundContentState* state) const +{ + return isCancel(dynamic_cast(state)); +} + +bool +RBAResultImpl::isPreCancel(const RBASoundContentState* state) const +{ + return isPreCancel(dynamic_cast(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 +RBAResultImpl::createBackupCurrentResultSet() +{ + return std::make_unique(*curResultSet_); +} + +std::unique_ptr +RBAResultImpl::createNextCurrentResultSet() +{ + std::unique_ptr nextResultSet {std::make_unique()}; + nextResultSet->copyActives(curResultSet_); + nextResultSet->copyProperties(curResultSet_); + return nextResultSet; +} + +void +RBAResultImpl::addViewAction(std::unique_ptr& 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& +RBAResultImpl::getCurResultSet() +{ + return curResultSet_; +} + +std::unique_ptr& +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* RBAResultImpl::getCurStatus() const +{ + return curResultSet_->getStatus(); +} + +std::set& RBAResultImpl::getDifferentConditionScenes() const +{ + return (curResultSet_->getDifferentConditionScenes(*preResultSet_.get())); +} +#ifdef RBA_USE_LOG +void +RBAResultImpl::addFailedConstraint(const RBAConstraint* constraint) +{ + curResultSet_->addFailedConstraint(constraint); +} + +const std::list& +RBAResultImpl::getFailedConstraints() const +{ + return curResultSet_->getFailedConstraints(); +} +#endif + +} -- cgit 1.2.3-korg