{
namespace Service
{
+
class SceneCollectionResource;
/**
friend class SceneCollection;
public:
+
/**
* Adds new SceneAction instance to the Scene instance
*
- * @param RCSRemoteResourceObjectPtr A pointer of discovered resource
- * @param attr A attribute set of key and value
+ * @param pRCSRemoteResourceObject A pointer of discovered resource
+ * @param key A key of attributes
+ * @param value A value to be mapped against the key
*
* @return A shared pointer of SceneAction instance
*
- * @throws RCSInvalidParameterException if RCSRemoteResourceObjectPtr is nullptr
- * @throws InvalidAddMemberRequestException if SceneMember is already registered
+ * @throws RCSInvalidParameterException if pRCSRemoteResourceObject is nullptr
+ * @throws InvalidAddMemberRequestException
+ * if scene member resource is already registered
*
* @note SceneAction instance is only produced by Scene class
*
* @see RCSResourceAttributes
*/
SceneAction::Ptr addNewSceneAction(
- const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr,
- const RCSResourceAttributes& attr);
+ const RCSRemoteResourceObject::Ptr& pRCSRemoteResourceObject,
+ std::string key, RCSResourceAttributes::Value value);
/**
* Adds new SceneAction instance to the Scene instance
*
- * @param RCSRemoteResourceObjectPtr A pointer of discovered resource
- * @param key A key of attributes
- * @param value A value to be mapped against the key
+ * @param pRCSRemoteResourceObject A pointer of discovered resource
+ * @param attr A attribute set of key and value
*
* @return A shared pointer of SceneAction instance
*
- * @throws RCSInvalidParameterException if RCSRemoteResourceObjectPtr is nullptr
- * @throws InvalidAddMemberRequestException
- * if scene member resource is already registered
+ * @throws RCSInvalidParameterException if pRCSRemoteResourceObject is nullptr
+ * @throws InvalidAddMemberRequestException if SceneMember is already registered
*
* @note SceneAction instance is only produced by Scene class
*
* @see RCSResourceAttributes
*/
SceneAction::Ptr addNewSceneAction(
- const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr,
- const std::string& key, const RCSResourceAttributes::Value& value);
+ const RCSRemoteResourceObject::Ptr& pRCSRemoteResourceObject,
+ RCSResourceAttributes attr);
/**
* Gets SceneAction using discovered resource
*
- * @param RCSRemoteResourceObjectPtr A pointer of discovered resource
+ * @param pRCSRemoteResourceObject A pointer of discovered resource
*
* @return A shared pointer of SceneAction
*
* @throws RCSInvalidParameterException
- * if RCSRemoteResourceObjectPtr is unknown resource
+ * if pRCSRemoteResourceObject is unknown resource
*/
SceneAction::Ptr getSceneAction(
- const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr) const;
+ const RCSRemoteResourceObject::Ptr& pRCSRemoteResourceObject) const;
/**
* Gets all SceneActions include current Scene
*/
std::string getName() const;
- void removeSceneAction(const SceneAction::Ptr&);
- void removeSceneAction(const RCSRemoteResourceObject::Ptr&);
-
/**
* Requests executing Scene to SceneCollection resource
*
private:
std::string m_name;
- std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
+ std::shared_ptr< SceneCollectionResource > m_sceneCollectionResource;
};
} /* namespace Service */
} /* namespace OIC */
+
#endif /* SM_SCENE_H_ */
{
namespace Service
{
+
class SceneMemberResource;
/**
public:
/**
- * Sets attributes of the SceneMember resource when the Scene is executed
+ * Sets the SceneAction parameters like a target attribute key and its value
+ * It replaces existing execution parameter
*
* @param key A key of attributes
* @param value A value to be mapped against the key
*
* @see RCSResourceAttributes
*/
- void setExecutionParameter(const std::string& key, RCSResourceAttributes::Value value);
+ void resetExecutionParameter(const std::string& key, RCSResourceAttributes::Value value);
/**
- * Sets attributes of the SceneMember resource when the Scene is executed
+ * Sets the SceneAction parameters like a target attribute key and its value
+ * It replaces existing execution parameter
*
* @param attr Attributes to set
*
* @see RCSResourceAttributes
*/
- void setExecutionParameter(const RCSResourceAttributes& attr);
+ void resetExecutionParameter(const RCSResourceAttributes& attr);
/**
* Gets execution parameter of the SceneAction instance
*
* @see RCSResourceAttributes
*/
- const RCSResourceAttributes getExecutionParameter();
+ RCSResourceAttributes getExecutionParameter() const;
/**
- * Gets remote resource object of SceneMember resource
+ * Gets remote resource object
*
* @return RCSRemoteResourceObject
*/
private:
RCSRemoteResourceObject::Ptr m_pRemoteResourceObject;
std::string m_sceneName;
- std::shared_ptr< SceneMemberResource > m_sceneMemberResourceObj;
+ std::shared_ptr< SceneMemberResource > m_sceneMemberResource;
};
} /* namespace Service */
} /* namespace OIC */
+
#endif /* SM_SCENEACTION_H_ */
#define SM_SCENECOLLECTION_H_
#include "Scene.h"
-#include <unordered_map>
namespace OIC
{
namespace Service
{
+
class SceneCollectionResource;
/**
*/
Scene::Ptr getScene(const std::string& sceneName) const;
-
- void removeScene(Scene::Ptr);
-
/**
* Sets a name attribute of SceneCollection resource
*
std::string getId() const;
private:
- std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
+ std::shared_ptr< SceneCollectionResource > m_sceneCollectionResource;
};
} /* namespace Service */
{
namespace Service
{
- class SceneListResource;
+
/**
* @class SceneList
*
class SceneList
{
private:
+ SceneList() = default;
~SceneList() = default;
public:
* Gets all SceneCollection instances stored in SceneList resource
*
* @return A vector of shared pointers of SceneCollection instances
+ *
+ * @note SceneCollection instance that addNewSceneCollection returns is not same
+ * instance that getSceneCollections returns
*/
std::vector<SceneCollection::Ptr> getSceneCollections() const;
- void removeSceneCollection(SceneCollection::Ptr);
-
/**
* Sets a name attribute of SceneList resource
*
};
} /* namespace Service */
} /* namespace OIC */
+
#endif /* SM_SCENELIST_H_ */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "Scene.h"
+
#include "SceneCollectionResource.h"
+
#include <algorithm>
namespace OIC
{
Scene::Scene(const std::string& sceneName,
SceneCollectionResource::Ptr sceneCollectionResource) :
- m_name(sceneName), m_sceneCollectionResourceObj(sceneCollectionResource) {}
+ m_name(sceneName), m_sceneCollectionResource(sceneCollectionResource) {}
SceneAction::Ptr Scene::addNewSceneAction(
- const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr,
- const std::string& key, const RCSResourceAttributes::Value& value)
+ const RCSRemoteResourceObject::Ptr& pRCSRemoteResourceObject,
+ std::string key, RCSResourceAttributes::Value value)
{
RCSResourceAttributes resAttr;
- resAttr[key] = RCSResourceAttributes::Value(value);
- return addNewSceneAction(RCSRemoteResourceObjectPtr, resAttr);
+ resAttr[key] = value;
+ return addNewSceneAction(pRCSRemoteResourceObject, std::move(resAttr));
}
SceneAction::Ptr Scene::addNewSceneAction(
- const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr,
- const RCSResourceAttributes& attr)
+ const RCSRemoteResourceObject::Ptr& pRCSRemoteResourceObject,
+ RCSResourceAttributes attr)
{
- if(RCSRemoteResourceObjectPtr == nullptr)
- {
- throw RCSInvalidParameterException("RCSRemoteResoureObjectPtr value is null");
- }
-
-
- auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
- bool isRegistered = false;
-
- SceneMemberResource::Ptr foundMember;
- std::function<void(const RCSRemoteResourceObject::Ptr&,
- const SceneMemberResource::Ptr&)> buildActionParam = [&](
- const RCSRemoteResourceObject::Ptr & RCSRemoteResourceObjectPtr,
- const SceneMemberResource::Ptr & member)
- {
- if(RCSRemoteResourceObjectPtr == member->getRemoteResourceObject())
- {
- foundMember = member;
- for(const auto &it: member->getMappingInfos())
- {
- isRegistered = (it.sceneName == m_name);
- }
- }
- };
-
-
- std::for_each(sceneMemberResObjs.begin(), sceneMemberResObjs.end(),
- [&buildActionParam, &RCSRemoteResourceObjectPtr](
- const SceneMemberResource::Ptr& member)
- {
- buildActionParam(RCSRemoteResourceObjectPtr, member);
- });
-
- if(isRegistered)
+ if(pRCSRemoteResourceObject == nullptr)
{
- throw InvalidAddMemberRequestException(
- "It is already registered member. Please set Execution Parameter!");
- }
-
- if(foundMember)
- {
- return SceneAction::Ptr(new SceneAction(foundMember, m_name, attr));
+ throw RCSInvalidParameterException("pRCSRemoteResourceObject is empty!");
}
SceneMemberResource::Ptr sceneMemberResObj;
sceneMemberResObj = SceneMemberResource::createSceneMemberResource(
- RCSRemoteResourceObjectPtr);
+ pRCSRemoteResourceObject);
try
{
- m_sceneCollectionResourceObj->addSceneMember(sceneMemberResObj);
+ m_sceneCollectionResource->addSceneMember(sceneMemberResObj);
}
- catch(std::exception e)
+ catch(std::exception& e)
{
- throw InvalidAddMemberRequestException(
- "It is already registered member. Please set Execution Parameter!");
+ auto sceneMemberRes = m_sceneCollectionResource->findSceneMembers(m_name);
+
+ auto it = std::find_if(sceneMemberRes.begin(), sceneMemberRes.end(),
+ [&pRCSRemoteResourceObject](const SceneMemberResource::Ptr& member)
+ {
+ return member->getRemoteResourceObject() == pRCSRemoteResourceObject;
+ }
+ );
+
+ if(it != sceneMemberRes.end())
+ {
+ throw InvalidAddMemberRequestException(
+ "It is already registered member. Please set Execution Parameter!");
+ }
+
+ auto sceneMembers = m_sceneCollectionResource->getSceneMembers();
+ auto memberRes = std::find_if(sceneMembers.begin(), sceneMembers.end(),
+ [&pRCSRemoteResourceObject](const SceneMemberResource::Ptr& member)
+ {
+ return member->getRemoteResourceObject() == pRCSRemoteResourceObject;
+ }
+ );
+ return SceneAction::Ptr(new SceneAction((*memberRes), m_name, attr));
}
return SceneAction::Ptr(new SceneAction(sceneMemberResObj, m_name, attr));
-
}
SceneAction::Ptr Scene::getSceneAction(
- const RCSRemoteResourceObject::Ptr& RCSRemoteResourceObjectPtr) const
+ const RCSRemoteResourceObject::Ptr& pRCSRemoteResourceObject) const
{
- auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
+ auto sceneMemberRes = m_sceneCollectionResource->findSceneMembers(m_name);
- RCSResourceAttributes actionParam;
- SceneMemberResource::Ptr foundMember;
-
- std::function<void(const RCSRemoteResourceObject::Ptr&,
- const SceneMemberResource::Ptr&)> buildActionParam = [&](
- const RCSRemoteResourceObject::Ptr & RCSRemoteResourceObjectPtr,
- const SceneMemberResource::Ptr & member)
- {
- if(RCSRemoteResourceObjectPtr == member->getRemoteResourceObject())
- {
- foundMember = member;
- for(const auto &it: member->getMappingInfos())
- {
- if(it.sceneName == m_name)
- {
- actionParam[it.key] = it.value;
- }
- }
- }
- };
-
- std::for_each (sceneMemberResObjs.begin(), sceneMemberResObjs.end(),
- [&RCSRemoteResourceObjectPtr, &buildActionParam](
- const SceneMemberResource::Ptr& member)
+ auto it = std::find_if(sceneMemberRes.begin(), sceneMemberRes.end(),
+ [&pRCSRemoteResourceObject](const SceneMemberResource::Ptr& member)
{
- buildActionParam(RCSRemoteResourceObjectPtr, member);
- });
+ return member->getRemoteResourceObject() == pRCSRemoteResourceObject;
+ }
+ );
- if(actionParam.empty())
+ if(it == sceneMemberRes.end())
{
throw RCSInvalidParameterException("Unknown Remote Resource!");
}
- return SceneAction::Ptr(new SceneAction(foundMember, m_name, actionParam));
+ RCSResourceAttributes actionParam;
+ for(const auto &info : (*it)->findMappingInfos(m_name))
+ {
+ actionParam[info.key] = info.value;
+ }
+
+ return SceneAction::Ptr(new SceneAction((*it), m_name, actionParam));
}
std::vector<SceneAction::Ptr> Scene::getSceneActions() const
{
std::vector<SceneAction::Ptr> actions;
- auto sceneMemberResObjs = m_sceneCollectionResourceObj->getSceneMembers();
+ auto sceneMemberRes = m_sceneCollectionResource->findSceneMembers(m_name);
- RCSResourceAttributes actionParam;
-
- std::function<void(const SceneMemberResource::Ptr&)> buildActionParams =
- [&](const SceneMemberResource::Ptr & member)
- {
- for(const auto &it: member->getMappingInfos())
- {
- if(it.sceneName == m_name)
- {
- actionParam[it.key] = it.value;
- }
- }
- if(!actionParam.empty())
- {
- actions.push_back(SceneAction::Ptr(
- new SceneAction(member, m_name, actionParam)));
- actionParam.clear();
- }
- };
+ std::for_each(sceneMemberRes.begin(), sceneMemberRes.end(),
+ [&actions, &m_name](const SceneMemberResource::Ptr& member)
+ {
+ RCSResourceAttributes actionParam;
- std::for_each (sceneMemberResObjs.begin(), sceneMemberResObjs.end(),
- [&buildActionParams](const SceneMemberResource::Ptr& member)
+ for(const auto &it : member->findMappingInfos(m_name))
{
- buildActionParams(member);
- });
+ actionParam[it.key] = it.value;
+ }
+ actions.push_back(SceneAction::Ptr(
+ new SceneAction(member, m_name, actionParam)));
+ }
+ );
return actions;
}
return m_name;
}
- void Scene::removeSceneAction(const SceneAction::Ptr& /*sceneActionPtr*/)
- {
-// TODO : need to implement
- }
-
- void Scene::removeSceneAction(
- const RCSRemoteResourceObject::Ptr& /*RCSRemoteResourceObjectPtr*/)
- {
-// TODO : : need to implement
- }
-
void Scene::execute(ExecuteCallback cb)
{
if(cb == nullptr)
throw RCSInvalidParameterException("Callback is empty!");
}
- m_sceneCollectionResourceObj->execute(m_name, cb);
+ m_sceneCollectionResource->execute(m_name, std::move(cb));
}
} /* namespace Service */
} /* namespace OIC */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneAction.h"
+
#include "SceneMemberResource.h"
namespace OIC
const std::string& sceneName, const RCSResourceAttributes& attr) :
m_pRemoteResourceObject(SceneMemberResource->getRemoteResourceObject()),
m_sceneName(sceneName),
- m_sceneMemberResourceObj(SceneMemberResource)
+ m_sceneMemberResource(SceneMemberResource)
{
for (const auto& it : attr)
{
- m_sceneMemberResourceObj->addMappingInfo(
+ m_sceneMemberResource->addMappingInfo(
SceneMemberResource::MappingInfo(m_sceneName, it.key(), it.value()));
}
}
const std::string& sceneName, const std::string& key,
const RCSResourceAttributes::Value& value) :
m_pRemoteResourceObject(SceneMemberResource->getRemoteResourceObject()),
- m_sceneName(sceneName), m_sceneMemberResourceObj(SceneMemberResource)
+ m_sceneName(sceneName), m_sceneMemberResource(SceneMemberResource)
{
- m_sceneMemberResourceObj->addMappingInfo(
+ m_sceneMemberResource->addMappingInfo(
SceneMemberResource::MappingInfo(m_sceneName, key, value));
}
- void SceneAction::setExecutionParameter(const std::string& key,
+ void SceneAction::resetExecutionParameter(const std::string& key,
RCSResourceAttributes::Value value)
{
RCSResourceAttributes attr;
attr[key] = value;
- setExecutionParameter(attr);
+ resetExecutionParameter(attr);
}
- void SceneAction::setExecutionParameter(const RCSResourceAttributes& attr)
+ void SceneAction::resetExecutionParameter(const RCSResourceAttributes& attr)
{
for(const auto& it : attr)
{
- m_sceneMemberResourceObj->addMappingInfo(
+ m_sceneMemberResource->addMappingInfo(
SceneMemberResource::MappingInfo(m_sceneName, it.key(), it.value()));
}
}
- const RCSResourceAttributes SceneAction::getExecutionParameter()
+ RCSResourceAttributes SceneAction::getExecutionParameter() const
{
RCSResourceAttributes attr;
- for(const auto& it : m_sceneMemberResourceObj->getMappingInfos())
+ for(const auto& it : m_sceneMemberResource->getMappingInfos())
{
if(it.sceneName == m_sceneName)
{
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneCollection.h"
+
#include "SceneCollectionResource.h"
namespace OIC
{
SceneCollection::SceneCollection(
const SceneCollectionResource::Ptr& sceneCollectionResource) :
- m_sceneCollectionResourceObj(sceneCollectionResource) {}
+ m_sceneCollectionResource(sceneCollectionResource) {}
Scene::Ptr SceneCollection::addNewScene(const std::string& sceneName)
{
throw RCSInvalidParameterException("Scene name is an empty string");
}
- m_sceneCollectionResourceObj->addScene(sceneName);
- return Scene::Ptr(new Scene(sceneName, m_sceneCollectionResourceObj));
+ m_sceneCollectionResource->addScene(sceneName);
+ return Scene::Ptr(new Scene(sceneName, m_sceneCollectionResource));
}
std::unordered_map< std::string, Scene::Ptr > SceneCollection::getScenes() const
{
std::unordered_map< std::string, Scene::Ptr > scenes;
- auto sceneValues = m_sceneCollectionResourceObj->getSceneValues();
- for(const auto &it : sceneValues)
+ for(const auto &it : m_sceneCollectionResource->getSceneValues())
{
- Scene::Ptr scenePtr(new Scene(it, m_sceneCollectionResourceObj));
+ Scene::Ptr scenePtr(new Scene(it, m_sceneCollectionResource));
scenes.insert(std::pair< std::string, Scene::Ptr >(it, scenePtr));
}
return scenes;
Scene::Ptr SceneCollection::getScene(const std::string& sceneName) const
{
- auto sceneValues = m_sceneCollectionResourceObj->getSceneValues();
+ auto sceneValues = m_sceneCollectionResource->getSceneValues();
auto it = std::find(sceneValues.begin(), sceneValues.end(), sceneName);
if(it != sceneValues.end())
{
throw RCSInvalidParameterException("Scene Name is Invalid!");
}
- return Scene::Ptr(new Scene(sceneName, m_sceneCollectionResourceObj));
- }
-
- void SceneCollection::removeScene(Scene::Ptr scenePtr)
- {
-// TODO : : need to implement
- if (scenePtr == nullptr)
- {
- throw RCSInvalidParameterException("Scene Ptr is empty!");
- }
+ return Scene::Ptr(new Scene(sceneName, m_sceneCollectionResource));
}
void SceneCollection::setName(const std::string& name)
{
- m_sceneCollectionResourceObj->setName(name);
+ m_sceneCollectionResource->setName(name);
}
std::string SceneCollection::getName() const
{
- return m_sceneCollectionResourceObj->getName();
+ return m_sceneCollectionResource->getName();
}
std::string SceneCollection::getId() const
{
- return m_sceneCollectionResourceObj->getId();
+ return m_sceneCollectionResource->getId();
}
+
} /* namespace Service */
} /* namespace OIC */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneList.h"
+
#include "SceneListResource.h"
#include "SceneCollectionResource.h"
std::vector< SceneCollection::Ptr > SceneList::getSceneCollections() const
{
std::vector<SceneCollection::Ptr> sceneCollections;
- auto sceneCollectionResObjs = SceneListResource::getInstance()->getSceneCollections();
- for(const auto& it : sceneCollectionResObjs)
+ for(const auto& it : SceneListResource::getInstance()->getSceneCollections())
{
SceneCollection::Ptr sceneCollectionPtr(new SceneCollection(it));
sceneCollections.push_back(sceneCollectionPtr);
return sceneCollections;
}
- void SceneList::removeSceneCollection(SceneCollection::Ptr sceneCollectionPtr)
- {
-// TODO : need to implement
- if (sceneCollectionPtr == nullptr)
- {
- throw RCSInvalidParameterException
- { "Scene Collection Ptr is empty!" };
- }
- }
-
void SceneList::setName(const std::string& sceneListName)
{
SceneListResource::getInstance()->setName(sceneListName);
constexpr char RESOURCE_URI2[]{ "/a/fan" };
constexpr char RESOURCE_TYPE2[]{ "core.fan" };
constexpr char KEY[]{ "power" };
-constexpr char VALUE[]{ "off" };
+constexpr char VALUE[]{ "on" };
constexpr char KEY_2[]{ "state" };
constexpr char VALUE_2[]{ "100" };
createSceneCollectionAndScene();
createSceneAction();
- pSceneAction1->setExecutionParameter(KEY, "off");
+ pSceneAction1->resetExecutionParameter(KEY, "off");
for(const auto &it : pSceneAction1->getExecutionParameter())
{
ASSERT_EQ(it.key(), KEY);
createSceneAction();
ASSERT_EQ(pSceneAction1->getRemoteResourceObject(), pRemoteResource1);
-}
+}
\ No newline at end of file
createScene();
auto pSceneAction1 = pScene1->addNewSceneAction(pRemoteResource1, KEY, VALUE);
- pSceneAction1->setExecutionParameter(KEY_2, VALUE_2);
+ pSceneAction1->resetExecutionParameter(KEY_2, VALUE_2);
ASSERT_EQ(pScene1->getSceneAction(pRemoteResource1)->getExecutionParameter(),
pSceneAction1->getExecutionParameter());
createScene();
auto pSceneAction1 = pScene1->addNewSceneAction(pRemoteResource1, KEY, VALUE);
-// auto pSceneAction2 = pScene1->addNewSceneAction(pRemoteResource2, KEY, VALUE);
+ auto pSceneAction2 = pScene1->addNewSceneAction(pRemoteResource2, KEY, VALUE);
for(const auto & it : pScene1->getSceneActions())
{
pScene1->addNewSceneAction(pRemoteResource2, KEY_2, VALUE_2);
ASSERT_THROW(pScene1->execute(nullptr), RCSInvalidParameterException);
-}
-
-//TEST_F(SceneTest, executeSceneByNotExistedSceneName)
-//{
-//
-//}
-
+}
\ No newline at end of file
projects / platform / upstream / iotivity.git / commitdiff