RemoteScene(
const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor >);
- RemoteSceneAction::Ptr createRemoteSceneActionInstance(
+ RemoteSceneAction::Ptr createRemoteSceneAction(
const std::string &, const RCSResourceAttributes &);
void addExistingRemoteSceneAction(const std::string &, const std::string &,
- const std::string &, const std::string &key,
- const RCSResourceAttributes::Value &);
+ RCSRemoteResourceObject::Ptr, const std::string &key,
+ const RCSResourceAttributes::Value &);
void onSceneActionAdded(
int, RCSRemoteResourceObject::Ptr,
public:
typedef std::shared_ptr< RemoteSceneAction > Ptr;
- typedef std::function< void(int eCode) > UpdateCallback;
+ typedef std::function< void(int eCode) > setExecutionParameterCallback;
public:
~RemoteSceneAction() = default;
void setExecutionParameter(const std::string &key,
- const RCSResourceAttributes::Value &value, UpdateCallback);
- void setExecutionParameter(const RCSResourceAttributes &attr, UpdateCallback);
+ const RCSResourceAttributes::Value &value, setExecutionParameterCallback);
+ void setExecutionParameter(
+ const RCSResourceAttributes &attr, setExecutionParameterCallback);
RCSResourceAttributes getExecutionParameter() const;
const std::string &sceneName,
const std::string &key, const RCSResourceAttributes::Value &);
- void onUpdated(int, const RCSResourceAttributes &, const UpdateCallback &);
+ void onExecutionParameterSet(int, const RCSResourceAttributes &,
+ const setExecutionParameterCallback &);
private:
std::string m_sceneName;
- std::mutex m_attributeLock;
+ mutable std::mutex m_attributeLock;
RCSResourceAttributes m_attributes;
std::shared_ptr< SceneMemberResourceRequestor > m_requestor;
void initializeRemoteScenes(const std::vector< RCSResourceAttributes > &,
const std::string &);
- RemoteScene::Ptr createRemoteSceneInstance(const std::string &);
+ RemoteScene::Ptr createRemoteScene(const std::string &);
void onSceneAddedRemoved(int, const std::string &name, int,
const AddNewSceneCallback &, const RemoveSceneCallback &);
private:
std::string m_id;
std::string m_name;
+ mutable std::mutex m_nameLock;
mutable std::mutex m_sceneLock;
std::unordered_map< std::string, RemoteScene::Ptr > m_remoteScenes;
std::shared_ptr< SceneCollectionResourceRequestor > m_requestor;
std::string getName() const;
private:
- class GetResponseHandler
- {
- public:
- typedef std::shared_ptr< GetResponseHandler > Ptr;
-
- typedef std::function< void(int eCode) >
- GetCallback;
-
- GetResponseHandler(std::shared_ptr< RemoteSceneList >);
- ~GetResponseHandler() = default;
-
- int m_numOfCollections;
- int m_respondedCollections;
- int m_errorCode;
- std::weak_ptr< RemoteSceneList > m_owner;
- GetCallback m_cb;
-
- void startGetResponseHandler(const std::string &host, GetCallback cb);
-
- void onGetListAttrs(const RCSRepresentation &, int, const std::string &);
-
- void onGetCollectionAttrs(const RCSRepresentation &, int eCode,
- RemoteSceneCollection::Ptr, const std::string &);
- };
-
- private:
RemoteSceneList(std::shared_ptr< SceneListResourceRequestor >);
static void onInstanceCreated(const RCSRepresentation &, int, const std::string &,
std::shared_ptr< SceneListResourceRequestor >, const CreateInstanceCallback &);
- static RemoteSceneList::Ptr buildSceneList(std::shared_ptr< SceneListResourceRequestor >,
- const RCSResourceAttributes &);
+ static RemoteSceneList::Ptr buildSceneList(
+ std::shared_ptr< SceneListResourceRequestor >, const RCSResourceAttributes &);
- RemoteSceneCollection::Ptr createRemoteSceneCollectionInstance(
+ RemoteSceneCollection::Ptr createRemoteSceneCollection(
const std::string &link, const std::string &id, const std::string &name);
std::shared_ptr< SceneListResourceRequestor > getListResourceRequestor() const;
- void setGetResponseHandler(const std::string &, GetResponseHandler::GetCallback);
-
std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
parseSceneListFromAttributes(const RCSResourceAttributes &);
private:
std::string m_name;
- std::mutex m_collectionLock;
std::vector< RemoteSceneCollection::Ptr > m_remoteSceneCollections;
+ mutable std::mutex m_nameLock;
+ mutable std::mutex m_collectionLock;
std::shared_ptr< SceneListResourceRequestor > m_requestorPtr;
-
- GetResponseHandler::Ptr m_getResponseHandler;
-
- friend class GetResponseHandler;
};
}
namespace Service
{
- RemoteScene::RemoteScene
- (const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor > requestor)
+ RemoteScene::RemoteScene(
+ const std::string &name, std::shared_ptr< SceneCollectionResourceRequestor > requestor)
: m_name{ name }, m_requestor{ requestor }
{
assert(requestor);
{
throw RCSInvalidParameterException("RCSResourceAttributes is empty");
}
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "addNewSceneAction : Callback is NULL" };
+ }
SceneCollectionResourceRequestor::InternalAddMemberCallback internalCB
= std::bind(&RemoteScene::onSceneActionAdded, this,
{
throw RCSInvalidParameterException("Scene action key value is empty");
}
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "addNewSceneAction : Callback is NULL" };
+ }
RCSResourceAttributes attrs;
attrs[key] = RCSResourceAttributes::Value(value);
void RemoteScene::execute(RemoteSceneExecuteCallback clientCB)
{
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "execute : Callback is NULL" };
+ }
+
SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
= std::bind(&RemoteScene::onSceneExecuted, this, std::placeholders::_2,
std::placeholders::_3, std::move(clientCB));
m_requestor->requestSceneExecution(m_name, internalCB);
}
- RemoteSceneAction::Ptr RemoteScene::createRemoteSceneActionInstance
- (const std::string &targetHref, const RCSResourceAttributes &attrs)
+ RemoteSceneAction::Ptr RemoteScene::createRemoteSceneAction(
+ const std::string &targetHref, const RCSResourceAttributes &attrs)
{
SceneMemberResourceRequestor::Ptr memRequestor
= m_requestor->getSceneMemberResourceRequestor(targetHref);
}
void RemoteScene::addExistingRemoteSceneAction(
- const std::string &href, const std::string &targetHref,
- const std::string &id, const std::string &key,
- const RCSResourceAttributes::Value &value)
+ const std::string &href, const std::string &id, RCSRemoteResourceObject::Ptr target,
+ const std::string &key, const RCSResourceAttributes::Value &value)
{
+ std::string targetHref = target->getAddress() + target->getUri();
+
SceneMemberResourceRequestor::Ptr foundMemberRequestor
= m_requestor->getSceneMemberResourceRequestor(targetHref);
if (foundMemberRequestor == nullptr)
- m_requestor->createSceneMemberResourceRequestor(href, id, targetHref);
+ m_requestor->createSceneMemberResourceRequestor(href, id, target);
RCSResourceAttributes attrs;
attrs[key] = RCSResourceAttributes::Value(value);
- createRemoteSceneActionInstance(targetHref, attrs);
+ createRemoteSceneAction(targetHref, attrs);
}
void RemoteScene::onSceneActionAdded(
{
std::string targetLink = target->getAddress() + target->getUri();
- newAction = createRemoteSceneActionInstance(targetLink, attrs);
+ newAction = createRemoteSceneAction(targetLink, attrs);
if (newAction)
result = SCENE_RESPONSE_SUCCESS;
void RemoteSceneAction::setExecutionParameter(const std::string &key,
const RCSResourceAttributes::Value &value,
- UpdateCallback clientCB)
+ setExecutionParameterCallback clientCB)
{
if (key.empty())
{
throw RCSInvalidParameterException("Scene action key value is empty");
}
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "setExecutionParameter : Callback is NULL" };
+ }
RCSResourceAttributes attr;
attr[key] = RCSResourceAttributes::Value(value);
}
void RemoteSceneAction::setExecutionParameter(const RCSResourceAttributes &attr,
- UpdateCallback clientCB)
+ setExecutionParameterCallback clientCB)
{
if (attr.empty())
{
throw RCSInvalidParameterException("RCSResourceAttributes is empty");
}
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "setExecutionParameter : Callback is NULL" };
+ }
SceneMemberResourceRequestor::InternalAddSceneActionCallback internalCB
- = std::bind(&RemoteSceneAction::onUpdated, this,
+ = std::bind(&RemoteSceneAction::onExecutionParameterSet, this,
std::placeholders::_1, attr, std::move(clientCB));
m_requestor->requestSceneActionCreation(
RCSResourceAttributes RemoteSceneAction::getExecutionParameter() const
{
+ std::lock_guard< std::mutex > lock(m_attributeLock);
return m_attributes;
}
return m_requestor->getRemoteResourceObject();
}
- void RemoteSceneAction::onUpdated(int eCode, const RCSResourceAttributes &attr,
- const UpdateCallback &clientCB)
+ void RemoteSceneAction::onExecutionParameterSet(int eCode, const RCSResourceAttributes &attr,
+ const setExecutionParameterCallback &clientCB)
{
int result = SCENE_CLIENT_BADREQUEST;
if (eCode == SCENE_RESPONSE_SUCCESS)
{
throw RCSInvalidParameterException("Scene name is an empty string");
}
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "addNewScene : Callback is NULL" };
+ }
SceneCollectionResourceRequestor::InternalSceneRequestCallback internalCB
= std::bind(&RemoteSceneCollection::onSceneAddedRemoved, this,
std::unordered_map< std::string, RemoteScene::Ptr >
RemoteSceneCollection::getRemoteScenes() const
{
+ std::lock_guard< std::mutex > scenelock(m_sceneLock);
return m_remoteScenes;
}
void RemoteSceneCollection::setName(const std::string &name, SetNameCallback clientCB)
{
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "setName : Callback is NULL" };
+ }
+
SceneCollectionResourceRequestor::InternalSetNameCallback internalCB
= std::bind(&RemoteSceneCollection::onNameSet, this,
std::placeholders::_1, name, std::move(clientCB));
std::string RemoteSceneCollection::getName() const
{
+ std::lock_guard< std::mutex > lock(m_nameLock);
return m_name;
}
{
for (const auto &scenename : scenes)
{
- createRemoteSceneInstance(scenename);
+ createRemoteScene(scenename);
}
}
{
try
{
- for (const auto &itr : MemberReps)
+ for (const auto &attrs : MemberReps)
{
- RCSResourceAttributes attrs = itr;
-
for (const auto &mappingInfo :
attrs.at(SCENE_KEY_SCENEMAPPINGS).get
<std::vector< RCSResourceAttributes > >())
{
std::string sceneName
= mappingInfo.at(SCENE_KEY_SCENE).get< std::string >();
- RemoteScene::Ptr pRemoteScene = nullptr;
auto remoteScene = m_remoteScenes.find(sceneName);
- if (remoteScene == m_remoteScenes.end()) return;
+ if (remoteScene == m_remoteScenes.end()) continue;
+
+ RemoteScene::Ptr pRemoteScene = m_remoteScenes.at(sceneName);
- pRemoteScene = m_remoteScenes.at(sceneName);
+ RCSResourceAttributes targetLinkAttrs
+ = attrs.at(SCENE_KEY_PAYLOAD_LINK).get< RCSResourceAttributes >();
- std::string targetHref
- = attrs.at(SCENE_KEY_PAYLOAD_LINK).get< RCSResourceAttributes >().
- at(SCENE_KEY_HREF).get< std::string >();
+ RCSRemoteResourceObject::Ptr targetResource
+ = SceneUtils::createRCSResourceObject(
+ targetLinkAttrs.at(SCENE_KEY_HREF).get< std::string >(),
+ SCENE_CONNECTIVITY,
+ targetLinkAttrs.at(SCENE_KEY_RT).get< std::vector< std::string > >(),
+ targetLinkAttrs.at(SCENE_KEY_IF).get< std::vector< std::string > >());
+
std::string mappingInfoKey
= mappingInfo.at(SCENE_KEY_MEMBERPROPERTY).get< std::string >();
RCSResourceAttributes::Value mappingInfoValue
= mappingInfo.at(SCENE_KEY_MEMBERVALUE);
pRemoteScene->addExistingRemoteSceneAction(
- host + attrs.at("uri").get< std::string >(),
- targetHref, attrs.at(SCENE_KEY_ID).get< std::string >(),
+ host + attrs.at(SCENE_KEY_URI).get< std::string >(),
+ attrs.at(SCENE_KEY_ID).get< std::string >(), targetResource,
mappingInfoKey, mappingInfoValue);
}
}
}
}
- RemoteScene::Ptr RemoteSceneCollection::createRemoteSceneInstance(
- const std::string &name)
+ RemoteScene::Ptr RemoteSceneCollection::createRemoteScene(const std::string &name)
{
std::lock_guard< std::mutex > scenelock(m_sceneLock);
RemoteScene::Ptr pNewRemoteScene(new RemoteScene(name, m_requestor));
{
if (eCode == SCENE_RESPONSE_SUCCESS)
{
- addCB(createRemoteSceneInstance(name), SCENE_RESPONSE_SUCCESS);
+ addCB(createRemoteScene(name), SCENE_RESPONSE_SUCCESS);
}
else
{
int result = SCENE_CLIENT_BADREQUEST;
if (eCode == SCENE_RESPONSE_SUCCESS)
{
+ std::lock_guard< std::mutex > lock(m_nameLock);
m_name = name;
result = SCENE_RESPONSE_SUCCESS;
}
{
RemoteSceneList::RemoteSceneList(SceneListResourceRequestor::Ptr requestor)
- : m_requestorPtr{ requestor }, m_getResponseHandler{}
+ : m_requestorPtr{ requestor }
{
}
void RemoteSceneList::createInstance(RCSRemoteResourceObject::Ptr sceneListResource,
CreateInstanceCallback clientCB)
{
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "createInstance : Callback is NULL" };
+ }
+
if (sceneListResource == nullptr)
{
throw RCSInvalidParameterException("Scene List resource object is null");
void RemoteSceneList::addNewSceneCollection(AddNewSceneCollectionCallback clientCB)
{
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "addNewSceneCollection : Callback is NULL" };
+ }
+
SceneListResourceRequestor::InternalCreateSceneCollectionCallback internalCB
= std::bind(&RemoteSceneList::onSceneCollectionCreated, this,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
std::vector< RemoteSceneCollection::Ptr >
RemoteSceneList::getRemoteSceneCollections() const
{
+ std::lock_guard< std::mutex > collectionlock(m_collectionLock);
return m_remoteSceneCollections;
}
void RemoteSceneList::setName(const std::string &name, SetNameCallback clientCB)
{
+ if (!clientCB)
+ {
+ throw RCSInvalidParameterException{ "setName : Callback is NULL" };
+ }
+
SceneListResourceRequestor::InternalSetNameCallback internalCB
= std::bind(&RemoteSceneList::onNameSet, this,
std::placeholders::_1, name, std::move(clientCB));
std::string RemoteSceneList::getName() const
{
+ std::lock_guard< std::mutex > lock(m_nameLock);
return m_name;
}
SceneListResourceRequestor::Ptr requestor, const RCSResourceAttributes &attrs)
{
RemoteSceneList::Ptr newList(new RemoteSceneList(requestor));
-
auto collections = newList->parseSceneListFromAttributes(attrs);
try
{
+ newList->m_name = attrs.at(SCENE_KEY_NAME).get< std::string >();
+
for (const auto &itr : collections)
{
auto collection = itr.first;
->getRemoteResourceObject()->getAddress();
RemoteSceneCollection::Ptr newCollection
- = newList->createRemoteSceneCollectionInstance(
+ = newList->createRemoteSceneCollection(
host + collection.at("uri").get< std::string >(),
collection.at(SCENE_KEY_ID).get< std::string >(),
collection.at(SCENE_KEY_NAME).get< std::string >());
return std::move(newList);
}
- RemoteSceneCollection::Ptr RemoteSceneList::createRemoteSceneCollectionInstance(
+ RemoteSceneCollection::Ptr RemoteSceneList::createRemoteSceneCollection(
const std::string &link, const std::string &id, const std::string &name)
{
try
return m_requestorPtr;
}
- void RemoteSceneList::setGetResponseHandler(
- const std::string &host, GetResponseHandler::GetCallback cb)
- {
- m_getResponseHandler.reset(new GetResponseHandler(shared_from_this()));
- m_getResponseHandler->startGetResponseHandler(host, std::move(cb));
- }
-
std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
RemoteSceneList::parseSceneListFromAttributes(const RCSResourceAttributes & listAttrs)
{
if (eCode == SCENE_RESPONSE_SUCCESS)
{
newCollection =
- createRemoteSceneCollectionInstance(link, id, name);
+ createRemoteSceneCollection(link, id, name);
if (newCollection)
result = SCENE_RESPONSE_SUCCESS;
int result = SCENE_CLIENT_BADREQUEST;
if (eCode == SCENE_RESPONSE_SUCCESS)
{
+ std::lock_guard< std::mutex > lock(m_nameLock);
m_name = name;
result = SCENE_RESPONSE_SUCCESS;
}
clientCB(result);
}
- RemoteSceneList::GetResponseHandler::GetResponseHandler(
- std::shared_ptr< RemoteSceneList > ptr)
- :m_numOfCollections{ 0 }, m_respondedCollections{ 0 },
- m_errorCode{ SCENE_RESPONSE_SUCCESS }, m_owner{ ptr }
- {
-
- }
-
- void RemoteSceneList::GetResponseHandler::startGetResponseHandler(
- const std::string &host, GetCallback cb)
- {
- RCSRemoteResourceObject::GetCallback ListGetCB
- = std::bind(&GetResponseHandler::onGetListAttrs, this,
- std::placeholders::_2, std::placeholders::_3, host);
-
- m_cb = cb;
-
- std::shared_ptr< RemoteSceneList > list = m_owner.lock();
-
- if (list)
- {
- list->getListResourceRequestor()
- ->requestGet(SCENE_CLIENT_CREATE_REQ_IF, ListGetCB);
- }
- }
-
- void RemoteSceneList::GetResponseHandler::onGetListAttrs(
- const RCSRepresentation &rep, int eCode, const std::string &host)
- {
- if (eCode == OC_STACK_OK)
- {
- std::shared_ptr< RemoteSceneList > list = m_owner.lock();
-
- if (list == nullptr)
- {
- SCENE_CLIENT_PRINT_LOG("remote scene list deleted.");
- return;
- }
-
- list->m_name
- = rep.getAttributes().at(SCENE_KEY_NAME).get< std::string >();
-
- std::vector< RCSRepresentation > childReps = rep.getChildren();
-
- if (childReps.size() > 0)
- {
- for (const auto &itr : childReps)
- {
- std::vector< std::string > childRTs = itr.getResourceTypes();
- if (std::find(childRTs.begin(), childRTs.end(), SCENE_COLLECTION_RT)
- != childRTs.end())
- {
- RCSResourceAttributes attrs = itr.getAttributes();
- RemoteSceneCollection::Ptr newCollection
- = list->createRemoteSceneCollectionInstance(
- host + rep.getUri(),
- attrs.at(SCENE_KEY_ID).get< std::string >(),
- attrs.at(SCENE_KEY_NAME).get< std::string >());
-
- if (newCollection == nullptr) continue;
-
- RCSRemoteResourceObject::GetCallback handlerGetCB
- = std::bind(&GetResponseHandler::onGetCollectionAttrs,
- this, std::placeholders::_2, std::placeholders::_3,
- newCollection, host);
-
- newCollection->m_requestor
- ->requestGet(SCENE_CLIENT_REQ_IF, handlerGetCB);
- }
- }
- }
- }
- else
- {
- // TODO error
- }
- }
-
- void RemoteSceneList::GetResponseHandler::onGetCollectionAttrs(
- const RCSRepresentation &reps, int eCode,
- RemoteSceneCollection::Ptr collection, const std::string &host)
- {
- m_respondedCollections++;
- if (eCode == OC_STACK_OK)
- {
- auto children = reps.getChildren();
- std::vector< RCSResourceAttributes > childrenAttr;
-
- std::for_each(children.begin(), children.end(),
- [&childrenAttr](const RCSRepresentation & rep)
- {
- childrenAttr.push_back(rep.getAttributes());
- });
-
- collection->
- initializeRemoteScenes(childrenAttr, host);
- }
- else
- {
- // TODO error
- m_errorCode = SCENE_CLIENT_BADREQUEST;
- }
-
- if (m_respondedCollections == m_numOfCollections)
- {
- m_cb(m_errorCode);
- }
- }
-
}
}
\ No newline at end of file
RCSRemoteResourceObject::SetCallback setRequestCB
= std::bind(&SceneCollectionResourceRequestor::onSceneMemberAdded,
std::placeholders::_2, std::placeholders::_3,
- targetResource->getAddress() + targetResource->getUri(),
+ targetResource,
std::move(addMemberCB),
SceneCollectionResourceRequestor::wPtr(shared_from_this()));
SceneMemberResourceRequestor::Ptr
SceneCollectionResourceRequestor::createSceneMemberResourceRequestor(
- const std::string &memHref, const std::string &id, const std::string &targetHref)
+ const std::string &memHref, const std::string &id, RCSRemoteResourceObject::Ptr target)
{
try
{
SceneMemberResourceRequestor::Ptr pMemRequestor =
std::make_shared< SceneMemberResourceRequestor >(pResource, id);
+ pMemRequestor->setRemoteResourceObject(target);
+
{
std::lock_guard< std::mutex > memberlock(m_memberRequestorLock);
- m_memberRequestors[targetHref] = pMemRequestor;
+ m_memberRequestors[target->getAddress() + target->getUri()] = pMemRequestor;
}
return pMemRequestor;
void SceneCollectionResourceRequestor::onSceneMemberAdded(
const RCSRepresentation &rep, int eCode,
- const std::string &targetHref, const InternalAddMemberCallback &internalCB,
+ RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB,
SceneCollectionResourceRequestor::wPtr ptr)
{
SceneCollectionResourceRequestor::Ptr collection = ptr.lock();
if (collection)
{
collection->onSceneMemberAdded_impl(
- std::move(rep), eCode, targetHref, std::move(internalCB));
+ std::move(rep), eCode, target, std::move(internalCB));
}
}
void SceneCollectionResourceRequestor::onSceneMemberAdded_impl(
const RCSRepresentation &rep, int eCode,
- const std::string &targetHref, const InternalAddMemberCallback &internalCB)
+ RCSRemoteResourceObject::Ptr target, const InternalAddMemberCallback &internalCB)
{
// TODO error code
int result = SCENE_CLIENT_BADREQUEST;
memRequestor
= createSceneMemberResourceRequestor(
receivedAttrs.at(SCENE_KEY_CREATEDLINK).get< std::string >(),
- receivedAttrs.at(SCENE_KEY_ID).get< std::string >(),
- targetHref);
+ receivedAttrs.at(SCENE_KEY_ID).get< std::string >(), target);
- if (memRequestor) result = SCENE_RESPONSE_SUCCESS;
+ if (memRequestor)
+ {
+ memRequestor->setRemoteResourceObject(target);
+ result = SCENE_RESPONSE_SUCCESS;
+ }
}
catch (const std::exception &e)
{
SceneMemberResourceRequestor::Ptr createSceneMemberResourceRequestor(
const std::string &memHref, const std::string &id,
- const std::string &targetHref);
+ RCSRemoteResourceObject::Ptr target);
SceneMemberResourceRequestor::Ptr getSceneMemberResourceRequestor(
const std::string &targetHref) const;
static void onSceneMemberAdded(
const RCSRepresentation &, int eCode,
- const std::string &, const InternalAddMemberCallback &,
+ RCSRemoteResourceObject::Ptr, const InternalAddMemberCallback &,
SceneCollectionResourceRequestor::wPtr);
void onSceneMemberAdded_impl(
const RCSRepresentation &, int eCode,
- const std::string &, const InternalAddMemberCallback &);
+ RCSRemoteResourceObject::Ptr, const InternalAddMemberCallback &);
static void onNameSet(const RCSRepresentation &, int eCode, const std::string &,
const InternalSetNameCallback &, SceneCollectionResourceRequestor::wPtr);
m_sceneMemberResource->get(params, cb);
}
+ void SceneMemberResourceRequestor::setRemoteResourceObject(
+ RCSRemoteResourceObject::Ptr target)
+ {
+ m_remoteResource = target;
+ }
+
RCSRemoteResourceObject::Ptr SceneMemberResourceRequestor::getRemoteResourceObject() const
{
- return m_sceneMemberResource;
+ return m_remoteResource;
}
void SceneMemberResourceRequestor::onSceneActionCreated(
void requestGet(const std::string &, RCSRemoteResourceObject::GetCallback);
+ void setRemoteResourceObject(RCSRemoteResourceObject::Ptr);
+
RCSRemoteResourceObject::Ptr getRemoteResourceObject() const;
private:
private:
std::string m_id;
+ RCSRemoteResourceObject::Ptr m_remoteResource;
RCSRemoteResourceObject::Ptr m_sceneMemberResource;
};