From: jyong2.kim <jyong2.kim@samsung.com>
Date: Tue, 23 Feb 2016 04:48:05 +0000 (+0900)
Subject: Renamed Scene resource class.
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a5a11389a62bbd6f4295e393e46ecee64d6850f1;p=contrib%2Fiotivity.git

Renamed Scene resource class.

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>
---

diff --git a/service/scene-manager/include/Scene.h b/service/scene-manager/include/Scene.h
index f295a54..8433a05 100755
--- a/service/scene-manager/include/Scene.h
+++ b/service/scene-manager/include/Scene.h
@@ -29,7 +29,7 @@ namespace OIC
 {
     namespace Service
     {
-        class SceneCollectionResourceObject;
+        class SceneCollectionResource;
         class Scene
         {
         public:
@@ -52,7 +52,7 @@ namespace OIC
 
         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:
@@ -73,7 +73,7 @@ namespace OIC
 
         private:
             std::string m_name;
-            std::shared_ptr< SceneCollectionResourceObject > m_sceneCollectionResourceObj;
+            std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
 
         };
     } /* namespace Service */
diff --git a/service/scene-manager/include/SceneAction.h b/service/scene-manager/include/SceneAction.h
index 233e20f..772749a 100755
--- a/service/scene-manager/include/SceneAction.h
+++ b/service/scene-manager/include/SceneAction.h
@@ -30,16 +30,16 @@ namespace OIC
 {
     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;
@@ -54,7 +54,7 @@ namespace OIC
         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 */
diff --git a/service/scene-manager/include/SceneCollection.h b/service/scene-manager/include/SceneCollection.h
index 4d30760..217f296 100755
--- a/service/scene-manager/include/SceneCollection.h
+++ b/service/scene-manager/include/SceneCollection.h
@@ -29,7 +29,7 @@ namespace OIC
 {
     namespace Service
     {
-        class SceneCollectionResourceObject;
+        class SceneCollectionResource;
         class SceneCollection
         {
         public:
@@ -43,7 +43,7 @@ namespace OIC
             typedef std::shared_ptr< SceneCollection > Ptr;
 
         private:
-            SceneCollection(const std::shared_ptr< SceneCollectionResourceObject >&);
+            SceneCollection(const std::shared_ptr< SceneCollectionResource >&);
             friend class SceneList;
 
         public:
@@ -59,7 +59,7 @@ namespace OIC
 
         private:
             std::map< const std::string, Scene::Ptr > m_scenes;
-            std::shared_ptr< SceneCollectionResourceObject > m_sceneCollectionResourceObj;
+            std::shared_ptr< SceneCollectionResource > m_sceneCollectionResourceObj;
 
         };
     } /* namespace Service */
diff --git a/service/scene-manager/src/Scene.cpp b/service/scene-manager/src/Scene.cpp
index 494598c..51d413f 100755
--- a/service/scene-manager/src/Scene.cpp
+++ b/service/scene-manager/src/Scene.cpp
@@ -19,16 +19,15 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #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(
@@ -50,10 +49,10 @@ namespace OIC
                 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())
@@ -63,7 +62,7 @@ namespace OIC
 
             else
             {
-                sceneMemberResObj = SceneMemberResourceObject::createSceneMemberResource(
+                sceneMemberResObj = SceneMemberResource::createSceneMemberResource(
                         RCSRemoteResourceObjectPtr);
                 m_sceneCollectionResourceObj->addSceneMember(sceneMemberResObj);
             }
diff --git a/service/scene-manager/src/SceneAction.cpp b/service/scene-manager/src/SceneAction.cpp
index 5e01914..3a685d7 100755
--- a/service/scene-manager/src/SceneAction.cpp
+++ b/service/scene-manager/src/SceneAction.cpp
@@ -19,13 +19,14 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #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),
@@ -34,18 +35,18 @@ namespace OIC
             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,
@@ -60,7 +61,7 @@ namespace OIC
             for(const auto& it : attr)
             {
                 m_sceneMemberResourceObj->addMappingInfo(
-                        SceneMemberResourceObject::MappingInfo(m_sceneName, it.key(), it.value()));
+                        SceneMemberResource::MappingInfo(m_sceneName, it.key(), it.value()));
             }
         }
 
diff --git a/service/scene-manager/src/SceneCollection.cpp b/service/scene-manager/src/SceneCollection.cpp
index e6bec4e..df94244 100755
--- a/service/scene-manager/src/SceneCollection.cpp
+++ b/service/scene-manager/src/SceneCollection.cpp
@@ -19,17 +19,16 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #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)
diff --git a/service/scene-manager/src/SceneCollectionResourceObject.cpp b/service/scene-manager/src/SceneCollectionResource.cpp
similarity index 79%
rename from service/scene-manager/src/SceneCollectionResourceObject.cpp
rename to service/scene-manager/src/SceneCollectionResource.cpp
index 0df2088..d2e2117 100644
--- a/service/scene-manager/src/SceneCollectionResourceObject.cpp
+++ b/service/scene-manager/src/SceneCollectionResource.cpp
@@ -18,7 +18,7 @@
 //
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
-#include "SceneCollectionResourceObject.h"
+#include "SceneCollectionResource.h"
 
 #include <atomic>
 #include "OCApi.h"
@@ -33,11 +33,11 @@ namespace OIC
             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
@@ -61,10 +61,10 @@ namespace OIC
             }
 
             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));
 
@@ -73,12 +73,12 @@ namespace OIC
             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 > >();
@@ -95,14 +95,14 @@ namespace OIC
             }
         }
 
-        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;
                 }
@@ -122,23 +122,23 @@ namespace OIC
             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(
@@ -176,7 +176,7 @@ namespace OIC
             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);
@@ -186,54 +186,54 @@ namespace OIC
             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)
@@ -255,10 +255,10 @@ namespace OIC
             .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(
@@ -277,10 +277,10 @@ namespace OIC
                     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(
@@ -290,7 +290,7 @@ namespace OIC
 
             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));
 
@@ -299,10 +299,10 @@ namespace OIC
             .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(
@@ -313,7 +313,7 @@ namespace OIC
             auto linkAtt = attributes.at(SCENE_KEY_PAYLOAD_LINK).get<RCSResourceAttributes>();
 
             auto memberObj
-                = SceneMemberResourceObject::createSceneMemberResource(linkAtt);
+                = SceneMemberResource::createSceneMemberResource(linkAtt);
 
             try
             {
@@ -332,7 +332,7 @@ namespace OIC
                     = 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)));
@@ -348,13 +348,13 @@ namespace OIC
             .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++;
@@ -368,9 +368,9 @@ namespace OIC
             }
         }
 
-        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>();
 
@@ -378,11 +378,11 @@ namespace OIC
             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;
diff --git a/service/scene-manager/src/SceneCollectionResourceObject.h b/service/scene-manager/src/SceneCollectionResource.h
similarity index 75%
rename from service/scene-manager/src/SceneCollectionResourceObject.h
rename to service/scene-manager/src/SceneCollectionResource.h
index e3764cd..acc2ec5 100644
--- a/service/scene-manager/src/SceneCollectionResourceObject.h
+++ b/service/scene-manager/src/SceneCollectionResource.h
@@ -25,27 +25,27 @@
 
 #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 &);
@@ -61,7 +61,7 @@ namespace OIC
             std::string getUri() const;
             std::string getAddress() const;
 
-            const std::vector<SceneMemberResourceObject::Ptr> getSceneMembers();
+            const std::vector<SceneMemberResource::Ptr> getSceneMembers();
 
             RCSResourceObject::Ptr getRCSResourceObject() const;
 
@@ -77,11 +77,11 @@ namespace OIC
                 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);
             };
 
@@ -91,7 +91,7 @@ namespace OIC
                 SceneCollectionRequestHandler() = default;
                 ~SceneCollectionRequestHandler() = default;
 
-                std::weak_ptr<SceneCollectionResourceObject> m_Owner;
+                std::weak_ptr<SceneCollectionResource> m_Owner;
 
                 RCSSetResponse onSetRequest(
                         const RCSRequest &, RCSResourceAttributes &);
@@ -111,21 +111,21 @@ namespace OIC
 
             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);
         };
diff --git a/service/scene-manager/src/SceneList.cpp b/service/scene-manager/src/SceneList.cpp
index 5d0c5bf..8329858 100755
--- a/service/scene-manager/src/SceneList.cpp
+++ b/service/scene-manager/src/SceneList.cpp
@@ -19,12 +19,11 @@
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #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
 {
@@ -39,8 +38,8 @@ 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;
@@ -49,7 +48,7 @@ namespace OIC
         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));
@@ -70,12 +69,12 @@ namespace OIC
 
         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 */
diff --git a/service/scene-manager/src/SceneListResourceObject.cpp b/service/scene-manager/src/SceneListResource.cpp
similarity index 77%
rename from service/scene-manager/src/SceneListResourceObject.cpp
rename to service/scene-manager/src/SceneListResource.cpp
index 76cc05c..5eb20fb 100644
--- a/service/scene-manager/src/SceneListResourceObject.cpp
+++ b/service/scene-manager/src/SceneListResource.cpp
@@ -18,15 +18,15 @@
 //
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
-#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(
@@ -43,26 +43,26 @@ namespace OIC
             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;
 
@@ -70,21 +70,21 @@ namespace OIC
             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)
@@ -94,14 +94,14 @@ namespace OIC
             }
 
             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());
diff --git a/service/scene-manager/src/SceneListResourceObject.h b/service/scene-manager/src/SceneListResource.h
similarity index 77%
rename from service/scene-manager/src/SceneListResourceObject.h
rename to service/scene-manager/src/SceneListResource.h
index e6f86c1..b425c20 100644
--- a/service/scene-manager/src/SceneListResourceObject.h
+++ b/service/scene-manager/src/SceneListResource.h
@@ -30,27 +30,27 @@
 #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.
@@ -72,7 +72,7 @@ namespace OIC
             /**
              * Returns all of Scene Collection Resource object.
              */
-            const std::vector<SceneCollectionResourceObject::Ptr> getSceneCollections();
+            const std::vector<SceneCollectionResource::Ptr> getSceneCollections();
 
         private:
             class SceneListRequestHandler
@@ -88,16 +88,16 @@ namespace OIC
             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;
         };
     }
 }
diff --git a/service/scene-manager/src/SceneMemberResourceObject.cpp b/service/scene-manager/src/SceneMemberResource.cpp
similarity index 83%
rename from service/scene-manager/src/SceneMemberResourceObject.cpp
rename to service/scene-manager/src/SceneMemberResource.cpp
index 43c011d..7d82f0c 100644
--- a/service/scene-manager/src/SceneMemberResourceObject.cpp
+++ b/service/scene-manager/src/SceneMemberResource.cpp
@@ -18,7 +18,7 @@
 //
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
-#include "SceneMemberResourceObject.h"
+#include "SceneMemberResource.h"
 
 #include <atomic>
 #include "OCPlatform.h"
@@ -32,12 +32,12 @@ namespace OIC
             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 + "/" +
@@ -48,7 +48,7 @@ namespace OIC
                         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;
 
@@ -70,21 +70,21 @@ namespace OIC
                     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>();
 
@@ -102,7 +102,7 @@ namespace OIC
             return createSceneMemberResource(RCSRemoteResourceObject::fromOCResource(ocResourcePtr));
         }
 
-        void SceneMemberResourceObject::addMappingInfo(MappingInfo && mInfo)
+        void SceneMemberResource::addMappingInfo(MappingInfo && mInfo)
         {
             RCSResourceAttributes newAtt;
             {
@@ -141,13 +141,13 @@ namespace OIC
             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).
@@ -168,37 +168,37 @@ namespace OIC
             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;
@@ -221,13 +221,13 @@ namespace OIC
             }
         }
 
-        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();
@@ -244,7 +244,7 @@ namespace OIC
                     = 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)));
diff --git a/service/scene-manager/src/SceneMemberResourceObject.h b/service/scene-manager/src/SceneMemberResource.h
similarity index 87%
rename from service/scene-manager/src/SceneMemberResourceObject.h
rename to service/scene-manager/src/SceneMemberResource.h
index 1303003..aae3963 100644
--- a/service/scene-manager/src/SceneMemberResourceObject.h
+++ b/service/scene-manager/src/SceneMemberResource.h
@@ -35,11 +35,11 @@ namespace OIC
 {
     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.
@@ -69,7 +69,7 @@ namespace OIC
                 RCSResourceAttributes::Value value; ///< val to set at attributes of remote resource
             };
 
-            ~SceneMemberResourceObject() = default;
+            ~SceneMemberResource() = default;
 
             /**
              * Register a Scene member resource and return a SceneMemberResourceObject
@@ -77,13 +77,13 @@ namespace OIC
              *
              * @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 &);
 
             /**
@@ -92,7 +92,7 @@ namespace OIC
              *
              * @param remoteObj information to make scene member resource
              */
-            static SceneMemberResourceObject::Ptr
+            static SceneMemberResource::Ptr
             createSceneMemberResource(RCSRemoteResourceObject::Ptr remoteObj);
 
             /**
@@ -164,7 +164,7 @@ namespace OIC
                 SceneMemberRequestHandler() = default;
                 ~SceneMemberRequestHandler() = default;
 
-                std::weak_ptr<SceneMemberResourceObject> m_Owner;
+                std::weak_ptr<SceneMemberResource> m_Owner;
 
                 RCSSetResponse onSetRequest(const RCSRequest & , RCSResourceAttributes &);
             };
@@ -174,13 +174,13 @@ namespace OIC
             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;
         };
     }
 }