rhubarb-lip-sync/lib/webrtc-8d2248ff/webrtc/base/referencecountedsingletonfa...

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_