#include <atomic>
#include "OCApi.h"
#include "RCSRequest.h"
+#include "RCSSeparateResponse.h"
namespace OIC
{
SceneCollectionResource::Ptr
SceneCollectionResource::createSceneCollectionObject()
{
- auto instance = new SceneCollectionResource();
- SceneCollectionResource::Ptr newSceneCollectionObject;
- newSceneCollectionObject.reset(instance);
+ SceneCollectionResource::Ptr newSceneCollectionObject(new SceneCollectionResource());
- newSceneCollectionObject->m_Uri
+ newSceneCollectionObject->m_uri
= PREFIX_SCENE_COLLECTION_URI + "/" + std::to_string(numOfSceneCollection++);
- newSceneCollectionObject->m_SceneCollectionResourceObj
+ newSceneCollectionObject->m_address = SceneUtils::getNetAddress();
+
+ newSceneCollectionObject->createResourceObject();
+
+ newSceneCollectionObject->setDefaultAttributes();
+
+ newSceneCollectionObject->initSetRequestHandler();
+
+ return newSceneCollectionObject;
+ }
+
+ void SceneCollectionResource::createResourceObject()
+ {
+ m_sceneCollectionResourceObj
= RCSResourceObject::Builder(
- newSceneCollectionObject->m_Uri,
- SCENE_COLLECTION_RT, OC_RSRVD_INTERFACE_DEFAULT).
+ m_uri, SCENE_COLLECTION_RT, OC_RSRVD_INTERFACE_DEFAULT).
addInterface(OC::BATCH_INTERFACE).
setDiscoverable(true).setObservable(false).build();
+ }
- auto collectionObj = newSceneCollectionObject->m_SceneCollectionResourceObj;
- {
- RCSResourceObject::LockGuard guard(collectionObj);
- collectionObj->setAttribute(SCENE_KEY_LAST_SCENE, std::string());
- collectionObj->setAttribute(SCENE_KEY_NAME, std::string());
- collectionObj->setAttribute(SCENE_KEY_ID, SceneUtils::OICGenerateUUIDStr());
- collectionObj->setAttribute(SCENE_KEY_RTS, SCENE_MEMBER_RT);
- collectionObj->setAttribute(SCENE_KEY_SCENEVALUES, std::vector<std::string>());
- }
+ void SceneCollectionResource::setDefaultAttributes()
+ {
+ m_sceneCollectionResourceObj->setAttribute(SCENE_KEY_LAST_SCENE, std::string());
+ m_sceneCollectionResourceObj->setAttribute(SCENE_KEY_NAME, std::string());
+ m_sceneCollectionResourceObj->setAttribute(
+ SCENE_KEY_ID, SceneUtils::OICGenerateUUIDStr());
+ m_sceneCollectionResourceObj->setAttribute(SCENE_KEY_RTS, SCENE_MEMBER_RT);
+ m_sceneCollectionResourceObj->setAttribute(
+ SCENE_KEY_SCENEVALUES, std::vector<std::string>());
+ m_sceneCollectionResourceObj->setAttribute(SCENE_KEY_URI, m_uri);
+ }
- newSceneCollectionObject->m_RequestHandler.m_Owner
- = std::weak_ptr<SceneCollectionResource>(newSceneCollectionObject);
+ void SceneCollectionResource::initSetRequestHandler()
+ {
+ m_requestHandler.m_owner
+ = std::weak_ptr<SceneCollectionResource>(shared_from_this());
- collectionObj->setSetRequestHandler(std::bind(
+ m_sceneCollectionResourceObj->setSetRequestHandler(std::bind(
&SceneCollectionResource::SceneCollectionRequestHandler::onSetRequest,
- newSceneCollectionObject->m_RequestHandler,
- std::placeholders::_1, std::placeholders::_2));
-
- newSceneCollectionObject->m_Address = SceneUtils::getNetAddress();
-
- return newSceneCollectionObject;
+ m_requestHandler, std::placeholders::_1, std::placeholders::_2));
}
void SceneCollectionResource::addScene(const std::string & newScene)
void SceneCollectionResource::addScene(std::string && newScene)
{
- auto sceneValues = m_SceneCollectionResourceObj->getAttributeValue(
+ auto sceneValues = m_sceneCollectionResourceObj->getAttributeValue(
SCENE_KEY_SCENEVALUES).get< std::vector< std::string > >();
auto foundScene
{
sceneValues.push_back(std::move(newScene));
- RCSResourceObject::LockGuard guard(m_SceneCollectionResourceObj);
- m_SceneCollectionResourceObj->setAttribute(
- SCENE_KEY_SCENEVALUES, sceneValues);
+ m_sceneCollectionResourceObj->setAttribute(SCENE_KEY_SCENEVALUES, sceneValues);
}
}
void SceneCollectionResource::addSceneMember(
SceneMemberResource::Ptr newMember)
{
- std::unique_lock<std::mutex> memberlock(m_SceneMemberLock);
+ std::lock_guard<std::mutex> memberlock(m_sceneMemberLock);
- struct FindMember
- {
- bool operator()(SceneMemberResource::Ptr ptr) const
- {
- return ptr->getFullUri() == name;
- }
- std::string name;
- };
- FindMember fMember;
- fMember.name = newMember->getFullUri();
- auto foundmember = std::find_if(
- m_SceneMembers.begin(), m_SceneMembers.end(), fMember);
- if (foundmember != m_SceneMembers.end())
+ auto foundmember = std::find_if(m_sceneMembers.begin(), m_sceneMembers.end(),
+ [& newMember](const SceneMemberResource::Ptr & ptr) -> bool
+ {
+ return ptr->getFullUri() == newMember->getFullUri();
+ });
+
+ if (foundmember != m_sceneMembers.end())
{
- // TODO will change to Scene Exception.
throw std::exception();
}
- m_SceneMembers.push_back(newMember);
- m_SceneCollectionResourceObj->bindResource(newMember->getRCSResourceObject());
+ m_sceneMembers.push_back(newMember);
+ m_sceneCollectionResourceObj->bindResource(newMember->getRCSResourceObject());
}
void SceneCollectionResource::execute(std::string && sceneName)
void SceneCollectionResource::execute(
std::string && sceneName, SceneExecuteCallback executeCB)
{
- auto sceneValues = m_SceneCollectionResourceObj->getAttributeValue(
+ auto sceneValues = m_sceneCollectionResourceObj->getAttributeValue(
SCENE_KEY_SCENEVALUES).get< std::vector< std::string > >();
+
auto foundSceneValue
= std::find(sceneValues.begin(), sceneValues.end(), sceneName);
-
- if (foundSceneValue == sceneValues.end())
+ if (foundSceneValue == sceneValues.end() && executeCB)
{
- if (executeCB)
- {
- executeCB(SCENE_CLIENT_BADREQUEST);
- }
+ std::thread(executeCB, SCENE_CLIENT_BADREQUEST).detach();
return;
}
= SceneExecuteResponseHandler::createExecuteHandler(
shared_from_this(), std::move(executeCB));
- std::unique_lock<std::mutex> handlerlock(m_ExecuteHandlerLock);
- m_ExecuteHandlers.push_back(executeHandler);
- handlerlock.unlock();
+ {
+ std::lock_guard<std::mutex> handlerlock(m_executeHandlerLock);
+ m_executeHandlers.push_back(executeHandler);
+ }
- std::unique_lock<std::mutex> memberlock(m_SceneMemberLock);
- for (unsigned int it = 0; it < m_SceneMembers.size(); ++it)
{
- m_SceneMembers[it]->execute(sceneName, std::bind(
- &SceneExecuteResponseHandler::onResponse, executeHandler,
- std::placeholders::_1, std::placeholders::_2));
+ std::lock_guard<std::mutex> memberlock(m_sceneMemberLock);
+ for (auto & it : m_sceneMembers)
+ {
+ it->execute(sceneName, std::bind(
+ &SceneExecuteResponseHandler::onResponse, executeHandler,
+ std::placeholders::_1, std::placeholders::_2));
+ }
}
- memberlock.unlock();
- RCSResourceObject::LockGuard guard(m_SceneCollectionResourceObj);
- m_SceneCollectionResourceObj->setAttribute(SCENE_KEY_LAST_SCENE, sceneName);
+ m_sceneCollectionResourceObj->setAttribute(SCENE_KEY_LAST_SCENE, sceneName);
}
void SceneCollectionResource::onExecute(
int errorCode, SceneExecuteCallback cb, SceneExecuteResponseHandler::Ptr ptr)
{
- std::unique_lock<std::mutex> handlerlock(m_ExecuteHandlerLock);
- m_ExecuteHandlers.remove(ptr);
- handlerlock.unlock();
+ {
+ std::lock_guard<std::mutex> handlerlock(m_executeHandlerLock);
+ m_executeHandlers.remove(ptr);
+ }
- cb(errorCode);
+ std::thread(cb, errorCode).detach();
}
std::string SceneCollectionResource::getId() const
{
- return m_SceneCollectionResourceObj->
- getAttributeValue(SCENE_KEY_ID).get<std::string>();
+ return m_sceneCollectionResourceObj->getAttributeValue(
+ SCENE_KEY_ID).get<std::string>();
}
std::string SceneCollectionResource::getUri() const
{
- return m_Uri;
+ return m_uri;
}
std::string SceneCollectionResource::getAddress() const
{
- return m_Address;
+ return m_address;
}
- const std::vector<SceneMemberResource::Ptr>
- SceneCollectionResource::getSceneMembers()
+ std::vector<std::string> SceneCollectionResource::getSceneValues() const
{
- std::unique_lock<std::mutex> memberlock(m_SceneMemberLock);
- std::vector<SceneMemberResource::Ptr> retMembers(m_SceneMembers);
- return retMembers;
+ return m_sceneCollectionResourceObj->getAttributeValue(
+ SCENE_KEY_SCENEVALUES).get<std::vector<std::string>>();
+ }
+
+ std::vector<SceneMemberResource::Ptr> SceneCollectionResource::getSceneMembers() const
+ {
+ return m_sceneMembers;
}
RCSResourceObject::Ptr SceneCollectionResource::getRCSResourceObject() const
{
- return m_SceneCollectionResourceObj;
+ return m_sceneCollectionResourceObj;
}
void SceneCollectionResource::setName(std::string && sceneCollectionName)
{
- RCSResourceObject::LockGuard guard(m_SceneCollectionResourceObj);
- m_SceneCollectionResourceObj->setAttribute(
+ m_sceneCollectionResourceObj->setAttribute(
SCENE_KEY_NAME, std::move(sceneCollectionName));
}
std::string SceneCollectionResource::getName() const
{
- return m_SceneCollectionResourceObj->getAttributeValue(
+ return m_sceneCollectionResourceObj->getAttributeValue(
SCENE_KEY_NAME).get<std::string>();
}
return executeSceneRequest(request, attributes);
}
- return RCSSetResponse::create(attributes, (int)SCENE_CLIENT_BADREQUEST)
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ if (attributes.contains(SCENE_KEY_NAME))
+ {
+ return setSceneCollectionName(request, attributes);
+ }
+
+ return RCSSetResponse::create(attributes, (int)SCENE_CLIENT_BADREQUEST).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
addSceneRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
{
- SceneCollectionResource::Ptr ptr = m_Owner.lock();
+ SceneCollectionResource::Ptr ptr = m_owner.lock();
if (ptr == nullptr)
{
- return RCSSetResponse::create(
- RCSResourceAttributes(attributes), SCENE_CLIENT_BADREQUEST).
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- auto scenes = attributes.at(SCENE_KEY_SCENEVALUES).get<std::vector<std::string>>();
-
- for(unsigned int it = 0; it < scenes.size(); ++it)
- {
- ptr->addScene(scenes[it]);
- }
+ auto values = attributes.at(SCENE_KEY_SCENEVALUES).get<std::vector<std::string>>();
+ std::for_each (values.begin(), values.end(),
+ [& ptr](const std::string & value)
+ {
+ ptr->addScene(value);
+ });
- return RCSSetResponse::create(RCSResourceAttributes(attributes)).
+ return RCSSetResponse::create(attributes).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
- executeSceneRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
+ executeSceneRequest(const RCSRequest & request, RCSResourceAttributes & attributes)
{
- SceneCollectionResource::Ptr ptr = m_Owner.lock();
+ SceneCollectionResource::Ptr ptr = m_owner.lock();
if (ptr == nullptr)
{
- return RCSSetResponse::create(
- RCSResourceAttributes(attributes), SCENE_CLIENT_BADREQUEST).
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- auto request_key = attributes.at(SCENE_KEY_LAST_SCENE).get<std::string>();
- ptr->execute(std::string(request_key), std::bind(
+ auto requestKey = attributes.at(SCENE_KEY_LAST_SCENE).get<std::string>();
+
+ RCSRequest req(request.getResourceObject().lock(), request.getOCRequest());
+ ptr->execute(std::string(requestKey), std::bind(
&SceneCollectionResource::SceneCollectionRequestHandler::onExecute, this,
- std::placeholders::_1,
- attributes));
+ std::placeholders::_1, req, attributes));
- // TODO slow response
- return RCSSetResponse::create(RCSResourceAttributes(attributes))
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ return RCSSetResponse::separate();
}
RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
createSceneMemberRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
{
- SceneCollectionResource::Ptr ptr = m_Owner.lock();
+ SceneCollectionResource::Ptr ptr = m_owner.lock();
if (ptr == nullptr || !attributes.contains(SCENE_KEY_PAYLOAD_LINK))
{
- return RCSSetResponse::create(
- RCSResourceAttributes(attributes), SCENE_CLIENT_BADREQUEST).
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
auto linkAtt = attributes.at(SCENE_KEY_PAYLOAD_LINK).get<RCSResourceAttributes>();
-
- auto memberObj
- = SceneMemberResource::createSceneMemberResource(linkAtt);
-
- try
+ if (!linkAtt.contains(SCENE_KEY_HREF) ||
+ !linkAtt.contains(SCENE_KEY_RT) || !linkAtt.contains(SCENE_KEY_IF))
{
- ptr->addSceneMember(memberObj);
- } catch (...)
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ auto memberObj = createSceneMemberFromRemote(linkAtt);
+ if (memberObj == nullptr)
{
- memberObj.reset();
- return RCSSetResponse::create(
- RCSResourceAttributes(attributes), SCENE_CLIENT_BADREQUEST).
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
if (attributes.contains(SCENE_KEY_SCENEMAPPINGS))
{
- auto sceneMappings
- = attributes.at(SCENE_KEY_SCENEMAPPINGS).get<std::vector<RCSResourceAttributes>>();
- for (unsigned int it = 0; it < sceneMappings.size(); ++it)
- {
- memberObj->addMappingInfo(SceneMemberResource::MappingInfo(
- sceneMappings[it].at(SCENE_KEY_SCENE).get<std::string>(),
- sceneMappings[it].at(SCENE_KEY_MEMBERPROPERTY).get<std::string>(),
- sceneMappings[it].at(SCENE_KEY_MEMBERVALUE)));
- }
+ addMemberInfoFromRemote(memberObj, attributes.at(
+ SCENE_KEY_SCENEMAPPINGS).get<std::vector<RCSResourceAttributes>>());
}
RCSResourceAttributes responseAtt(attributes);
responseAtt[SCENE_KEY_CREATEDLINK]
= RCSResourceAttributes::Value(memberObj->getFullUri());
- return RCSSetResponse::create(responseAtt)
- .setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ return RCSSetResponse::create(responseAtt).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ RCSSetResponse
+ SceneCollectionResource::SceneCollectionRequestHandler::setSceneCollectionName(
+ const RCSRequest & /*request*/, RCSResourceAttributes & attr)
+ {
+ SceneCollectionResource::Ptr ptr = m_owner.lock();
+ if (ptr == nullptr)
+ {
+ return RCSSetResponse::create(attr, SCENE_CLIENT_BADREQUEST).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ ptr->setName(attr.at(SCENE_KEY_NAME).get<std::string>());
+
+ return RCSSetResponse::create(attr).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ SceneMemberResource::Ptr
+ SceneCollectionResource::SceneCollectionRequestHandler::createSceneMemberFromRemote(
+ RCSResourceAttributes & linkAtt)
+ {
+ auto memberObj = SceneMemberResource::createSceneMemberResource(linkAtt);
+
+ try
+ {
+ SceneCollectionResource::Ptr ptr = m_owner.lock();
+ ptr->addSceneMember(memberObj);
+ } catch (...)
+ {
+ return nullptr;
+ }
+
+ return memberObj;
+ }
+
+ void SceneCollectionResource::SceneCollectionRequestHandler::addMemberInfoFromRemote(
+ SceneMemberResource::Ptr memberObj, std::vector<RCSResourceAttributes> mInfo)
+ {
+ std::for_each (mInfo.begin(), mInfo.end(),
+ [& memberObj](const RCSResourceAttributes & att)
+ {
+ memberObj->addMappingInfo(SceneMemberResource::MappingInfo(
+ att.at(SCENE_KEY_SCENE).get<std::string>(),
+ att.at(SCENE_KEY_MEMBERPROPERTY).get<std::string>(),
+ att.at(SCENE_KEY_MEMBERVALUE)));
+ });
}
void SceneCollectionResource::SceneCollectionRequestHandler::
- onExecute(int /*errorCode*/, /*const RCSRequest & request,*/ RCSResourceAttributes & /*att*/)
+ onExecute(int /*errorCode*/, const RCSRequest & request, RCSResourceAttributes & /*att*/)
{
- // TODO slow response
+ // TODO need to set error code.
+ // and need to set specific attr' but this attr not to be apply to RCSResourceObject.
+ RCSSeparateResponse(request).set();
}
void SceneCollectionResource::SceneExecuteResponseHandler::
}
if (m_responseMembers == m_numOfMembers)
{
- m_Cb(m_errorCode);
+ m_cb(m_errorCode);
}
}
{
auto executeHandler = std::make_shared<SceneExecuteResponseHandler>();
- executeHandler->m_numOfMembers = ptr->m_SceneMembers.size();
+ executeHandler->m_numOfMembers = ptr->m_sceneMembers.size();
executeHandler->m_responseMembers = 0;
- executeHandler->m_Cb = std::bind(
+ executeHandler->m_cb = std::bind(
&SceneCollectionResource::onExecute, ptr,
std::placeholders::_1, std::move(executeCB), executeHandler);
- executeHandler->m_Owner
+ executeHandler->m_owner
= std::weak_ptr<SceneCollectionResource>(ptr);
executeHandler->m_errorCode = SCENE_RESPONSE_SUCCESS;
}
}
}
+
void setName(std::string &&);
void setName(const std::string &);
+ std::vector<std::string> getSceneValues() const;
+
std::string getName() const;
std::string getId() const;
std::string getUri() const;
std::string getAddress() const;
- const std::vector<SceneMemberResource::Ptr> getSceneMembers();
+ std::vector<SceneMemberResource::Ptr> getSceneMembers() const;
RCSResourceObject::Ptr getRCSResourceObject() const;
public:
typedef std::shared_ptr<SceneExecuteResponseHandler> Ptr;
- SceneExecuteResponseHandler() = default;
+ SceneExecuteResponseHandler()
+ : m_numOfMembers(0), m_responseMembers(0), m_errorCode(0) { }
~SceneExecuteResponseHandler() = default;
int m_numOfMembers;
int m_responseMembers;
int m_errorCode;
- std::weak_ptr<SceneCollectionResource> m_Owner;
- SceneExecuteCallback m_Cb;
+ std::weak_ptr<SceneCollectionResource> m_owner;
+ SceneExecuteCallback m_cb;
static SceneExecuteResponseHandler::Ptr createExecuteHandler(
const SceneCollectionResource::Ptr, SceneExecuteCallback);
SceneCollectionRequestHandler() = default;
~SceneCollectionRequestHandler() = default;
- std::weak_ptr<SceneCollectionResource> m_Owner;
+ std::weak_ptr<SceneCollectionResource> m_owner;
RCSSetResponse onSetRequest(
const RCSRequest &, RCSResourceAttributes &);
- void onExecute(int, /*const RCSRequest &,*/ RCSResourceAttributes &);
+ void onExecute(int, const RCSRequest &, RCSResourceAttributes &);
private:
RCSSetResponse addSceneRequest(
const RCSRequest &, RCSResourceAttributes &);
RCSSetResponse createSceneMemberRequest(
const RCSRequest &, RCSResourceAttributes &);
+ RCSSetResponse setSceneCollectionName(
+ const RCSRequest &, RCSResourceAttributes &);
+
+ SceneMemberResource::Ptr createSceneMemberFromRemote(RCSResourceAttributes &);
+ void addMemberInfoFromRemote(SceneMemberResource::Ptr,
+ std::vector<RCSResourceAttributes>);
};
- std::string m_Uri;
- std::string m_Address;
+ std::string m_uri;
+ std::string m_address;
- RCSResourceObject::Ptr m_SceneCollectionResourceObj;
- std::mutex m_SceneMemberLock;
- std::vector<SceneMemberResource::Ptr> m_SceneMembers;
+ RCSResourceObject::Ptr m_sceneCollectionResourceObj;
+ std::mutex m_sceneMemberLock;
+ std::vector<SceneMemberResource::Ptr> m_sceneMembers;
- SceneCollectionRequestHandler m_RequestHandler;
- std::mutex m_ExecuteHandlerLock;
- std::list<SceneExecuteResponseHandler::Ptr> m_ExecuteHandlers;
+ SceneCollectionRequestHandler m_requestHandler;
+ std::mutex m_executeHandlerLock;
+ std::list<SceneExecuteResponseHandler::Ptr> m_executeHandlers;
SceneCollectionResource() = default;
const SceneCollectionResource &) = delete;
SceneCollectionResource(SceneCollectionResource &&) = delete;
- SceneCollectionResource && operator = (
+ SceneCollectionResource & operator = (
SceneCollectionResource &&) = delete;
+ void createResourceObject();
+ void setDefaultAttributes();
+ void initSetRequestHandler();
+
void onExecute(int, SceneExecuteCallback, SceneExecuteResponseHandler::Ptr);
};
}
#endif // SCENE_COLLECTION_RESOURCE_OBJECT_H
+
const std::string SCENE_KEY_MEMBERVALUE = "memberValue";
const std::string SCENE_KEY_CREATEDLINK = "createdlink";
+ const std::string SCENE_KEY_URI = "uri";
+ const std::string SCENE_KEY_CHILD = "child";
+
const std::string SCENE_LIST_RT = "oic.wk.scenelist";
const std::string SCENE_MEMBER_RT = "oic.r.scenemember";
const std::string SCENE_COLLECTION_RT = "oic.wk.scenecollection";
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+#include "SceneListResource.h"
+
#include "RCSRequest.h"
#include "OCApi.h"
-#include "SceneListResource.h"
namespace OIC
{
namespace Service
{
SceneListResource::SceneListResource()
- : m_SceneListName(), m_SceneListObj(), m_RequestHandler()
+ : m_sceneListName(), m_sceneListObj()
{
- m_SceneListObj = RCSResourceObject::Builder(
+ m_sceneListObj = RCSResourceObject::Builder(
SCENE_LIST_URI, SCENE_LIST_RT, OC_RSRVD_INTERFACE_DEFAULT).
addInterface(OC::BATCH_INTERFACE).
setDiscoverable(true).setObservable(false).build();
- {
- RCSResourceObject::LockGuard guard(m_SceneListObj);
- m_SceneListObj->setAttribute(SCENE_KEY_NAME, SCENE_LIST_DEFAULT_NAME);
- m_SceneListObj->setAttribute(SCENE_KEY_RTS, SCENE_LIST_RT);
- }
+ m_sceneListObj->setAttribute(SCENE_KEY_NAME, SCENE_LIST_DEFAULT_NAME);
+ m_sceneListObj->setAttribute(SCENE_KEY_RTS, SCENE_LIST_RT);
- m_SceneListObj->setSetRequestHandler(&SceneListRequestHandler::onSetRequest);
+ m_sceneListObj->setSetRequestHandler(&SceneListRequestHandler::onSetRequest);
+ m_sceneListObj->setGetRequestHandler(&SceneListRequestHandler::onGetRequest);
}
SceneListResource * SceneListResource::getInstance()
void SceneListResource::addSceneCollectionResource(
SceneCollectionResource::Ptr newObject)
{
- std::unique_lock<std::mutex> collectionlock(m_SceneCollectionLock);
- m_SceneCollections.push_back(newObject);
- m_SceneListObj->bindResource(newObject->getRCSResourceObject());
+ std::lock_guard<std::mutex> collectionlock(m_sceneCollectionLock);
+ m_sceneCollections.push_back(newObject);
+ m_sceneListObj->bindResource(newObject->getRCSResourceObject());
}
std::string SceneListResource::getName() const
{
- return m_SceneListName;
+ return m_sceneListName;
}
void SceneListResource::setName(std::string && newName)
{
- m_SceneListName = newName;
+ m_sceneListName = std::move(newName);
- RCSResourceObject::LockGuard guard(m_SceneListObj);
- m_SceneListObj->setAttribute(SCENE_KEY_NAME, m_SceneListName);
+ RCSResourceObject::LockGuard guard(m_sceneListObj);
+ m_sceneListObj->setAttribute(SCENE_KEY_NAME, m_sceneListName);
}
void SceneListResource::setName(const std::string & newName)
setName(std::string(newName));
}
- const std::vector<SceneCollectionResource::Ptr>
- SceneListResource::getSceneCollections()
+ std::vector<SceneCollectionResource::Ptr> SceneListResource::getSceneCollections() const
{
- std::unique_lock<std::mutex> collectionlock(m_SceneCollectionLock);
- std::vector<SceneCollectionResource::Ptr> retCollections(m_SceneCollections);
- return retCollections;
+ return m_sceneCollections;
}
- RCSSetResponse
- SceneListResource::SceneListRequestHandler::onSetRequest(
+ std::vector<RCSResourceAttributes> SceneListResource::getChildrenAttributes() const
+ {
+ std::vector<RCSResourceAttributes> childrenAttrs;
+
+ auto sceneCollections = getSceneCollections();
+
+ std::for_each(sceneCollections.begin(), sceneCollections.end(),
+ [& childrenAttrs](const SceneCollectionResource::Ptr & pCollection)
+ {
+ RCSResourceAttributes collectionAttr;
+ {
+ RCSResourceObject::LockGuard guard(
+ pCollection->getRCSResourceObject());
+ collectionAttr = pCollection->getRCSResourceObject()->getAttributes();
+ }
+
+ auto sceneMembers = pCollection->getSceneMembers();
+ std::vector<RCSResourceAttributes> membersAttrs;
+
+ std::for_each(sceneMembers.begin(), sceneMembers.end(),
+ [& membersAttrs](const SceneMemberResource::Ptr & pMember)
+ {
+ RCSResourceObject::LockGuard guard(pMember->getRCSResourceObject());
+ membersAttrs.push_back(pMember->getRCSResourceObject()->getAttributes());
+ });
+
+ collectionAttr[SCENE_KEY_CHILD] = membersAttrs;
+
+ childrenAttrs.push_back(collectionAttr);
+ });
+
+ return childrenAttrs;
+ }
+
+ RCSSetResponse SceneListResource::SceneListRequestHandler::onSetRequest(
const RCSRequest & request, RCSResourceAttributes & attributes)
{
- if (request.getInterface() != OC::BATCH_INTERFACE)
+ if(request.getInterface() == OC::BATCH_INTERFACE)
{
- return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
+ auto newObject
+ = SceneCollectionResource::createSceneCollectionObject();
+
+ if (attributes.contains(SCENE_KEY_NAME))
+ {
+ newObject->setName(attributes.at(SCENE_KEY_NAME).get<std::string>());
+ }
+
+ SceneListResource::getInstance()->addSceneCollectionResource(newObject);
+
+ auto responseAtt = attributes;
+ responseAtt[SCENE_KEY_NAME] = RCSResourceAttributes::Value(newObject->getName());
+ responseAtt[SCENE_KEY_ID] = RCSResourceAttributes::Value(newObject->getId());
+
+ auto uri = COAP_TAG + newObject->getAddress() + newObject->getUri();
+ responseAtt[SCENE_KEY_PAYLOAD_LINK]
+ = RCSResourceAttributes::Value(uri);
+
+ return RCSSetResponse::create(responseAtt, SCENE_RESPONSE_SUCCESS).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- auto newObject
- = SceneCollectionResource::createSceneCollectionObject();
-
if (attributes.contains(SCENE_KEY_NAME))
{
- newObject->setName(attributes.at(SCENE_KEY_NAME).get<std::string>());
+ SceneListResource::getInstance()->setName(
+ attributes.at(SCENE_KEY_NAME).get<std::string>());
+ return RCSSetResponse::create(attributes, SCENE_RESPONSE_SUCCESS).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- SceneListResource::getInstance()->addSceneCollectionResource(newObject);
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ RCSGetResponse SceneListResource::SceneListRequestHandler::onGetRequest(
+ const RCSRequest & request, RCSResourceAttributes & attributes)
+ {
+
+ if(request.getInterface() != OC::DEFAULT_INTERFACE)
+ {
+ return RCSGetResponse::defaultAction();
+ }
- auto responseAtt = attributes;
- responseAtt[SCENE_KEY_NAME] = RCSResourceAttributes::Value(newObject->getName());
- responseAtt[SCENE_KEY_ID] = RCSResourceAttributes::Value(newObject->getId());
+ auto childrenAttrs = SceneListResource::getInstance()->getChildrenAttributes();
- auto uri = COAP_TAG + newObject->getAddress() + newObject->getUri();
- responseAtt[SCENE_KEY_PAYLOAD_LINK]
- = RCSResourceAttributes::Value(uri);
+ RCSResourceAttributes retAttr = attributes;
+ if (childrenAttrs.size())
+ {
+ retAttr[SCENE_KEY_CHILD] = childrenAttrs;
+ }
- return RCSSetResponse::create(responseAtt, SCENE_RESPONSE_SUCCESS).
- setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ return RCSGetResponse::create(retAttr);
}
}
}
/**
* Returns all of Scene Collection Resource object.
*/
- const std::vector<SceneCollectionResource::Ptr> getSceneCollections();
+ std::vector<SceneCollectionResource::Ptr> getSceneCollections() const;
+
+ std::vector<RCSResourceAttributes> getChildrenAttributes() const;
private:
class SceneListRequestHandler
~SceneListRequestHandler() = default;
static RCSSetResponse onSetRequest(const RCSRequest &, RCSResourceAttributes &);
+ static RCSGetResponse onGetRequest(const RCSRequest &, RCSResourceAttributes &);
};
- std::string m_SceneListName;
- RCSResourceObject::Ptr m_SceneListObj;
- SceneListRequestHandler m_RequestHandler;
- std::mutex m_SceneCollectionLock;
- std::vector<SceneCollectionResource::Ptr> m_SceneCollections;
+ std::string m_sceneListName;
+ RCSResourceObject::Ptr m_sceneListObj;
+ std::mutex m_sceneCollectionLock;
+ std::vector<SceneCollectionResource::Ptr> m_sceneCollections;
SceneListResource();
~SceneListResource() = default;
SceneListResource & operator = (const SceneListResource &) = delete;
SceneListResource(SceneListResource &&) = delete;
- SceneListResource && operator = (SceneListResource &&) = delete;
+ SceneListResource & operator = (SceneListResource &&) = delete;
};
}
}
-
#endif // SCENE_LIST_RESOURCE_OBJECT_H
SceneMemberResource::createSceneMemberResource(
RCSRemoteResourceObject::Ptr remoteObject)
{
- auto instance = new SceneMemberResource();
- SceneMemberResource::Ptr newSceneMemberObject;
- newSceneMemberObject.reset(instance);
+ SceneMemberResource::Ptr newSceneMemberObject(new SceneMemberResource());
- newSceneMemberObject->m_Uri = PREFIX_SCENE_MEMBER_URI + "/" +
+ newSceneMemberObject->m_uri = PREFIX_SCENE_MEMBER_URI + "/" +
std::to_string(numOfSceneMember++);
- newSceneMemberObject->m_SceneMemberResourceObj
- = RCSResourceObject::Builder(
- newSceneMemberObject->m_Uri,
- SCENE_MEMBER_RT, OC_RSRVD_INTERFACE_DEFAULT).
- setDiscoverable(true).setObservable(false).build();
- newSceneMemberObject->m_RequestHandler.m_Owner
- = std::weak_ptr<SceneMemberResource>(newSceneMemberObject);
-
- newSceneMemberObject->m_RemoteMemberObj = remoteObject;
-
- auto resourceObj = newSceneMemberObject->m_SceneMemberResourceObj;
-
- RCSResourceObject::LockGuard guard(resourceObj);
- resourceObj->setAttribute(SCENE_KEY_ID, SceneUtils::OICGenerateUUIDStr());
- resourceObj->setAttribute(SCENE_KEY_NAME, std::string());
-
- RCSResourceAttributes subAtt;
- subAtt[SCENE_KEY_HREF]
- = RCSResourceAttributes::Value(
- remoteObject->getAddress() + remoteObject->getUri());
- subAtt[SCENE_KEY_IF] = RCSResourceAttributes::Value(remoteObject->getInterfaces());
- subAtt[SCENE_KEY_RT] = RCSResourceAttributes::Value(remoteObject->getTypes());
- resourceObj->setAttribute(SCENE_KEY_PAYLOAD_LINK, subAtt);
- resourceObj->setAttribute(
- SCENE_KEY_SCENEMAPPINGS, std::vector<RCSResourceAttributes>());
+ newSceneMemberObject->m_remoteMemberObj = remoteObject;
- resourceObj->setSetRequestHandler(std::bind(
- &SceneMemberResource::SceneMemberRequestHandler::onSetRequest,
- newSceneMemberObject->m_RequestHandler,
- std::placeholders::_1, std::placeholders::_2));
+ newSceneMemberObject->createResourceObject();
+ newSceneMemberObject->initSetRequestHandler();
+ newSceneMemberObject->setDefaultAttributes();
return newSceneMemberObject;
}
return createSceneMemberResource(RCSRemoteResourceObject::fromOCResource(ocResourcePtr));
}
+ void SceneMemberResource::createResourceObject()
+ {
+ m_sceneMemberResourceObj
+ = RCSResourceObject::Builder(
+ m_uri, SCENE_MEMBER_RT, OC_RSRVD_INTERFACE_DEFAULT).
+ setDiscoverable(true).setObservable(false).build();
+ }
+
+ void SceneMemberResource::setDefaultAttributes()
+ {
+ m_sceneMemberResourceObj->setAttribute(SCENE_KEY_ID, SceneUtils::OICGenerateUUIDStr());
+ m_sceneMemberResourceObj->setAttribute(SCENE_KEY_NAME, std::string());
+
+ RCSResourceAttributes subAtt;
+ subAtt[SCENE_KEY_HREF]
+ = RCSResourceAttributes::Value(
+ m_remoteMemberObj->getAddress() + m_remoteMemberObj->getUri());
+ subAtt[SCENE_KEY_IF] = RCSResourceAttributes::Value(m_remoteMemberObj->getInterfaces());
+ subAtt[SCENE_KEY_RT] = RCSResourceAttributes::Value(m_remoteMemberObj->getTypes());
+ m_sceneMemberResourceObj->setAttribute(SCENE_KEY_PAYLOAD_LINK, subAtt);
+
+ m_sceneMemberResourceObj->setAttribute(
+ SCENE_KEY_SCENEMAPPINGS, std::vector<RCSResourceAttributes>());
+ m_sceneMemberResourceObj->setAttribute(SCENE_KEY_URI, m_uri);
+ }
+
+ void SceneMemberResource::initSetRequestHandler()
+ {
+ m_requestHandler.m_owner = std::weak_ptr<SceneMemberResource>(shared_from_this());
+ m_sceneMemberResourceObj->setSetRequestHandler(std::bind(
+ &SceneMemberResource::SceneMemberRequestHandler::onSetRequest,
+ m_requestHandler, std::placeholders::_1, std::placeholders::_2));
+ }
+
void SceneMemberResource::addMappingInfo(MappingInfo && mInfo)
{
RCSResourceAttributes newAtt;
{
- RCSResourceObject::LockGuard guard(m_SceneMemberResourceObj);
- newAtt = m_SceneMemberResourceObj->getAttributes();
+ RCSResourceObject::LockGuard guard(m_sceneMemberResourceObj);
+ newAtt = m_sceneMemberResourceObj->getAttributes();
}
auto mappingInfo = newAtt.at(SCENE_KEY_SCENEMAPPINGS).
get<std::vector<RCSResourceAttributes>>();
- struct FindSceneName
- {
- bool operator()(RCSResourceAttributes att) const
- {
- return att.at(SCENE_KEY_SCENE).get<std::string>() == name;
- }
- std::string name;
- };
-
- FindSceneName fScene;
- fScene.name = mInfo.sceneName;
- auto foundMInfo = std::find_if(mappingInfo.begin(), mappingInfo.end(), fScene);
-
- if (foundMInfo != mappingInfo.end() &&
- (* foundMInfo).at(SCENE_KEY_MEMBERPROPERTY).get<std::string>() == mInfo.key)
+ auto foundMInfo = std::find_if(mappingInfo.begin(), mappingInfo.end(),
+ [& mInfo](const RCSResourceAttributes & att) -> bool
+ {
+ return (att.at(SCENE_KEY_SCENE).get<std::string>() == mInfo.sceneName) &&
+ (att.at(SCENE_KEY_MEMBERPROPERTY).get<std::string>() == mInfo.key);
+ });
+
+ if (foundMInfo != mappingInfo.end())
{
mappingInfo.erase(foundMInfo);
}
newMapInfo[SCENE_KEY_MEMBERVALUE] = mInfo.value;
mappingInfo.push_back(newMapInfo);
- RCSResourceObject::LockGuard guard(m_SceneMemberResourceObj);
- m_SceneMemberResourceObj->setAttribute(SCENE_KEY_SCENEMAPPINGS, mappingInfo);
+ m_sceneMemberResourceObj->setAttribute(SCENE_KEY_SCENEMAPPINGS, mappingInfo);
}
void SceneMemberResource::addMappingInfo(const MappingInfo & mInfo)
addMappingInfo(MappingInfo(mInfo));
}
- std::vector<SceneMemberResource::MappingInfo>
- SceneMemberResource::getMappingInfo()
+ std::vector<SceneMemberResource::MappingInfo> SceneMemberResource::getMappingInfo()
{
- auto mappingInfo
- = m_SceneMemberResourceObj->getAttributeValue(SCENE_KEY_SCENEMAPPINGS).
- get<std::vector<RCSResourceAttributes>>();
-
std::vector<MappingInfo> retMInfo;
- for(unsigned int it = 0; it < mappingInfo.size(); ++it)
- {
- MappingInfo info(mappingInfo[it].at(
- SCENE_KEY_SCENE).get<std::string>(),
- mappingInfo[it].at(
- SCENE_KEY_MEMBERPROPERTY).get<std::string>(),
- mappingInfo[it].at(
- SCENE_KEY_MEMBERVALUE));
- retMInfo.push_back(info);
- }
+
+ auto mInfo = m_sceneMemberResourceObj->getAttributeValue(SCENE_KEY_SCENEMAPPINGS).
+ get<std::vector<RCSResourceAttributes>>();
+ std::for_each(mInfo.begin(), mInfo.end(),
+ [& retMInfo](const RCSResourceAttributes & att)
+ {
+ MappingInfo info(att.at(SCENE_KEY_SCENE).get<std::string>(),
+ att.at(SCENE_KEY_MEMBERPROPERTY).get<std::string>(),
+ att.at(SCENE_KEY_MEMBERVALUE));
+ retMInfo.push_back(info);
+ });
return retMInfo;
}
std::string SceneMemberResource::getId() const
{
- return m_SceneMemberResourceObj->getAttributeValue(SCENE_KEY_ID).get<std::string>();
+ return m_sceneMemberResourceObj->getAttributeValue(SCENE_KEY_ID).get<std::string>();
}
std::string SceneMemberResource::getFullUri() const
{
- return std::string(COAP_TAG + SceneUtils::getNetAddress() + m_Uri);
+ return std::string(COAP_TAG + SceneUtils::getNetAddress() + m_uri);
}
RCSRemoteResourceObject::Ptr SceneMemberResource::getRemoteResourceObject() const
{
- return m_RemoteMemberObj;
+ return m_remoteMemberObj;
}
RCSResourceObject::Ptr SceneMemberResource::getRCSResourceObject() const
{
- return m_SceneMemberResourceObj;
+ return m_sceneMemberResourceObj;
}
void SceneMemberResource::execute(std::string && sceneName)
execute(std::string(sceneName));
}
- void SceneMemberResource::execute(
- std::string && sceneName, executeCallback executeCB)
+ void SceneMemberResource::execute(std::string && sceneName, MemberexecuteCallback executeCB)
{
- bool hasScene = false;
- auto mInfo = getMappingInfo();
+ RCSResourceAttributes setAtt;
- for (unsigned int it = 0; it < mInfo.size(); ++it)
- {
- if (mInfo[it].sceneName == sceneName)
- {
- hasScene = true;
-
- RCSResourceAttributes setAtt;
- setAtt[mInfo[it].key] = mInfo[it].value;
- m_RemoteMemberObj->setRemoteAttributes(setAtt, executeCB);
- }
- }
- if (!hasScene && executeCB != nullptr)
+ auto mInfo = getMappingInfo();
+ std::for_each (mInfo.begin(), mInfo.end(),
+ [& setAtt, & sceneName](const MappingInfo & info)
+ {
+ if(info.sceneName == sceneName)
+ {
+ setAtt[info.key] = info.value;
+ }
+ });
+
+ if (setAtt.empty() && executeCB != nullptr)
{
executeCB(RCSResourceAttributes(), SCENE_RESPONSE_SUCCESS);
}
+
+ m_remoteMemberObj->setRemoteAttributes(setAtt, executeCB);
}
void SceneMemberResource::execute(
- const std::string & sceneName, executeCallback executeCB)
+ const std::string & sceneName, MemberexecuteCallback executeCB)
{
execute(std::string(sceneName), std::move(executeCB));
}
+ void SceneMemberResource::setName(const std::string & name)
+ {
+ setName(std::string(name));
+ }
+
+ void SceneMemberResource::setName(std::string && name)
+ {
+ m_sceneMemberResourceObj->setAttribute(SCENE_KEY_NAME, std::move(name));
+ }
+
+ std::string SceneMemberResource::getName() const
+ {
+ return m_sceneMemberResourceObj->getAttributeValue(SCENE_KEY_NAME).toString();
+ }
+
RCSSetResponse SceneMemberResource::SceneMemberRequestHandler::
- onSetRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
+ onSetRequest(const RCSRequest & request, RCSResourceAttributes & attributes)
{
- auto ptr = m_Owner.lock();
+ if (attributes.contains(SCENE_KEY_SCENEMAPPINGS))
+ {
+ addMappingInfos(request, attributes);
+ }
+
+ if (attributes.contains(SCENE_KEY_NAME))
+ {
+ setSceneMemberName(request, attributes);
+ }
+
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ RCSSetResponse
+ SceneMemberResource::SceneMemberRequestHandler::addMappingInfos(
+ const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
+ {
+ auto ptr = m_owner.lock();
if (!ptr)
{
- return RCSSetResponse::create(
- RCSResourceAttributes(attributes), SCENE_CLIENT_BADREQUEST).
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- if (attributes.contains(SCENE_KEY_SCENEMAPPINGS))
+ auto mInfo = attributes.at(SCENE_KEY_SCENEMAPPINGS).
+ get<std::vector<RCSResourceAttributes>>();
+ std::for_each (mInfo.begin(), mInfo.end(),
+ [& ptr](const RCSResourceAttributes & att)
+ {
+ ptr->addMappingInfo(SceneMemberResource::MappingInfo(
+ att.at(SCENE_KEY_SCENE).get<std::string>(),
+ att.at(SCENE_KEY_MEMBERPROPERTY).get<std::string>(),
+ att.at(SCENE_KEY_MEMBERVALUE)));
+ });
+
+ return RCSSetResponse::create(attributes).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
+ }
+
+ RCSSetResponse
+ SceneMemberResource::SceneMemberRequestHandler::setSceneMemberName(
+ const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
+ {
+ auto ptr = m_owner.lock();
+ if (!ptr)
{
- auto sceneMappings
- = attributes.at(SCENE_KEY_SCENEMAPPINGS).get<std::vector<RCSResourceAttributes>>();
- for (unsigned int it = 0; it < sceneMappings.size(); ++it)
- {
- ptr->addMappingInfo(SceneMemberResource::MappingInfo(
- sceneMappings[it].at(SCENE_KEY_SCENE).get<std::string>(),
- sceneMappings[it].at(SCENE_KEY_MEMBERPROPERTY).get<std::string>(),
- sceneMappings[it].at(SCENE_KEY_MEMBERVALUE)));
- }
+ return RCSSetResponse::create(attributes, SCENE_CLIENT_BADREQUEST).
+ setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- return RCSSetResponse::create(RCSResourceAttributes(attributes)).
+ ptr->setName(attributes.at(SCENE_KEY_NAME).get<std::string>());
+
+ return RCSSetResponse::create(attributes).
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
}
* @see RCSRemoteResourceObject::setRemoteAttributes
*/
typedef std::function< void(const RCSResourceAttributes & attrs, int eCode) >
- executeCallback;
+ MemberexecuteCallback;
/**
* A Mapping information about each scene values.
struct MappingInfo
{
MappingInfo(
- std::string scene,
- std::string keyName,
- RCSResourceAttributes::Value val)
+ const std::string & scene,
+ const std::string & keyName,
+ const RCSResourceAttributes::Value & val)
:sceneName(scene), key(keyName), value(val) { }
+
MappingInfo(MappingInfo &&) = default;
MappingInfo(const MappingInfo &) = default;
+
std::string sceneName; ///< name of scene value
std::string key; ///< key to set at attributes of remote resource
RCSResourceAttributes::Value value; ///< val to set at attributes of remote resource
* @param sceneValue scene value to execute
* @param cb callback to response
*/
- void execute(std::string && sceneValue, executeCallback cb);
+ void execute(std::string && sceneValue, MemberexecuteCallback cb);
/**
* @overload
*/
- void execute(const std::string &, executeCallback);
+ void execute(const std::string &, MemberexecuteCallback);
/**
* Execute of Scene Action (without callback for response).
*/
void execute(const std::string &);
+ void setName(const std::string &);
+ void setName(std::string &&);
+
+ std::string getName() const;
+
private:
class SceneMemberRequestHandler
{
SceneMemberRequestHandler() = default;
~SceneMemberRequestHandler() = default;
- std::weak_ptr<SceneMemberResource> m_Owner;
+ std::weak_ptr<SceneMemberResource> m_owner;
RCSSetResponse onSetRequest(const RCSRequest & , RCSResourceAttributes &);
+
+ RCSSetResponse addMappingInfos(const RCSRequest & , RCSResourceAttributes &);
+ RCSSetResponse setSceneMemberName(const RCSRequest & , RCSResourceAttributes &);
};
- std::string m_Uri;
- RCSResourceObject::Ptr m_SceneMemberResourceObj;
- RCSRemoteResourceObject::Ptr m_RemoteMemberObj;
- SceneMemberRequestHandler m_RequestHandler;
+ std::string m_uri;
+ RCSResourceObject::Ptr m_sceneMemberResourceObj;
+ RCSRemoteResourceObject::Ptr m_remoteMemberObj;
+ SceneMemberRequestHandler m_requestHandler;
SceneMemberResource() = default;
SceneMemberResource & operator = (const SceneMemberResource &) = delete;
SceneMemberResource(SceneMemberResource &&) = delete;
- SceneMemberResource && operator = (SceneMemberResource &&) = delete;
+ SceneMemberResource & operator = (SceneMemberResource &&) = delete;
+
+ void createResourceObject();
+ void setDefaultAttributes();
+ void initSetRequestHandler();
};
}
}
projects / platform / upstream / iotivity.git / commitdiff