XMLMethodRegistry.h

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  XMLMethodRegistry.h
 
  Paul Licameli
 
**********************************************************************/
 
#ifndef __AUDACITY_XML_METHOD_REGISTRY__
#define __AUDACITY_XML_METHOD_REGISTRY__
 
#include <forward_list>
#include <string>
#include <string_view>
#include <functional>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
class XMLTagHandler;
class XMLWriter;
class XMLAttributeValueView;
 
 
class XML_API XMLMethodRegistryBase {
public:
 
template< typename Substructure >
using Mutator = std::function< void(Substructure&, const XMLAttributeValueView &) >;
 
template< typename Substructure >
using Mutators = std::vector< std::pair< std::string, Mutator<Substructure> > >;
 
   XMLMethodRegistryBase();
   ~XMLMethodRegistryBase();
protected:
   using TypeErasedObjectAccessor = std::function< XMLTagHandler *( void* ) >;
   using TagTable =
      std::unordered_map< std::string_view, TypeErasedObjectAccessor >;
   TagTable mTagTable;
   std::forward_list<std::string> mTags;
 
   void Register(std::string tag, TypeErasedObjectAccessor accessor);
   XMLTagHandler *CallObjectAccessor( const std::string_view &tag, void *p );
 
   using TypeErasedAccessor = std::function< void*( void* ) >;
   using TypeErasedAccessors = std::vector< TypeErasedAccessor >;
   TypeErasedAccessors mAccessors;
 
   void PushAccessor( TypeErasedAccessor accessor );
 
   using TypeErasedMutator = std::function< void( void*, const XMLAttributeValueView& ) >;
   using MutatorTable = std::unordered_map<std::string_view,
      std::pair<size_t, TypeErasedMutator>>;
   MutatorTable mMutatorTable;
   std::forward_list<std::string> mMutatorTags;
 
   void Register(std::string tag, TypeErasedMutator mutator);
 
   bool CallAttributeHandler(const std::string_view& tag,
      void *p, const XMLAttributeValueView &value );
 
   using TypeErasedWriter = std::function< void(const void *, XMLWriter &) >;
   using WriterTable = std::vector< TypeErasedWriter >;
 
   WriterTable mAttributeWriterTable;
   void RegisterAttributeWriter( TypeErasedWriter writer );
   void CallAttributeWriters( const void *p, XMLWriter &writer );
 
   WriterTable mObjectWriterTable;
   void RegisterObjectWriter( TypeErasedWriter writer );
   void CallObjectWriters( const void *p, XMLWriter &writer );
};
 
template< typename Host >
class XMLMethodRegistry : public XMLMethodRegistryBase {
public:
 
   // Typically statically constructed
struct ObjectReaderEntry {
   template <
      typename ObjectAccessor 
   >
   ObjectReaderEntry( const std::string &tag, ObjectAccessor fn )
   {
      // Remember the function, type-erased
      Get().Register( tag, [ fn = std::move(fn) ] (void *p) {
         // CallObjectAccessor will guarantee p is not null
         return fn( *static_cast<Host *>(p) );
      } );
   }
};
 
XMLTagHandler *CallObjectAccessor(const std::string_view& tag, Host& host)
{
   return XMLMethodRegistryBase::CallObjectAccessor( tag, &host );
}
 
struct AttributeReaderEntries {
   template<
      typename Accessor, 
      typename Substructure //<! Type deduction of the return of Accessor
         = std::remove_reference_t< decltype(
            std::declval<Accessor>()( std::declval<Host &>() )
         ) >
   >
   AttributeReaderEntries( Accessor fn, Mutators<Substructure> pairs )
   {
      // Remember the functions, type-erased
      auto &registry = Get();
      registry.PushAccessor(
         [ fn = std::move(fn) ] ( void *p ) {
            // CallAttributeHandler will guarantee p is not null
            return &fn( *static_cast<Host *>(p) ); }
      );
      for (auto &pair : pairs)
         registry.Register( pair.first,
            [ fn = move(pair.second) ]( auto p, auto value ){
               fn( *static_cast<Substructure*>(p), value ); }
         );
   }
};
 
// @return whether any function was found and called for the tag
bool CallAttributeHandler(
   const std::string_view &tag, Host &host, const XMLAttributeValueView& value )
{
   return XMLMethodRegistryBase::CallAttributeHandler( tag, &host, value );
}
 
struct AttributeWriterEntry {
   template <
      typename Writer 
   >
   explicit AttributeWriterEntry( Writer fn )
   {
      // Remember the function, type-erased
      Get().RegisterAttributeWriter(
         [ fn = std::move(fn) ] ( const void *p, XMLWriter &writer ) {
            // CallObjectAccessor will guarantee p is not null
            return fn( *static_cast<const Host *>(p), writer );
         } );
   }
};
 
struct ObjectWriterEntry {
   template <
      typename Writer 
   >
   explicit ObjectWriterEntry( Writer fn )
   {
      // Remember the function, type-erased
      Get().RegisterObjectWriter(
         [ fn = std::move(fn) ] ( const void *p, XMLWriter &writer ) {
            // CallObjectAccessor will guarantee p is not null
            return fn( *static_cast<const Host *>(p), writer );
         } );
   }
};
 
void CallWriters( const Host &host, XMLWriter &writer )
{
   XMLMethodRegistryBase::CallAttributeWriters( &host, writer );
   XMLMethodRegistryBase::CallObjectWriters( &host, writer );
}
 
static XMLMethodRegistry &Get();
 
};
 
#define DECLARE_XML_METHOD_REGISTRY(DECLSPEC, Name) \
   template<> auto DECLSPEC Name::Get() -> Name &;
 
#define DEFINE_XML_METHOD_REGISTRY(Name)  \
   template<> auto Name::Get() -> Name &  \
   {                                      \
      static Name registry;               \
      return registry;                    \
   }
 
#endif