ClientDataHelpers.h

Go to the documentation of this file.

/*!********************************************************************
 
Audacity: A Digital Audio Editor
 
@file ClientDataHelpers.h
@brief Some implementation details for ClientData
 
Paul Licameli
 
**********************************************************************/
 
#ifndef __AUDACITY_CLIENT_DATA_HELPERS__
#define __AUDACITY_CLIENT_DATA_HELPERS__
 
#include <memory>
#include <mutex>
#include <type_traits>
 
namespace ClientData {
   // Helpers to define ClientData::Site class template
 
 
enum LockingPolicy {
   NoLocking,
   NonrecursiveLocking, 
   RecursiveLocking,    
};
 
 
enum CopyingPolicy {
   SkipCopying,     
   ShallowCopying,  
   DeepCopying,     
};
 
// forward declarations
struct Base;
template<
   typename Covariant,
   template<typename> class Owner
> struct Cloneable;
 
 
template< typename Ptr > static inline
   const Ptr &Dereferenceable( Ptr &p )
      { return p; }
template< typename Obj > static inline
   std::shared_ptr<Obj> Dereferenceable( std::weak_ptr<Obj> &p )
      { return p.lock(); }
 
 
template< typename Object, LockingPolicy > struct Lockable{};
template< typename Object > struct Lockable< Object, NoLocking >
: Object {
   struct Lock{};
   Lock lock() const { return {}; }
};
template< typename Object > struct Lockable< Object, NonrecursiveLocking >
: Object, std::mutex {
   using Lock = std::unique_lock< std::mutex >;
   Lock lock() const { return Lock{ *this }; }
};
template< typename Object > struct Lockable< Object, RecursiveLocking >
: Object, std::recursive_mutex {
   using Lock = std::unique_lock< std::recursive_mutex >;
   Lock lock() const { return Lock{ *this }; }
};
 
 
template< typename Lockable > struct Locked
   : private Lockable::Lock
{
   explicit Locked( Lockable &object )
      : Lockable::Lock( object.lock() )
      , mObject( object )
   {}
   Lockable &mObject;
};
 
template< typename Container, CopyingPolicy > struct Copyable{};
template< typename Container > struct Copyable< Container, SkipCopying >
: Container {
   Copyable() = default;
   Copyable( const Copyable & ) {}
   Copyable &operator=( const Copyable & ) { return *this; }
   Copyable( Copyable && ) = default;
   Copyable &operator=( Copyable&& ) = default;
};
template< typename Container > struct Copyable< Container, ShallowCopying >
: Container {
   Copyable() = default;
   Copyable( const Copyable &other )
   { *this = other;  }
   Copyable &operator=( const Copyable &other )
   {
      if (this != &other) {
         // Build then swap for strong exception guarantee
         Copyable temp;
         for ( auto &&ptr : other )
            temp.push_back( ptr );
         this->swap( temp );
      }
      return *this;
   }
   Copyable( Copyable && ) = default;
   Copyable &operator=( Copyable&& ) = default;
};
template< typename Container > struct Copyable< Container, DeepCopying >
: Container {
   Copyable() = default;
   Copyable( const Copyable &other )
   { *this = other;  }
   Copyable &operator=( const Copyable &other )
   {
      if (this != &other) {
         // Build then swap for strong exception guarantee
         Copyable temp;
         for ( auto &&p : other ) {
            using Ptr = decltype( p->Clone() );
            temp.push_back( p ? p->Clone() : Ptr{} );
         }
         this->swap( temp );
      }
      return *this;
   }
   Copyable( Copyable && ) = default;
   Copyable &operator=( Copyable&& ) = default;
};
 
}
 
#endif