160 lines
4.3 KiB
C++
160 lines
4.3 KiB
C++
/*
|
|
* Copyright 2004 The WebRTC Project Authors. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
|
|
#define WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
|
|
|
|
#include <memory>
|
|
|
|
#include "webrtc/base/common.h"
|
|
#include "webrtc/base/constructormagic.h"
|
|
#include "webrtc/base/criticalsection.h"
|
|
#include "webrtc/base/logging.h"
|
|
|
|
namespace rtc {
|
|
|
|
template <typename Interface> class rcsf_ptr;
|
|
|
|
// A ReferenceCountedSingletonFactory is an object which owns another object,
|
|
// and doles out the owned object to consumers in a reference-counted manner.
|
|
// Thus, the factory owns at most one object of the desired kind, and
|
|
// hands consumers a special pointer to it, through which they can access it.
|
|
// When the consumers delete the pointer, the reference count goes down,
|
|
// and if the reference count hits zero, the factory can throw the object
|
|
// away. If a consumer requests the pointer and the factory has none,
|
|
// it can create one on the fly and pass it back.
|
|
template <typename Interface>
|
|
class ReferenceCountedSingletonFactory {
|
|
friend class rcsf_ptr<Interface>;
|
|
public:
|
|
ReferenceCountedSingletonFactory() : ref_count_(0) {}
|
|
|
|
virtual ~ReferenceCountedSingletonFactory() {
|
|
ASSERT(ref_count_ == 0);
|
|
}
|
|
|
|
protected:
|
|
// Must be implemented in a sub-class. The sub-class may choose whether or not
|
|
// to cache the instance across lifetimes by either reset()'ing or not
|
|
// reset()'ing the unique_ptr in CleanupInstance().
|
|
virtual bool SetupInstance() = 0;
|
|
virtual void CleanupInstance() = 0;
|
|
|
|
std::unique_ptr<Interface> instance_;
|
|
|
|
private:
|
|
Interface* GetInstance() {
|
|
rtc::CritScope cs(&crit_);
|
|
if (ref_count_ == 0) {
|
|
if (!SetupInstance()) {
|
|
LOG(LS_VERBOSE) << "Failed to setup instance";
|
|
return NULL;
|
|
}
|
|
ASSERT(instance_.get() != NULL);
|
|
}
|
|
++ref_count_;
|
|
|
|
LOG(LS_VERBOSE) << "Number of references: " << ref_count_;
|
|
return instance_.get();
|
|
}
|
|
|
|
void ReleaseInstance() {
|
|
rtc::CritScope cs(&crit_);
|
|
ASSERT(ref_count_ > 0);
|
|
ASSERT(instance_.get() != NULL);
|
|
--ref_count_;
|
|
LOG(LS_VERBOSE) << "Number of references: " << ref_count_;
|
|
if (ref_count_ == 0) {
|
|
CleanupInstance();
|
|
}
|
|
}
|
|
|
|
CriticalSection crit_;
|
|
int ref_count_;
|
|
|
|
RTC_DISALLOW_COPY_AND_ASSIGN(ReferenceCountedSingletonFactory);
|
|
};
|
|
|
|
template <typename Interface>
|
|
class rcsf_ptr {
|
|
public:
|
|
// Create a pointer that uses the factory to get the instance.
|
|
// This is lazy - it won't generate the instance until it is requested.
|
|
explicit rcsf_ptr(ReferenceCountedSingletonFactory<Interface>* factory)
|
|
: instance_(NULL),
|
|
factory_(factory) {
|
|
}
|
|
|
|
~rcsf_ptr() {
|
|
release();
|
|
}
|
|
|
|
Interface& operator*() {
|
|
EnsureAcquired();
|
|
return *instance_;
|
|
}
|
|
|
|
Interface* operator->() {
|
|
EnsureAcquired();
|
|
return instance_;
|
|
}
|
|
|
|
// Gets the pointer, creating the singleton if necessary. May return NULL if
|
|
// creation failed.
|
|
Interface* get() {
|
|
Acquire();
|
|
return instance_;
|
|
}
|
|
|
|
// Set instance to NULL and tell the factory we aren't using the instance
|
|
// anymore.
|
|
void release() {
|
|
if (instance_) {
|
|
instance_ = NULL;
|
|
factory_->ReleaseInstance();
|
|
}
|
|
}
|
|
|
|
// Lets us know whether instance is valid or not right now.
|
|
// Even though attempts to use the instance will automatically create it, it
|
|
// is advisable to check this because creation can fail.
|
|
bool valid() const {
|
|
return instance_ != NULL;
|
|
}
|
|
|
|
// Returns the factory that this pointer is using.
|
|
ReferenceCountedSingletonFactory<Interface>* factory() const {
|
|
return factory_;
|
|
}
|
|
|
|
private:
|
|
void EnsureAcquired() {
|
|
Acquire();
|
|
ASSERT(instance_ != NULL);
|
|
}
|
|
|
|
void Acquire() {
|
|
// Since we're getting a singleton back, acquire is a noop if instance is
|
|
// already populated.
|
|
if (!instance_) {
|
|
instance_ = factory_->GetInstance();
|
|
}
|
|
}
|
|
|
|
Interface* instance_;
|
|
ReferenceCountedSingletonFactory<Interface>* factory_;
|
|
|
|
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(rcsf_ptr);
|
|
};
|
|
|
|
}; // namespace rtc
|
|
|
|
#endif // WEBRTC_BASE_REFERENCECOUNTEDSINGLETONFACTORY_H_
|