# Provider.hpp

This File On Github
Ask A Question

API: latest
module: oatpp
#include "oatpp/core/provider/Provider.hpp"

# ResourceHandleTemplate

Resource handle template.

  • @tparam T

namespace oatpp { namespace provider { 
  template<class T, class PTR>
  struct ResourceHandleTemplate {}
}}

# Fields

Type Name Summary
PTR object Pointer to the resource.
std::shared_ptr<Invalidator<T>> invalidator Invalidator that can be used to invalidate the resource.

# Methods

Return Type Name Summary
[none] ResourceHandleTemplate Multiple implementations:
  1. Default constructor.
  2. Nullptr constructor.
  3. Constructor.
void invalidate Invalidates the resource so it can be disposed and cannot be reused anymore.

# ResourceHandleTemplate::object

Pointer to the resource.

PTR object

# ResourceHandleTemplate::invalidator

Invalidator that can be used to invalidate the resource.

std::shared_ptr<Invalidator<T>> invalidator

# ResourceHandleTemplate::ResourceHandleTemplate

  1. Default constructor.
    ResourceHandleTemplate() = default
    
  2. Nullptr constructor.
    ResourceHandleTemplate(std::nullptr_t)
    
  3. Constructor.
    • @param resourceObject
    • @param resourceInvalidator
    ResourceHandleTemplate(const PTR& resourceObject,
                           const std::shared_ptr<Invalidator<T>> &resourceInvalidator)
      : object(resourceObject), invalidator(resourceInvalidator)
    

# ResourceHandleTemplate::invalidate

Invalidates the resource so it can be disposed and cannot be reused anymore.

virtual void invalidate()

# ResourceHandle

Resource handle.

  • @tparam T

namespace oatpp { namespace provider { 
  template<class T>
  struct ResourceHandle : public ResourceHandleTemplate<T, std::shared_ptr<T>> {}
}}

# Methods

Return Type Name Summary
[none] ResourceHandle Multiple implementations:
  1. Default constructor.
  2. Nullptr constructor.
  3. Constructor.

# ResourceHandle::ResourceHandle

  1. Default constructor.
    ResourceHandle() = default
    
  2. Nullptr constructor.
    ResourceHandle(std::nullptr_t)
    
  3. Constructor.
    • @param resourceObject
    • @param resourceInvalidator
    ResourceHandle(const std::shared_ptr<T>& resourceObject,
                   const std::shared_ptr<Invalidator<T>>& resourceInvalidator)
      : ResourceHandleTemplate<T, std::shared_ptr<T>>(resourceObject, resourceInvalidator)
    

# WeakResourceHandle

Weak Resource handle.

  • @tparam T

namespace oatpp { namespace provider { 
  template<class T>
  struct WeakResourceHandle : public ResourceHandleTemplate<T, std::weak_ptr<T>> {}
}}

# Methods

Return Type Name Summary
[none] WeakResourceHandle Multiple implementations:
  1. Default constructor.
  2. Nullptr constructor.
  3. Constructor.

# WeakResourceHandle::WeakResourceHandle

  1. Default constructor.
    WeakResourceHandle() = default
    
  2. Nullptr constructor.
    WeakResourceHandle(std::nullptr_t)
    
  3. Constructor.
    • @param resourceObject
    • @param resourceInvalidator
    WeakResourceHandle(const std::weak_ptr<T>& resourceObject,
                       const std::shared_ptr<Invalidator<T>>& resourceInvalidator)
      : ResourceHandleTemplate<T, std::weak_ptr<T>>(resourceObject, resourceInvalidator)
    

# Provider

Abstract resource provider.

  • @tparam T - resource class.

namespace oatpp { namespace provider { 
  template <class T>
  class Provider : public oatpp::base::Countable {}
}}

# Methods

Return Type Name Summary
[none] Provider Multiple implementations:
  1. Default constructor.
  2. Constructor.
[none] ~Provider Virtual destructor.
const std::unordered_map<data::share::StringKeyLabelCI, data::share::StringKeyLabel>& getProperties Some optional properties that user might want to know.
data::share::StringKeyLabel getProperty Get optional property
ResourceHandle<T> get Get resource.
async::CoroutineStarterForResult<const ResourceHandle<T>&> getAsync Get resource in Async manner.
void stop Stop provider and free associated resources.

# Provider::Provider

  1. Default constructor.
    Provider() = default
    
  2. Constructor.
    • @param properties
    Provider(const std::unordered_map<data::share::StringKeyLabelCI, data::share::StringKeyLabel>& properties)
      : m_properties(properties)
    

# Provider::~Provider

Virtual destructor.

virtual ~Provider() = default

# Provider::getProperties

Some optional properties that user might want to know.
Note: All properties are optional and user should not rely on this.

const std::unordered_map<data::share::StringKeyLabelCI, data::share::StringKeyLabel>& getProperties() const

# Provider::getProperty

Get optional property

data::share::StringKeyLabel getProperty(const oatpp::String& key) const

# Provider::get

Get resource.

  • @return - resource.

virtual ResourceHandle<T> get() = 0

# Provider::getAsync

Get resource in Async manner.

  • @return - oatpp::async::CoroutineStarterForResult of T.

virtual async::CoroutineStarterForResult<const ResourceHandle<T>&> getAsync() = 0

# Provider::stop

Stop provider and free associated resources.

virtual void stop() = 0