{

using Base = Cloneable;

using PointerType = Owner< Base >;

virtual ~Cloneable() {}

virtual PointerType Clone() const = 0;

{

~Site()

{

static_assert( std::has_virtual_destructor<ClientData>::value,

"ClientData::Site requires a data class with a virtual destructor" );

}

// Associated type aliases

using DataType = ClientData;

using DataPointer = Pointer< ClientData >;

using DataFactory = std::function< DataPointer( Host& ) >;

Site()

{

auto factories = GetFactories();

auto size = factories.mObject.size();

mData.reserve( size );

}

Site( const Site &other )

: mData( other.mData )

{ }

Site& operator =( const Site & other )

{ mData = other.mData; return *this; }

Site( Site && other )

: mData( std::move(other.mData) )

{ }

Site& operator =( Site && other )

{ mData = std::move(other.mData); return *this; }

size_t size() const { return mData.size(); }

static size_t slots() { return GetFactories().mObject.size(); }

/// \brief a type meant to be stored by client code in a static variable,

/// and used as a retrieval key to get the manufactured client object back

/// from the host object.

/// It can be destroyed to de-register the factory, but usually not before

/// destruction of statics at program exit.

class RegisteredFactory

{

public:

RegisteredFactory( DataFactory factory )

{

auto factories = GetFactories();

mIndex = factories.mObject.size();

factories.mObject.emplace_back( std::move( factory ) );

}

RegisteredFactory( RegisteredFactory &&other )

{

mIndex = other.mIndex;

mOwner = other.mOwner;

other.mOwner = false;

}

~RegisteredFactory()

{

if (mOwner) {

auto factories = GetFactories();

// Should always be true, the factory vector never shrinks:

if ( mIndex < factories.mObject.size() )

factories.mObject[mIndex] = nullptr;

}

}

private:

friend Site;

bool mOwner{ true };

size_t mIndex;

};

// member functions for use by clients

// \brief Get a reference to an object, creating it on demand if needed, and

// down-cast it with static_cast. Throws on failure to create it.

// (Lifetime of the object may depend on the Host's lifetime and also on the

// client's use of Assign(). Site is not responsible for guarantees.)

template< typename Subclass = ClientData >

Subclass &Get( const RegisteredFactory &key )

{

auto data = GetData();

return DoGet< Subclass >( data, key );

}

// const counterpart of the previous

template< typename Subclass = const ClientData >

auto Get( const RegisteredFactory &key ) const -> typename

std::enable_if< std::is_const< Subclass >::value, Subclass & >::type

{

auto data = GetData();

return DoGet< Subclass >( data, key );

}

// \brief Get a (bare) pointer to an object, or null, and down-cast it with

// static_cast. Do not create any object.

// (Lifetime of the object may depend on the Host's lifetime and also on the

// client's use of Assign(). Site is not responsible for guarantees.)

template< typename Subclass = ClientData >

Subclass *Find( const RegisteredFactory &key )

{

auto data = GetData();

return DoFind< Subclass >( data, key );

}

// const counterpart of the previous

template< typename Subclass = const ClientData >

auto Find( const RegisteredFactory &key ) const -> typename

std::enable_if< std::is_const< Subclass >::value, Subclass * >::type

{

auto data = GetData();

return DoFind< Subclass >( data, key );

}

// \brief Reassign Host's pointer to ClientData.

// If there is object locking, then reassignments to the same slot in the

// same host object are serialized.

template< typename ReplacementPointer >

void Assign( const RegisteredFactory &key, ReplacementPointer &&replacement )

{

auto index = key.mIndex;

auto data = GetData();

EnsureIndex( data, index );

auto iter = GetIterator( data, index );

// Copy or move as appropriate:

*iter = std::forward< ReplacementPointer >( replacement );

}

// member functions for use by Host

// \brief Invoke function on each ClientData object that has been created in

// this, but do not cause the creation of any.

template< typename Function >

void ForEach( const Function &function )

{

auto data = GetData();

for( auto &pObject : data.mObject ) {

const auto &ptr = Dereferenceable(pObject);

if ( ptr )

function( *ptr );

}

}

// const counterpart of previous, only compiles with a function that takes

// a value or const reference argument

template< typename Function >

void ForEach( const Function &function ) const

{

auto data = GetData();

for( auto &pObject : data.mObject ) {

const auto &ptr = Dereferenceable(pObject);

if ( ptr ) {

const auto &c_ref = *ptr;

function( c_ref );

}

}

}

// \brief Invoke predicate on the ClientData objects that have been created in

// this, but do not cause the creation of any. Stop at the first for which

// the predicate returns true, and return a pointer to the corresponding

// object, or return nullptr if no return values were true.

// Beware that the sequence of visitation is not specified.

template< typename Function >

ClientData *FindIf( const Function &function )

{

auto data = GetData();

for( auto &pObject : data.mObject ) {

const auto &ptr = Dereferenceable(pObject);

if ( ptr && function ( *ptr ) )

return &*ptr;

}

return nullptr;

}

// const counterpart of previous, only compiles with a function that takes

// a value or const reference argument

template< typename Function >

const ClientData *FindIf( const Function &function ) const

{

auto data = GetData();

for( auto &pObject : data.mObject ) {

const auto &ptr = Dereferenceable(pObject);

if ( ptr ) {

const auto &c_ref = *ptr;

if ( function( c_ref ) )

return &*c_ref;

}

}

return nullptr;

}

// \brief For each registered factory, if the corresponding object in this

// is absent, then invoke the factory and store the result.

void BuildAll()

{

// Note that we cannot call this function in the Site constructor as we

// might wish, because we pass *this to the factories, but this is not yet

// fully constructed as the ultimate derived class. So delayed calls to

// this function are needed.

size_t size;

{

auto factories = GetFactories();

size = factories.mObject.size();

// Release lock on factories before getting one on data -- otherwise

// there would be a deadlock possibility inside Ensure

}

auto data = GetData();

EnsureIndex( data, size - 1 );

auto iter = GetIterator( data, 0 );

for ( size_t ii = 0; ii < size; ++ii, ++iter )

static_cast< void >( Build( data, iter, ii ) );

}

using DataFactories =

Lockable< std::vector< DataFactory >, RegistryLockingPolicy >;

using DataContainer =

Lockable<

Copyable< std::vector< DataPointer >, ObjectCopyingPolicy >,

ObjectLockingPolicy

>;

decltype( Dereferenceable( std::declval<DataPointer&>() ) )

Slot( Locked<DataContainer> &data, const RegisteredFactory &key, bool create )

{

auto index = key.mIndex;

EnsureIndex( data, index );

auto iter = GetIterator( data, index );

auto &pointer = create ? Build( data, iter, index ) : *iter;

return Dereferenceable( pointer );

}

template< typename Subclass >

Subclass &DoGet( Locked<DataContainer> &data, const RegisteredFactory &key )

{

const auto &d = Slot( data, key, true );

if (!d)

// Oops, a factory was deregistered too soon, or returned a null, or

// the pointer was reassigned null

THROW_INCONSISTENCY_EXCEPTION;

return static_cast< Subclass& >( *d );

}

template< typename Subclass >

Subclass *DoFind( Locked<DataContainer> &data, const RegisteredFactory &key )

{

const auto &d = Slot( data, key, false );

if (!d)

return nullptr;

else

return static_cast< Subclass* >( &*d );

}

static Locked< DataFactories > GetFactories()

{

// C++11 does not need extra thread synch for static initialization

// Note that linker eliminates duplicates of this function

static DataFactories factories;

// But give back a scoped lock to the user of this function, in case

// there is contention to resize the vector

return Locked< DataFactories >{ factories };

}

Locked<DataContainer> GetData()

{

return Locked< DataContainer >{ mData };

}

Locked<const DataContainer> GetData() const

{

return Locked< const DataContainer >{ mData };

}

static void EnsureIndex( Locked<DataContainer> &data, size_t index )

{

if (data.mObject.size() <= index)

data.mObject.resize(index + 1);

}

static typename DataContainer::iterator inline

GetIterator( Locked<DataContainer> &data, size_t index )

{

// This function might help generalize Site with different kinds of

// containers for pointers to ClientData that are not random-access.

// Perhaps non-relocation of elements will be needed.

// Perhaps another template-template parameter could vary the kind of

// container.

auto result = data.mObject.begin();

std::advance( result, index );

return result;

}

DataPointer &Build( Locked<DataContainer> &,

typename DataContainer::iterator iter, size_t index )

{

// If there is no object at index, then invoke the factory, else do

// nothing.

// The factory may be null or may return null, in which case do nothing.

auto &result = *iter;

if (!Dereferenceable(result)) {

// creation on demand

auto factories = GetFactories();

auto &factory = factories.mObject[index];

result = factory

? factory( static_cast< Host& >( *this ) )

: DataPointer{};

}

return result;

}

// Container of pointers returned by factories, per instance of Host class

// This is the only non-static data member that Site injects into the

// derived class.

DataContainer mData;