diff options
author | Kenji Hosokawa <khosokawa@jp.adit-jv.com> | 2020-08-24 21:58:42 +0900 |
---|---|---|
committer | Kenji Hosokawa <khosokawa@jp.adit-jv.com> | 2020-08-24 21:58:42 +0900 |
commit | 2b4ae7fde370bc3316ab30cc38b74d23e785b360 (patch) | |
tree | 41b6eb70b3419c2fbd192ed133c5890a985eddec /src/core/logic | |
parent | 6694a4d2952ebd171564932200cac00d6e5792f4 (diff) |
First commitjellyfish_9.99.4jellyfish/9.99.49.99.4
Signed-off-by: Kenji Hosokawa <khosokawa@jp.adit-jv.com>
Change-Id: I381abb0a6521f5349768a76ef7ceecbce4b2d701
Diffstat (limited to 'src/core/logic')
27 files changed, 6854 insertions, 0 deletions
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 |