ObjectCatalog.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_DATAREPOSITORY_OBJECTCATALOG_HPP_
#define GEOS_DATAREPOSITORY_OBJECTCATALOG_HPP_
 
#include "common/logger/Logger.hpp"
#include "common/format/StringUtilities.hpp"
#include "LvArray/src/system.hpp"
#include "DataContext.hpp"
 
#include <iostream>
#include <list>
#include <memory>
#include <unordered_map>
 
#ifndef OBJECTCATALOGVERBOSE
#define OBJECTCATALOGVERBOSE 0
#endif
 
 
#ifndef BASEHOLDSCATALOG
#define BASEHOLDSCATALOG 1
#endif
 
namespace geos
{
namespace dataRepository
{
 
//START_SPHINX_0
template< typename BASETYPE, typename ... ARGS >
class CatalogInterface
{
public:
 
  //START_SPHINX_1
  typedef std::unordered_map< std::string,
                              std::unique_ptr< CatalogInterface< BASETYPE, ARGS... > > > CatalogType;
  //STOP_SPHINX
 
  CatalogInterface()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling constructor for CatalogInterface< " << LvArray::system::demangle( typeid( BASETYPE ).name() ) << " , ... >" );
#endif
  }
 
  virtual ~CatalogInterface()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling destructor for CatalogInterface< " << LvArray::system::demangle( typeid( BASETYPE ).name() ) << " , ... >" );
#endif
  }
 
  explicit CatalogInterface( CatalogInterface const & ) = default;
 
  CatalogInterface( CatalogInterface && ) = default;
 
  CatalogInterface & operator=( CatalogInterface const & ) = default;
 
  CatalogInterface & operator=( CatalogInterface && ) = default;
 
  static CatalogType & getCatalog()
  {
#if BASEHOLDSCATALOG == 1
    return BASETYPE::getCatalog();
#else
    static CatalogType catalog;
    return catalog;
#endif
  }
 
  virtual std::unique_ptr< BASETYPE > allocate( ARGS... args ) const = 0;
 
  static bool hasKeyName( std::string const & objectTypeName )
  {
    return getCatalog().count( objectTypeName );
  }
 
  static std::list< typename CatalogType::key_type > getKeys()
  {
    std::list< typename CatalogType::key_type > keys;
    for( typename CatalogType::value_type const & pair: getCatalog() )
    {
      keys.push_back( pair.first );
    }
    auto const cmp = []( string const & a,
                         string const & b ) -> bool
    {
      return stringutilities::toLower( a ) < stringutilities::toLower( b );
    };
    keys.sort( cmp );
 
    return keys;
  }
 
  //START_SPHINX_2
  static std::unique_ptr< BASETYPE > factory( std::string const & objectTypeName,
                                              DataContext const & context,
                                              ARGS... args )
  {
    // We stop the simulation if the type to create is not found
    GEOS_ERROR_IF( !hasKeyName( objectTypeName ), unknownTypeError( objectTypeName, context, getKeys() ) );
 
    // We also stop the simulation if the builder is not here.
    CatalogInterface< BASETYPE, ARGS... > const * builder = getCatalog().at( objectTypeName ).get();
    GEOS_ERROR_IF( builder == nullptr,
                   GEOS_FMT( "Type \"{}\" is valid in {}, but the builder is invalid.",
                             objectTypeName, context ) );
 
    return builder->allocate( args ... );
  }
  //STOP_SPHINX
 
  template< typename KEYS_CONTAINER_T >
  static string unknownTypeError( string const & objectTypeName, DataContext const & context,
                                  KEYS_CONTAINER_T const & allowedKeys )
  {
    return GEOS_FMT( "The tag \"{}\" is invalid within {}. Please verify the keywords spelling and that "
                     "input file parameters have not changed.\n"
                     "All available tags are: {}\n",
                     objectTypeName, context, stringutilities::join( allowedKeys, ", " ) );
  }
 
  template< typename TYPE >
  static TYPE & catalogCast( BASETYPE & object )
  {
    std::string const & castedName = TYPE::catalogName();
    std::string const & objectName = object.getName();
 
    if( castedName != objectName )
    {
#if OBJECTCATALOGVERBOSE > 1
      GEOS_LOG( "Invalid Cast of " << objectName << " to " << castedName );
#endif
    }
 
    return static_cast< TYPE & >(object);
  }
 
};
 
//START_SPHINX_3
template< typename BASETYPE, typename TYPE, typename ... ARGS >
class CatalogEntry final : public CatalogInterface< BASETYPE, ARGS... >
{
public:
 
  CatalogEntry():
    CatalogInterface< BASETYPE, ARGS... >()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling constructor for CatalogEntry< " << LvArray::system::demangle( typeid(TYPE).name())
                                                       << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                       << " , ... >" );
#endif
  }
 
  ~CatalogEntry() override
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling destructor for CatalogEntry< " << LvArray::system::demangle( typeid(TYPE).name())
                                                      << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                      << " , ... >" );
#endif
 
  }
 
  CatalogEntry( CatalogEntry const & source ):
    CatalogInterface< BASETYPE, ARGS... >( source )
  {}
 
  CatalogEntry( CatalogEntry && source ):
    CatalogInterface< BASETYPE, ARGS... >( std::move( source ))
  {}
 
  CatalogEntry & operator=( CatalogEntry const & source )
  {
    CatalogInterface< BASETYPE, ARGS... >::operator=( source );
  }
 
  CatalogEntry & operator=( CatalogEntry && source )
  {
    CatalogInterface< BASETYPE, ARGS... >::operator=( std::move( source ));
  }
 
  //START_SPHINX_4
  virtual std::unique_ptr< BASETYPE > allocate( ARGS ... args ) const override
  {
#if OBJECTCATALOGVERBOSE > 0
    GEOS_LOG( "Creating type " << LvArray::system::demangle( typeid(TYPE).name())
                               << " from catalog of " << LvArray::system::demangle( typeid(BASETYPE).name()));
#endif
#if ( __cplusplus >= 201402L )
    return std::make_unique< TYPE >( args ... );
#else
    return std::unique_ptr< BASETYPE >( new TYPE( args ... ) );
#endif
  }
  //STOP_SPHINX
 
};
 
 
template< typename BASETYPE, typename TYPE, typename ... ARGS >
class CatalogEntryConstructor
{
public:
  CatalogEntryConstructor()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling constructor for CatalogEntryConstructor< " << LvArray::system::demangle( typeid(TYPE).name())
                                                                  << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                                  << " , ... >" );
#endif
 
    std::string name = TYPE::catalogName();
#if ( __cplusplus >= 201402L )
    std::unique_ptr< CatalogEntry< BASETYPE, TYPE, ARGS... > > temp = std::make_unique< CatalogEntry< BASETYPE, TYPE, ARGS... > >();
#else
    std::unique_ptr< CatalogEntry< BASETYPE, TYPE, ARGS... > > temp = std::unique_ptr< CatalogEntry< BASETYPE, TYPE, ARGS... > >( new CatalogEntry< BASETYPE,
                                                                                                                                                    TYPE,
                                                                                                                                                    ARGS... >()  );
#endif
    ( CatalogInterface< BASETYPE, ARGS... >::getCatalog() ).insert( std::move( std::make_pair( name, std::move( temp ) ) ) );
 
#if OBJECTCATALOGVERBOSE > 0
    GEOS_LOG( "Registered " << LvArray::system::demangle( typeid(BASETYPE).name())
                            << " catalog component of derived type "
                            << LvArray::system::demangle( typeid(TYPE).name())
                            << " where " << LvArray::system::demangle( typeid(TYPE).name())
                            << "::catalogName() = " << TYPE::catalogName());
#endif
  }
 
  ~CatalogEntryConstructor()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling destructor for CatalogEntryConstructor< " << LvArray::system::demangle( typeid(TYPE).name())
                                                                 << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                                 << " , ... >" );
#endif
  }
 
  CatalogEntryConstructor( CatalogEntryConstructor const & ) = delete;
 
  CatalogEntryConstructor( CatalogEntryConstructor && ) = delete;
 
 
  CatalogEntryConstructor & operator=( CatalogEntryConstructor const & ) = delete;
 
  CatalogEntryConstructor & operator=( CatalogEntryConstructor && ) = delete;
 
};
 
template< typename BASETYPE >
class CatalogInterface< BASETYPE >
{
public:
 
  typedef std::unordered_map< std::string, std::unique_ptr< CatalogInterface< BASETYPE > > > CatalogType;
 
  CatalogInterface()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling constructor for CatalogInterface< " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                           << " , ... >" );
#endif
  }
 
  virtual ~CatalogInterface()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling destructor for CatalogInterface< " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                          << " , ... >" );
#endif
  }
 
  explicit CatalogInterface( CatalogInterface const & ) = default;
 
  CatalogInterface( CatalogInterface && ) = default;
 
  CatalogInterface & operator=( CatalogInterface const & ) = default;
 
  CatalogInterface & operator=( CatalogInterface && ) = default;
 
  static CatalogType & getCatalog()
  {
#if BASEHOLDSCATALOG == 1
    return BASETYPE::getCatalog();
#else
    static CatalogType catalog;
    return catalog;
#endif
  }
 
  virtual std::unique_ptr< BASETYPE > allocate(  ) const = 0;
 
  static std::unique_ptr< BASETYPE > factory( std::string const & objectTypeName )
  {
    CatalogInterface< BASETYPE > const * const entry = getCatalog().at( objectTypeName ).get();
    return entry->allocate();
  }
 
  template< typename TYPE >
  static TYPE & catalogCast( BASETYPE & object )
  {
    std::string const & castedName = TYPE::catalogName();
    std::string const & objectName = object.getName();
 
    if( castedName != objectName )
    {
#if OBJECTCATALOGVERBOSE > 1
      GEOS_LOG( "Invalid Cast of " << objectName << " to " << castedName );
#endif
    }
 
    return static_cast< TYPE & >(object);
  }
 
};
 
template< typename BASETYPE, typename TYPE >
class CatalogEntry< BASETYPE, TYPE > final : public CatalogInterface< BASETYPE >
{
public:
  CatalogEntry():
    CatalogInterface< BASETYPE >()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling constructor for CatalogEntry< " << LvArray::system::demangle( typeid(TYPE).name())
                                                       << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                       << " , ... >" );
#endif
  }
 
  ~CatalogEntry() override
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling destructor for CatalogEntry< " << LvArray::system::demangle( typeid(TYPE).name())
                                                      << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                      << " , ... >" );
#endif
 
  }
 
  CatalogEntry( CatalogEntry const & source ):
    CatalogInterface< BASETYPE >( source )
  {}
 
  CatalogEntry( CatalogEntry && source ):
    CatalogInterface< BASETYPE >( std::move( source ))
  {}
 
  CatalogEntry & operator=( CatalogEntry const & source )
  {
    CatalogInterface< BASETYPE >::operator=( source );
  }
 
  CatalogEntry & operator=( CatalogEntry && source )
  {
    CatalogInterface< BASETYPE >::operator=( std::move( source ));
  }
 
  virtual std::unique_ptr< BASETYPE > allocate(  ) const override
  {
#if OBJECTCATALOGVERBOSE > 0
    GEOS_LOG( "Creating type " << LvArray::system::demangle( typeid(TYPE).name())
                               << " from catalog of " << LvArray::system::demangle( typeid(BASETYPE).name()));
#endif
#if ( __cplusplus >= 201402L )
    return std::make_unique< TYPE >(  );
#else
    return std::unique_ptr< BASETYPE >( new TYPE(  ) );
#endif
  }
};
 
 
template< typename BASETYPE, typename TYPE >
class CatalogEntryConstructor< BASETYPE, TYPE >
{
public:
 
  CatalogEntryConstructor()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling constructor for CatalogEntryConstructor< " << LvArray::system::demangle( typeid(TYPE).name())
                                                                  << " , " << LvArray::system::demangle( typeid(BASETYPE).name())
                                                                  << " , ... >" );
#endif
 
    std::string name = TYPE::catalogName();
#if ( __cplusplus >= 201402L )
    std::unique_ptr< CatalogEntry< BASETYPE, TYPE > > temp = std::make_unique< CatalogEntry< BASETYPE, TYPE > >();
#else
    std::unique_ptr< CatalogEntry< BASETYPE, TYPE > > temp = std::unique_ptr< CatalogEntry< BASETYPE, TYPE > >( new CatalogEntry< BASETYPE, TYPE >()  );
#endif
    ( CatalogInterface< BASETYPE >::getCatalog() ).insert( std::move( std::make_pair( name, std::move( temp ) ) ) );
 
#if OBJECTCATALOGVERBOSE > 0
    GEOS_LOG( "Registered " << LvArray::system::demangle( typeid(BASETYPE).name())
                            << " catalog component of derived type "
                            << LvArray::system::demangle( typeid(TYPE).name())
                            << " where " << LvArray::system::demangle( typeid(TYPE).name())
                            << "::catalogName() = " << TYPE::catalogName());
#endif
  }
 
  ~CatalogEntryConstructor()
  {
#if OBJECTCATALOGVERBOSE > 1
    GEOS_LOG( "Calling destructor for CatalogEntryConstructor< " << LvArray::system::demangle( typeid(TYPE).name())
                                                                 << " , " << LvArray::system::demangle( typeid(BASETYPE).name()) << " , ... >" );
#endif
  }
 
  CatalogEntryConstructor( CatalogEntryConstructor const & ) = delete;
 
  CatalogEntryConstructor( CatalogEntryConstructor && ) = delete;
 
  CatalogEntryConstructor & operator=( CatalogEntryConstructor const & ) = delete;
 
  CatalogEntryConstructor & operator=( CatalogEntryConstructor && ) = delete;
 
};
 
 
}
}
 
 
#define REGISTER_CATALOG_ENTRY( BaseType, DerivedType, ... ) \
  namespace { GEOS_MAYBE_UNUSED geos::dataRepository::CatalogEntryConstructor< BaseType, DerivedType, __VA_ARGS__ > catEntry_ ## DerivedType; }
 
#define REGISTER_CATALOG_ENTRY0( BaseType, DerivedType ) \
  namespace { GEOS_MAYBE_UNUSED geos::dataRepository::CatalogEntryConstructor< BaseType, DerivedType > catEntry_ ## DerivedType; }
 
#endif /* GEOS_DATAREPOSITORY_OBJECTCATALOG_HPP_ */