#include "RCSResourceObject.h"
#include <functional>
-#include <vector>
#include "RequestHandler.h"
#include "AssertUtils.h"
#include "logger.h"
#include "OCPlatform.h"
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
#define LOG_TAG "RCSResourceObject"
namespace
template< typename HANDLER, typename RESPONSE =
typename std::decay<HANDLER>::type::result_type >
- RESPONSE invokeHandler(const RCSResourceObject::Ptr& resObj, RCSResourceAttributes& attrs,
- const std::shared_ptr< OC::OCResourceRequest >& ocRequest,
+ RESPONSE invokeHandler(RCSResourceAttributes& attrs, const RCSRequest& request,
std::shared_ptr< HANDLER > handler)
{
- if (handler)
+ if (handler && *handler)
{
- return (*handler)(RCSRequest{ resObj, ocRequest }, attrs);
+ return (*handler)(request, attrs);
}
return RESPONSE::defaultAction();
return {};
}
+ void insertValue(std::vector<std::string>& container, std::string value)
+ {
+ if (value.empty()) return;
+
+ if (std::find(container.begin(), container.end(), value) == container.end())
+ {
+ container.push_back(std::move(value));
+ }
+ }
+
} // unnamed namespace
namespace OIC
namespace Service
{
- RCSResourceObject::Builder::Builder(const std::string& uri, const std::string& type,
- const std::string& interface) :
- m_uri{ uri },
- m_types{ type },
- m_interfaces{ interface },
- m_defaultInterface { BASELINE_INTERFACE },
+ RCSResourceObject::Builder::Builder(std::string uri, std::string type,
+ std::string interface) :
+ m_uri{ std::move(uri) },
+ m_types{ std::move(type) },
+ m_interfaces{ },
+ m_defaultInterface{ interface },
m_properties{ OC_DISCOVERABLE | OC_OBSERVABLE },
m_resourceAttributes{ }
{
- }
+ addInterface(interface);
+ addInterface(BASELINE_INTERFACE);
- RCSResourceObject::Builder& RCSResourceObject::Builder::addInterface(
- const std::string& interface)
- {
- return addInterface(std::string{ interface });
+ if (m_defaultInterface.empty())
+ {
+ m_defaultInterface = BASELINE_INTERFACE;
+ }
}
- RCSResourceObject::Builder& RCSResourceObject::Builder::addInterface(
- std::string&& interface)
+ RCSResourceObject::Builder& RCSResourceObject::Builder::addInterface(std::string interface)
{
- m_interfaces.push_back(std::move(interface));
+ insertValue(m_interfaces, std::move(interface));
return *this;
}
- RCSResourceObject::Builder& RCSResourceObject::Builder::addType(const std::string& type)
- {
- return addType(std::string{ type });
- }
-
- RCSResourceObject::Builder& RCSResourceObject::Builder::addType(std::string&& type)
+ RCSResourceObject::Builder& RCSResourceObject::Builder::addType(std::string type)
{
- m_types.push_back(std::move(type));
+ insertValue(m_types, std::move(type));
return *this;
}
{
try
{
- OC::OCPlatform::unregisterResource(m_resourceHandle);
+ invokeOCFunc(OC::OCPlatform::unregisterResource, m_resourceHandle);
}
catch (...)
{
return m_types;
}
- RCSRepresentation RCSResourceObject::toRepresentation() const
+ RCSRepresentation RCSResourceObject::getRepresentation(const RCSRequest& request) const
{
- WeakGuard lock{*this};
- return RCSRepresentation{ m_uri, m_interfaces, m_types, m_resourceAttributes };
+ if (request.getOCRequest()->getRequestType() == "GET")
+ {
+ return findInterfaceHandler(
+ request.getInterface()).getGetResponseBuilder()(request, *this);
+ }
+
+ if (request.getOCRequest()->getRequestType() == "POST")
+ {
+ return findInterfaceHandler(
+ request.getInterface()).getSetResponseBuilder()(request, *this);
+ }
+
+ throw RCSBadRequestException{ "Unsupported request type!" };
}
void RCSResourceObject::autoNotify(bool isAttributesChanged) const
try
{
+ RCSRequest rcsRequest{ resource, request };
+
if (request->getRequestHandlerFlag() & OC::RequestHandlerFlag::RequestFlag)
{
- return resource->handleRequest(request);
+ return resource->handleRequest(rcsRequest);
}
if (request->getRequestHandlerFlag() & OC::RequestHandlerFlag::ObserverFlag)
{
- return resource->handleObserve(request);
+ return resource->handleObserve(rcsRequest);
}
}
catch (const std::exception& e)
}
OCEntityHandlerResult RCSResourceObject::handleRequest(
- const std::shared_ptr< OC::OCResourceRequest >& request)
+ const RCSRequest& request)
{
- assert(request != nullptr);
-
- RCSRequest rcsRequest{ shared_from_this(), request };
-
- if (rcsRequest.getInterface() != "" && m_interfaceHandlers.find(
- rcsRequest.getInterface()) == m_interfaceHandlers.end())
+ if (request.getInterface() != "" &&
+ m_interfaceHandlers.find(request.getInterface()) == m_interfaceHandlers.end())
{
return OC_EH_ERROR;
}
- if (request->getRequestType() == "GET")
+ if (request.getOCRequest()->getRequestType() == "GET")
{
- return handleRequestGet(rcsRequest);
+ return handleRequestGet(request);
}
- if (request->getRequestType() == "POST")
+ if (request.getOCRequest()->getRequestType() == "POST")
{
- return handleRequestSet(rcsRequest);
+ return handleRequestSet(request);
}
return OC_EH_ERROR;
}
- OCEntityHandlerResult RCSResourceObject::handleRequestGet(
- const RCSRequest& request)
+ OCEntityHandlerResult RCSResourceObject::handleRequestGet(const RCSRequest& request)
{
if (!findInterfaceHandler(request.getInterface()).isGetSupported())
{
auto attrs = getAttributesFromOCRequest(request.getOCRequest());
- auto response = invokeHandler(shared_from_this(), attrs, request.getOCRequest(),
- m_getRequestHandler);
+ auto response = invokeHandler(attrs, request, m_getRequestHandler);
if (response.isSeparate()) return OC_EH_SLOW;
findInterfaceHandler(request.getInterface()).getGetResponseBuilder());
}
- RCSResourceAttributes RCSResourceObject::applyAcceptanceMethod(
+ bool RCSResourceObject::applyAcceptanceMethod(
const RCSSetResponse& response, const RCSResourceAttributes& requestAttrs)
{
auto requestHandler = response.getHandler();
{
(*foundListener)(attrKeyValPair.second, requestAttrs.at(attrKeyValPair.first));
}
-
- result[attrKeyValPair.first] = attrKeyValPair.second;
}
- return result;
+ return !replaced.empty();
}
- OCEntityHandlerResult RCSResourceObject::handleRequestSet(
- const RCSRequest& request)
+ OCEntityHandlerResult RCSResourceObject::handleRequestSet(const RCSRequest& request)
{
if (!findInterfaceHandler(request.getInterface()).isSetSupported())
{
auto attrs = getAttributesFromOCRequest(request.getOCRequest());
- auto response = invokeHandler(shared_from_this(), attrs, request.getOCRequest(),
- m_setRequestHandler);
+ auto response = invokeHandler(attrs, request, m_setRequestHandler);
if (response.isSeparate()) return OC_EH_SLOW;
- auto replaced = applyAcceptanceMethod(response, attrs);
-
- autoNotify(!replaced.empty(), m_autoNotifyPolicy);
+ autoNotify(applyAcceptanceMethod(response, attrs), m_autoNotifyPolicy);
return sendResponse(request, response,
findInterfaceHandler(request.getInterface()).getSetResponseBuilder());
}
- OCEntityHandlerResult RCSResourceObject::handleObserve(
- const std::shared_ptr< OC::OCResourceRequest >&)
+ OCEntityHandlerResult RCSResourceObject::handleObserve(const RCSRequest&)
{
if (!isObservable())
{
else
{
ocResponse->setResourceRepresentation(
- RCSRepresentation::toOCRepresentation(
- resBuilder(request, *this)));
+ RCSRepresentation::toOCRepresentation(resBuilder(request, *this)));
}
return ::sendResponse(request.getOCRequest(), ocResponse);
m_resourceObject, m_resourceObject.m_resourceAttributes, m_autoNotifyPolicy);
}
- RCSResourceObject::WeakGuard::WeakGuard(
+ RCSResourceObject::WeakGuard::WeakGuard(
const RCSResourceObject& resourceObject) :
m_isOwningLock{ false },
m_resourceObject(resourceObject)
projects / platform / upstream / iotivity.git / blobdiff