Scene List / Collection / Member Class is renamed to Scene Resource from Scene Resource Object.
Change-Id: I31d43a7b9d11ba31bd003a89771e206cacfb50ab
Signed-off-by: jyong2.kim <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/5129
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
{
namespace Service
{
- class SceneCollectionResourceObject;
+ class SceneCollectionResource;
class Scene
{
public:
private:
Scene(const Scene&) = default;
- Scene(const std::string&, std::shared_ptr<SceneCollectionResourceObject>);
+ Scene(const std::string&, std::shared_ptr<SceneCollectionResource>);
friend class SceneCollection;
public:
private:
std::string m_name;
- std::shared_ptr< SceneCollectionResourceObject > m_sceneCollectionResourceObj;
+ std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
};
} /* namespace Service */
{
namespace Service
{
- class SceneMemberResourceObject;
+ class SceneMemberResource;
class SceneAction
{
public:
typedef std::shared_ptr< SceneAction > Ptr;
private:
- SceneAction(const std::shared_ptr< SceneMemberResourceObject >,
+ SceneAction(const std::shared_ptr< SceneMemberResource >,
const std::string&, const RCSResourceAttributes&);
- SceneAction(const std::shared_ptr< SceneMemberResourceObject >,
+ SceneAction(const std::shared_ptr< SceneMemberResource >,
const std::string&, const std::string&,
const RCSResourceAttributes::Value&);
friend class Scene;
private:
RCSRemoteResourceObject::Ptr m_pRemoteResourceObject;
std::string m_sceneName;
- std::shared_ptr< SceneMemberResourceObject > m_sceneMemberResourceObj;
+ std::shared_ptr< SceneMemberResource > m_sceneMemberResourceObj;
RCSResourceAttributes m_attr;
};
} /* namespace Service */
{
namespace Service
{
- class SceneCollectionResourceObject;
+ class SceneCollectionResource;
class SceneCollection
{
public:
typedef std::shared_ptr< SceneCollection > Ptr;
private:
- SceneCollection(const std::shared_ptr< SceneCollectionResourceObject >&);
+ SceneCollection(const std::shared_ptr< SceneCollectionResource >&);
friend class SceneList;
public:
private:
std::map< const std::string, Scene::Ptr > m_scenes;
- std::shared_ptr< SceneCollectionResourceObject > m_sceneCollectionResourceObj;
+ std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
};
} /* namespace Service */
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "Scene.h"
-#include "SceneCollectionResourceObject.h"
-
#include <algorithm>
+#include "SceneCollectionResource.h"
namespace OIC
{
namespace Service
{
Scene::Scene(const std::string& sceneName,
- SceneCollectionResourceObject::Ptr sceneCollectionResource) :
+ SceneCollectionResource::Ptr sceneCollectionResource) :
m_name(sceneName), m_sceneCollectionResourceObj(sceneCollectionResource) {}
SceneAction::Ptr Scene::addNewSceneAction(
throw RCSInvalidParameterException("RCSRemoteResoureObjectPtr value is null");
}
- SceneMemberResourceObject::Ptr sceneMemberResObj;
+ SceneMemberResource::Ptr sceneMemberResObj;
auto members = m_sceneCollectionResourceObj->getSceneMembers();
auto check = std::find_if(members.begin(), members.end(), [&RCSRemoteResourceObjectPtr] (
- const SceneMemberResourceObject::Ptr it){
+ const SceneMemberResource::Ptr it){
return it->getRemoteResourceObject() == RCSRemoteResourceObjectPtr;});
if(check != members.end())
else
{
- sceneMemberResObj = SceneMemberResourceObject::createSceneMemberResource(
+ sceneMemberResObj = SceneMemberResource::createSceneMemberResource(
RCSRemoteResourceObjectPtr);
m_sceneCollectionResourceObj->addSceneMember(sceneMemberResObj);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneAction.h"
-#include "SceneMemberResourceObject.h"
+
+#include "SceneMemberResource.h"
namespace OIC
{
namespace Service
{
- SceneAction::SceneAction(const SceneMemberResourceObject::Ptr SceneMemberResource,
+ SceneAction::SceneAction(const SceneMemberResource::Ptr SceneMemberResource,
const std::string& sceneName, const RCSResourceAttributes& attr) :
m_pRemoteResourceObject(SceneMemberResource->getRemoteResourceObject()),
m_sceneName(sceneName),
for (const auto& it : attr)
{
m_sceneMemberResourceObj->addMappingInfo(
- SceneMemberResourceObject::MappingInfo(m_sceneName, it.key(), it.value()));
+ SceneMemberResource::MappingInfo(m_sceneName, it.key(), it.value()));
}
}
- SceneAction::SceneAction(const SceneMemberResourceObject::Ptr SceneMemberResource,
+ SceneAction::SceneAction(const SceneMemberResource::Ptr SceneMemberResource,
const std::string& sceneName, const std::string& key,
const RCSResourceAttributes::Value& value) :
m_pRemoteResourceObject(SceneMemberResource->getRemoteResourceObject()),
m_sceneName(sceneName), m_sceneMemberResourceObj(SceneMemberResource)
{
m_sceneMemberResourceObj->addMappingInfo(
- SceneMemberResourceObject::MappingInfo(m_sceneName, key, value));
+ SceneMemberResource::MappingInfo(m_sceneName, key, value));
}
void SceneAction::update(const std::string& key,
for(const auto& it : attr)
{
m_sceneMemberResourceObj->addMappingInfo(
- SceneMemberResourceObject::MappingInfo(m_sceneName, it.key(), it.value()));
+ SceneMemberResource::MappingInfo(m_sceneName, it.key(), it.value()));
}
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneCollection.h"
-#include "SceneCollectionResourceObject.h"
-
#include "octypes.h"
#include "ocrandom.h"
+#include "SceneCollectionResource.h"
namespace OIC
{
namespace Service
{
SceneCollection::SceneCollection(
- const SceneCollectionResourceObject::Ptr& sceneCollectionResource) :
+ const SceneCollectionResource::Ptr& sceneCollectionResource) :
m_sceneCollectionResourceObj(sceneCollectionResource) {}
Scene::Ptr SceneCollection::addNewScene(const std::string& sceneName)
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include "SceneCollectionResourceObject.h"
+#include "SceneCollectionResource.h"
#include <atomic>
#include "OCApi.h"
std::atomic_int numOfSceneCollection(0);
}
- SceneCollectionResourceObject::Ptr
- SceneCollectionResourceObject::createSceneCollectionObject()
+ SceneCollectionResource::Ptr
+ SceneCollectionResource::createSceneCollectionObject()
{
- auto instance = new SceneCollectionResourceObject();
- SceneCollectionResourceObject::Ptr newSceneCollectionObject;
+ auto instance = new SceneCollectionResource();
+ SceneCollectionResource::Ptr newSceneCollectionObject;
newSceneCollectionObject.reset(instance);
newSceneCollectionObject->m_Uri
}
newSceneCollectionObject->m_RequestHandler.m_Owner
- = std::weak_ptr<SceneCollectionResourceObject>(newSceneCollectionObject);
+ = std::weak_ptr<SceneCollectionResource>(newSceneCollectionObject);
collectionObj->setSetRequestHandler(std::bind(
- &SceneCollectionResourceObject::SceneCollectionRequestHandler::onSetRequest,
+ &SceneCollectionResource::SceneCollectionRequestHandler::onSetRequest,
newSceneCollectionObject->m_RequestHandler,
std::placeholders::_1, std::placeholders::_2));
return newSceneCollectionObject;
}
- void SceneCollectionResourceObject::addScene(const std::string & newScene)
+ void SceneCollectionResource::addScene(const std::string & newScene)
{
addScene(std::string(newScene));
}
- void SceneCollectionResourceObject::addScene(std::string && newScene)
+ void SceneCollectionResource::addScene(std::string && newScene)
{
auto sceneValues = m_SceneCollectionResourceObj->getAttributeValue(
SCENE_KEY_SCENEVALUES).get< std::vector< std::string > >();
}
}
- void SceneCollectionResourceObject::addSceneMember(
- SceneMemberResourceObject::Ptr newMember)
+ void SceneCollectionResource::addSceneMember(
+ SceneMemberResource::Ptr newMember)
{
std::unique_lock<std::mutex> memberlock(m_SceneMemberLock);
struct FindMember
{
- bool operator()(SceneMemberResourceObject::Ptr ptr) const
+ bool operator()(SceneMemberResource::Ptr ptr) const
{
return ptr->getFullUri() == name;
}
m_SceneCollectionResourceObj->bindResource(newMember->getRCSResourceObject());
}
- void SceneCollectionResourceObject::execute(std::string && sceneName)
+ void SceneCollectionResource::execute(std::string && sceneName)
{
execute(std::move(sceneName), nullptr);
}
- void SceneCollectionResourceObject::execute(const std::string & sceneName)
+ void SceneCollectionResource::execute(const std::string & sceneName)
{
execute(std::string(sceneName));
}
- void SceneCollectionResourceObject::execute(
+ void SceneCollectionResource::execute(
const std::string & sceneName, SceneExecuteCallback executeCB)
{
execute(std::string(sceneName), std::move(executeCB));
}
- void SceneCollectionResourceObject::execute(
+ void SceneCollectionResource::execute(
std::string && sceneName, SceneExecuteCallback executeCB)
{
auto sceneValues = m_SceneCollectionResourceObj->getAttributeValue(
m_SceneCollectionResourceObj->setAttribute(SCENE_KEY_LAST_SCENE, sceneName);
}
- void SceneCollectionResourceObject::onExecute(
+ void SceneCollectionResource::onExecute(
int errorCode, SceneExecuteCallback cb, SceneExecuteResponseHandler::Ptr ptr)
{
std::unique_lock<std::mutex> handlerlock(m_ExecuteHandlerLock);
cb(errorCode);
}
- std::string SceneCollectionResourceObject::getId() const
+ std::string SceneCollectionResource::getId() const
{
return m_SceneCollectionResourceObj->
getAttributeValue(SCENE_KEY_ID).get<std::string>();
}
- std::string SceneCollectionResourceObject::getUri() const
+ std::string SceneCollectionResource::getUri() const
{
return m_Uri;
}
- std::string SceneCollectionResourceObject::getAddress() const
+ std::string SceneCollectionResource::getAddress() const
{
return m_Address;
}
- const std::vector<SceneMemberResourceObject::Ptr>
- SceneCollectionResourceObject::getSceneMembers()
+ const std::vector<SceneMemberResource::Ptr>
+ SceneCollectionResource::getSceneMembers()
{
std::unique_lock<std::mutex> memberlock(m_SceneMemberLock);
- std::vector<SceneMemberResourceObject::Ptr> retMembers(m_SceneMembers);
+ std::vector<SceneMemberResource::Ptr> retMembers(m_SceneMembers);
return retMembers;
}
- RCSResourceObject::Ptr SceneCollectionResourceObject::getRCSResourceObject() const
+ RCSResourceObject::Ptr SceneCollectionResource::getRCSResourceObject() const
{
return m_SceneCollectionResourceObj;
}
- void SceneCollectionResourceObject::setName(std::string && sceneCollectionName)
+ void SceneCollectionResource::setName(std::string && sceneCollectionName)
{
RCSResourceObject::LockGuard guard(m_SceneCollectionResourceObj);
m_SceneCollectionResourceObj->setAttribute(
SCENE_KEY_NAME, std::move(sceneCollectionName));
}
- void SceneCollectionResourceObject::setName(const std::string & sceneCollectionName)
+ void SceneCollectionResource::setName(const std::string & sceneCollectionName)
{
setName(std::string(sceneCollectionName));
}
- std::string SceneCollectionResourceObject::getName() const
+ std::string SceneCollectionResource::getName() const
{
return m_SceneCollectionResourceObj->getAttributeValue(
SCENE_KEY_NAME).get<std::string>();
}
- RCSSetResponse SceneCollectionResourceObject::SceneCollectionRequestHandler::
+ RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
onSetRequest(const RCSRequest & request, RCSResourceAttributes & attributes)
{
if (request.getInterface() == OC::BATCH_INTERFACE)
.setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- RCSSetResponse SceneCollectionResourceObject::SceneCollectionRequestHandler::
+ RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
addSceneRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
{
- SceneCollectionResourceObject::Ptr ptr = m_Owner.lock();
+ SceneCollectionResource::Ptr ptr = m_Owner.lock();
if (ptr == nullptr)
{
return RCSSetResponse::create(
setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- RCSSetResponse SceneCollectionResourceObject::SceneCollectionRequestHandler::
+ RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
executeSceneRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
{
- SceneCollectionResourceObject::Ptr ptr = m_Owner.lock();
+ SceneCollectionResource::Ptr ptr = m_Owner.lock();
if (ptr == nullptr)
{
return RCSSetResponse::create(
auto request_key = attributes.at(SCENE_KEY_LAST_SCENE).get<std::string>();
ptr->execute(std::string(request_key), std::bind(
- &SceneCollectionResourceObject::SceneCollectionRequestHandler::onExecute, this,
+ &SceneCollectionResource::SceneCollectionRequestHandler::onExecute, this,
std::placeholders::_1,
attributes));
.setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- RCSSetResponse SceneCollectionResourceObject::SceneCollectionRequestHandler::
+ RCSSetResponse SceneCollectionResource::SceneCollectionRequestHandler::
createSceneMemberRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
{
- SceneCollectionResourceObject::Ptr ptr = m_Owner.lock();
+ SceneCollectionResource::Ptr ptr = m_Owner.lock();
if (ptr == nullptr || !attributes.contains(SCENE_KEY_PAYLOAD_LINK))
{
return RCSSetResponse::create(
auto linkAtt = attributes.at(SCENE_KEY_PAYLOAD_LINK).get<RCSResourceAttributes>();
auto memberObj
- = SceneMemberResourceObject::createSceneMemberResource(linkAtt);
+ = SceneMemberResource::createSceneMemberResource(linkAtt);
try
{
= attributes.at(SCENE_KEY_SCENEMAPPINGS).get<std::vector<RCSResourceAttributes>>();
for (unsigned int it = 0; it < sceneMappings.size(); ++it)
{
- memberObj->addMappingInfo(SceneMemberResourceObject::MappingInfo(
+ 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)));
.setAcceptanceMethod(RCSSetResponse::AcceptanceMethod::IGNORE);
}
- void SceneCollectionResourceObject::SceneCollectionRequestHandler::
+ void SceneCollectionResource::SceneCollectionRequestHandler::
onExecute(int /*errorCode*/, /*const RCSRequest & request,*/ RCSResourceAttributes & /*att*/)
{
// TODO slow response
}
- void SceneCollectionResourceObject::SceneExecuteResponseHandler::
+ void SceneCollectionResource::SceneExecuteResponseHandler::
onResponse(const RCSResourceAttributes & /*attributes*/, int errorCode)
{
m_responseMembers++;
}
}
- SceneCollectionResourceObject::SceneExecuteResponseHandler::Ptr
- SceneCollectionResourceObject::SceneExecuteResponseHandler::createExecuteHandler(
- const SceneCollectionResourceObject::Ptr ptr, SceneExecuteCallback executeCB)
+ SceneCollectionResource::SceneExecuteResponseHandler::Ptr
+ SceneCollectionResource::SceneExecuteResponseHandler::createExecuteHandler(
+ const SceneCollectionResource::Ptr ptr, SceneExecuteCallback executeCB)
{
auto executeHandler = std::make_shared<SceneExecuteResponseHandler>();
executeHandler->m_responseMembers = 0;
executeHandler->m_Cb = std::bind(
- &SceneCollectionResourceObject::onExecute, ptr,
+ &SceneCollectionResource::onExecute, ptr,
std::placeholders::_1, std::move(executeCB), executeHandler);
executeHandler->m_Owner
- = std::weak_ptr<SceneCollectionResourceObject>(ptr);
+ = std::weak_ptr<SceneCollectionResource>(ptr);
executeHandler->m_errorCode = SCENE_RESPONSE_SUCCESS;
return executeHandler;
#include "RCSResourceObject.h"
#include "SceneCommons.h"
-#include "SceneMemberResourceObject.h"
+#include "SceneMemberResource.h"
namespace OIC
{
namespace Service
{
- class SceneCollectionResourceObject
- : public std::enable_shared_from_this<SceneCollectionResourceObject>
+ class SceneCollectionResource
+ : public std::enable_shared_from_this<SceneCollectionResource>
{
public:
- typedef std::shared_ptr< SceneCollectionResourceObject > Ptr;
+ typedef std::shared_ptr< SceneCollectionResource > Ptr;
typedef std::function< void(int) > SceneExecuteCallback;
- ~SceneCollectionResourceObject() = default;
+ ~SceneCollectionResource() = default;
- static SceneCollectionResourceObject::Ptr createSceneCollectionObject();
+ static SceneCollectionResource::Ptr createSceneCollectionObject();
void addScene(std::string &&);
void addScene(const std::string &);
- void addSceneMember(SceneMemberResourceObject::Ptr);
+ void addSceneMember(SceneMemberResource::Ptr);
void execute(std::string &&);
void execute(const std::string &);
std::string getUri() const;
std::string getAddress() const;
- const std::vector<SceneMemberResourceObject::Ptr> getSceneMembers();
+ const std::vector<SceneMemberResource::Ptr> getSceneMembers();
RCSResourceObject::Ptr getRCSResourceObject() const;
int m_numOfMembers;
int m_responseMembers;
int m_errorCode;
- std::weak_ptr<SceneCollectionResourceObject> m_Owner;
+ std::weak_ptr<SceneCollectionResource> m_Owner;
SceneExecuteCallback m_Cb;
static SceneExecuteResponseHandler::Ptr createExecuteHandler(
- const SceneCollectionResourceObject::Ptr, SceneExecuteCallback);
+ const SceneCollectionResource::Ptr, SceneExecuteCallback);
void onResponse(const RCSResourceAttributes &, int);
};
SceneCollectionRequestHandler() = default;
~SceneCollectionRequestHandler() = default;
- std::weak_ptr<SceneCollectionResourceObject> m_Owner;
+ std::weak_ptr<SceneCollectionResource> m_Owner;
RCSSetResponse onSetRequest(
const RCSRequest &, RCSResourceAttributes &);
RCSResourceObject::Ptr m_SceneCollectionResourceObj;
std::mutex m_SceneMemberLock;
- std::vector<SceneMemberResourceObject::Ptr> m_SceneMembers;
+ std::vector<SceneMemberResource::Ptr> m_SceneMembers;
SceneCollectionRequestHandler m_RequestHandler;
std::mutex m_ExecuteHandlerLock;
std::list<SceneExecuteResponseHandler::Ptr> m_ExecuteHandlers;
- SceneCollectionResourceObject() = default;
+ SceneCollectionResource() = default;
- SceneCollectionResourceObject(const SceneCollectionResourceObject &) = delete;
- SceneCollectionResourceObject & operator = (
- const SceneCollectionResourceObject &) = delete;
+ SceneCollectionResource(const SceneCollectionResource &) = delete;
+ SceneCollectionResource & operator = (
+ const SceneCollectionResource &) = delete;
- SceneCollectionResourceObject(SceneCollectionResourceObject &&) = delete;
- SceneCollectionResourceObject && operator = (
- SceneCollectionResourceObject &&) = delete;
+ SceneCollectionResource(SceneCollectionResource &&) = delete;
+ SceneCollectionResource && operator = (
+ SceneCollectionResource &&) = delete;
void onExecute(int, SceneExecuteCallback, SceneExecuteResponseHandler::Ptr);
};
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "SceneList.h"
-#include "SceneListResourceObject.h"
-#include "SceneCollectionResourceObject.h"
-
#include "RCSRequest.h"
#include "PrimitiveResource.h"
#include "OCPlatform.h"
+#include "SceneCollectionResource.h"
+#include "SceneListResource.h"
namespace OIC
{
SceneCollection::Ptr SceneList::addNewSceneCollection()
{
auto sceneCollectionResObj =
- SceneCollectionResourceObject::createSceneCollectionObject();
- SceneListResourceObject::getInstance()->addSceneCollectionResource(sceneCollectionResObj);
+ SceneCollectionResource::createSceneCollectionObject();
+ SceneListResource::getInstance()->addSceneCollectionResource(sceneCollectionResObj);
SceneCollection::Ptr sceneCollectionPtr(new SceneCollection(sceneCollectionResObj));
return sceneCollectionPtr;
std::vector< SceneCollection::Ptr > SceneList::getSceneCollections() const
{
std::vector<SceneCollection::Ptr> sceneCollections;
- auto sceneCollectionResObjs = SceneListResourceObject::getInstance()->getSceneCollections();
+ auto sceneCollectionResObjs = SceneListResource::getInstance()->getSceneCollections();
for(const auto& it : sceneCollectionResObjs)
{
SceneCollection::Ptr sceneCollectionPtr(new SceneCollection(it));
void SceneList::setName(const std::string& sceneListName)
{
- SceneListResourceObject::getInstance()->setName(sceneListName);
+ SceneListResource::getInstance()->setName(sceneListName);
}
std::string SceneList::getName() const
{
- return SceneListResourceObject::getInstance()->getName();
+ return SceneListResource::getInstance()->getName();
}
} /* namespace Service */
} /* namespace OIC */
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include "SceneListResourceObject.h"
#include "RCSRequest.h"
#include "OCApi.h"
+#include "SceneListResource.h"
namespace OIC
{
namespace Service
{
- SceneListResourceObject::SceneListResourceObject()
+ SceneListResource::SceneListResource()
: m_SceneListName(), m_SceneListObj(), m_RequestHandler()
{
m_SceneListObj = RCSResourceObject::Builder(
m_SceneListObj->setSetRequestHandler(&SceneListRequestHandler::onSetRequest);
}
- SceneListResourceObject * SceneListResourceObject::getInstance()
+ SceneListResource * SceneListResource::getInstance()
{
- static SceneListResourceObject instance;
+ static SceneListResource instance;
return & instance;
}
- void SceneListResourceObject::addSceneCollectionResource(
- SceneCollectionResourceObject::Ptr newObject)
+ 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::string SceneListResourceObject::getName() const
+ std::string SceneListResource::getName() const
{
return m_SceneListName;
}
- void SceneListResourceObject::setName(std::string && newName)
+ void SceneListResource::setName(std::string && newName)
{
m_SceneListName = newName;
m_SceneListObj->setAttribute(SCENE_KEY_NAME, m_SceneListName);
}
- void SceneListResourceObject::setName(const std::string & newName)
+ void SceneListResource::setName(const std::string & newName)
{
setName(std::string(newName));
}
- const std::vector<SceneCollectionResourceObject::Ptr>
- SceneListResourceObject::getSceneCollections()
+ const std::vector<SceneCollectionResource::Ptr>
+ SceneListResource::getSceneCollections()
{
std::unique_lock<std::mutex> collectionlock(m_SceneCollectionLock);
- std::vector<SceneCollectionResourceObject::Ptr> retCollections(m_SceneCollections);
+ std::vector<SceneCollectionResource::Ptr> retCollections(m_SceneCollections);
return retCollections;
}
RCSSetResponse
- SceneListResourceObject::SceneListRequestHandler::onSetRequest(
+ SceneListResource::SceneListRequestHandler::onSetRequest(
const RCSRequest & request, RCSResourceAttributes & attributes)
{
if (request.getInterface() != OC::BATCH_INTERFACE)
}
auto newObject
- = SceneCollectionResourceObject::createSceneCollectionObject();
+ = SceneCollectionResource::createSceneCollectionObject();
if (attributes.contains(SCENE_KEY_NAME))
{
newObject->setName(attributes.at(SCENE_KEY_NAME).get<std::string>());
}
- SceneListResourceObject::getInstance()->addSceneCollectionResource(newObject);
+ SceneListResource::getInstance()->addSceneCollectionResource(newObject);
auto responseAtt = attributes;
responseAtt[SCENE_KEY_NAME] = RCSResourceAttributes::Value(newObject->getName());
#include <string>
#include "RCSResourceObject.h"
-#include "SceneCollectionResourceObject.h"
+#include "SceneCollectionResource.h"
#include "SceneCommons.h"
namespace OIC
{
namespace Service
{
- class SceneListResourceObject
+ class SceneListResource
{
public:
/**
* Returns Scene List Resource object as single instance.
*/
- static SceneListResourceObject * getInstance();
+ static SceneListResource * getInstance();
/**
* Add Scene Collection resource object to Scene List Resource.
*
* @param collectionObj created Scene Collection Resource Object by constructor of SceneCollectionResourceObject class
*/
- void addSceneCollectionResource(SceneCollectionResourceObject::Ptr collectionObj);
+ void addSceneCollectionResource(SceneCollectionResource::Ptr collectionObj);
/**
* Returns Scene List name.
/**
* Returns all of Scene Collection Resource object.
*/
- const std::vector<SceneCollectionResourceObject::Ptr> getSceneCollections();
+ const std::vector<SceneCollectionResource::Ptr> getSceneCollections();
private:
class SceneListRequestHandler
RCSResourceObject::Ptr m_SceneListObj;
SceneListRequestHandler m_RequestHandler;
std::mutex m_SceneCollectionLock;
- std::vector<SceneCollectionResourceObject::Ptr> m_SceneCollections;
+ std::vector<SceneCollectionResource::Ptr> m_SceneCollections;
- SceneListResourceObject();
- ~SceneListResourceObject() = default;
+ SceneListResource();
+ ~SceneListResource() = default;
- SceneListResourceObject(const SceneListResourceObject &) = delete;
- SceneListResourceObject & operator = (const SceneListResourceObject &) = delete;
+ SceneListResource(const SceneListResource &) = delete;
+ SceneListResource & operator = (const SceneListResource &) = delete;
- SceneListResourceObject(SceneListResourceObject &&) = delete;
- SceneListResourceObject && operator = (SceneListResourceObject &&) = delete;
+ SceneListResource(SceneListResource &&) = delete;
+ SceneListResource && operator = (SceneListResource &&) = delete;
};
}
}
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include "SceneMemberResourceObject.h"
+#include "SceneMemberResource.h"
#include <atomic>
#include "OCPlatform.h"
std::atomic_int numOfSceneMember(0);
}
- SceneMemberResourceObject::Ptr
- SceneMemberResourceObject::createSceneMemberResource(
+ SceneMemberResource::Ptr
+ SceneMemberResource::createSceneMemberResource(
RCSRemoteResourceObject::Ptr remoteObject)
{
- auto instance = new SceneMemberResourceObject();
- SceneMemberResourceObject::Ptr newSceneMemberObject;
+ auto instance = new SceneMemberResource();
+ SceneMemberResource::Ptr newSceneMemberObject;
newSceneMemberObject.reset(instance);
newSceneMemberObject->m_Uri = PREFIX_SCENE_MEMBER_URI + "/" +
SCENE_MEMBER_RT, OC_RSRVD_INTERFACE_DEFAULT).
setDiscoverable(true).setObservable(false).build();
newSceneMemberObject->m_RequestHandler.m_Owner
- = std::weak_ptr<SceneMemberResourceObject>(newSceneMemberObject);
+ = std::weak_ptr<SceneMemberResource>(newSceneMemberObject);
newSceneMemberObject->m_RemoteMemberObj = remoteObject;
SCENE_KEY_SCENEMAPPINGS, std::vector<RCSResourceAttributes>());
resourceObj->setSetRequestHandler(std::bind(
- &SceneMemberResourceObject::SceneMemberRequestHandler::onSetRequest,
+ &SceneMemberResource::SceneMemberRequestHandler::onSetRequest,
newSceneMemberObject->m_RequestHandler,
std::placeholders::_1, std::placeholders::_2));
return newSceneMemberObject;
}
- SceneMemberResourceObject::Ptr
- SceneMemberResourceObject::createSceneMemberResource(const RCSResourceAttributes & link)
+ SceneMemberResource::Ptr
+ SceneMemberResource::createSceneMemberResource(const RCSResourceAttributes & link)
{
return createSceneMemberResource(RCSResourceAttributes(link));
}
- SceneMemberResourceObject::Ptr
- SceneMemberResourceObject::createSceneMemberResource(RCSResourceAttributes && link)
+ SceneMemberResource::Ptr
+ SceneMemberResource::createSceneMemberResource(RCSResourceAttributes && link)
{
auto href = link.at(SCENE_KEY_HREF).get<std::string>();
return createSceneMemberResource(RCSRemoteResourceObject::fromOCResource(ocResourcePtr));
}
- void SceneMemberResourceObject::addMappingInfo(MappingInfo && mInfo)
+ void SceneMemberResource::addMappingInfo(MappingInfo && mInfo)
{
RCSResourceAttributes newAtt;
{
m_SceneMemberResourceObj->setAttribute(SCENE_KEY_SCENEMAPPINGS, mappingInfo);
}
- void SceneMemberResourceObject::addMappingInfo(const MappingInfo & mInfo)
+ void SceneMemberResource::addMappingInfo(const MappingInfo & mInfo)
{
addMappingInfo(MappingInfo(mInfo));
}
- std::vector<SceneMemberResourceObject::MappingInfo>
- SceneMemberResourceObject::getMappingInfo()
+ std::vector<SceneMemberResource::MappingInfo>
+ SceneMemberResource::getMappingInfo()
{
auto mappingInfo
= m_SceneMemberResourceObj->getAttributeValue(SCENE_KEY_SCENEMAPPINGS).
return retMInfo;
}
- std::string SceneMemberResourceObject::getId() const
+ std::string SceneMemberResource::getId() const
{
return m_SceneMemberResourceObj->getAttributeValue(SCENE_KEY_ID).get<std::string>();
}
- std::string SceneMemberResourceObject::getFullUri() const
+ std::string SceneMemberResource::getFullUri() const
{
return std::string(COAP_TAG + SceneUtils::getNetAddress() + m_Uri);
}
- RCSRemoteResourceObject::Ptr SceneMemberResourceObject::getRemoteResourceObject() const
+ RCSRemoteResourceObject::Ptr SceneMemberResource::getRemoteResourceObject() const
{
return m_RemoteMemberObj;
}
- RCSResourceObject::Ptr SceneMemberResourceObject::getRCSResourceObject() const
+ RCSResourceObject::Ptr SceneMemberResource::getRCSResourceObject() const
{
return m_SceneMemberResourceObj;
}
- void SceneMemberResourceObject::execute(std::string && sceneName)
+ void SceneMemberResource::execute(std::string && sceneName)
{
execute(std::move(sceneName), nullptr);
}
- void SceneMemberResourceObject::execute(const std::string & sceneName)
+ void SceneMemberResource::execute(const std::string & sceneName)
{
execute(std::string(sceneName));
}
- void SceneMemberResourceObject::execute(
+ void SceneMemberResource::execute(
std::string && sceneName, executeCallback executeCB)
{
bool hasScene = false;
}
}
- void SceneMemberResourceObject::execute(
+ void SceneMemberResource::execute(
const std::string & sceneName, executeCallback executeCB)
{
execute(std::string(sceneName), std::move(executeCB));
}
- RCSSetResponse SceneMemberResourceObject::SceneMemberRequestHandler::
+ RCSSetResponse SceneMemberResource::SceneMemberRequestHandler::
onSetRequest(const RCSRequest & /*request*/, RCSResourceAttributes & attributes)
{
auto ptr = m_Owner.lock();
= attributes.at(SCENE_KEY_SCENEMAPPINGS).get<std::vector<RCSResourceAttributes>>();
for (unsigned int it = 0; it < sceneMappings.size(); ++it)
{
- ptr->addMappingInfo(SceneMemberResourceObject::MappingInfo(
+ 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)));
{
namespace Service
{
- class SceneMemberResourceObject
- : public std::enable_shared_from_this<SceneMemberResourceObject>
+ class SceneMemberResource
+ : public std::enable_shared_from_this<SceneMemberResource>
{
public:
- typedef std::shared_ptr< SceneMemberResourceObject > Ptr;
+ typedef std::shared_ptr< SceneMemberResource > Ptr;
/**
* Callback definition to be invoked when the response of setRemoteAttribitues is received.
RCSResourceAttributes::Value value; ///< val to set at attributes of remote resource
};
- ~SceneMemberResourceObject() = default;
+ ~SceneMemberResource() = default;
/**
* Register a Scene member resource and return a SceneMemberResourceObject
*
* @param attrs information to make scene member resource
*/
- static SceneMemberResourceObject::Ptr
+ static SceneMemberResource::Ptr
createSceneMemberResource(RCSResourceAttributes && attrs);
/**
* @overload
*/
- static SceneMemberResourceObject::Ptr
+ static SceneMemberResource::Ptr
createSceneMemberResource(const RCSResourceAttributes &);
/**
*
* @param remoteObj information to make scene member resource
*/
- static SceneMemberResourceObject::Ptr
+ static SceneMemberResource::Ptr
createSceneMemberResource(RCSRemoteResourceObject::Ptr remoteObj);
/**
SceneMemberRequestHandler() = default;
~SceneMemberRequestHandler() = default;
- std::weak_ptr<SceneMemberResourceObject> m_Owner;
+ std::weak_ptr<SceneMemberResource> m_Owner;
RCSSetResponse onSetRequest(const RCSRequest & , RCSResourceAttributes &);
};
RCSRemoteResourceObject::Ptr m_RemoteMemberObj;
SceneMemberRequestHandler m_RequestHandler;
- SceneMemberResourceObject() = default;
+ SceneMemberResource() = default;
- SceneMemberResourceObject(const SceneMemberResourceObject &) = delete;
- SceneMemberResourceObject & operator = (const SceneMemberResourceObject &) = delete;
+ SceneMemberResource(const SceneMemberResource &) = delete;
+ SceneMemberResource & operator = (const SceneMemberResource &) = delete;
- SceneMemberResourceObject(SceneMemberResourceObject &&) = delete;
- SceneMemberResourceObject && operator = (SceneMemberResourceObject &&) = delete;
+ SceneMemberResource(SceneMemberResource &&) = delete;
+ SceneMemberResource && operator = (SceneMemberResource &&) = delete;
};
}
}