Group.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
 
#ifndef GEOS_DATAREPOSITORY_GROUP_HPP_
#define GEOS_DATAREPOSITORY_GROUP_HPP_
 
#include "InputFlags.hpp"
#include "ObjectCatalog.hpp"
#include "MappedVector.hpp"
#include "RestartFlags.hpp"
#include "Wrapper.hpp"
#include "xmlWrapper.hpp"
 
 
#include <iostream>
 
#ifndef NOCHARTOSTRING_KEYLOOKUP
#define NOCHARTOSTRING_KEYLOOKUP 0
#endif
 
namespace geos
{
 
namespace dataRepository
{
 
//START_SPHINX_INCLUDE_00
using keyType = string;
 
using indexType = localIndex;
//END_SPHINX_INCLUDE_00
 
class Group
{
public:
  //START_SPHINX_INCLUDE_01
  using subGroupMap = MappedVector< Group, Group *, keyType, indexType >;
 
  using wrapperMap = MappedVector< WrapperBase, WrapperBase *, keyType, indexType >;
  //END_SPHINX_INCLUDE_01
 
 
  explicit Group( string const & name,
                  Group * const parent );
 
  explicit Group( string const & name,
                  conduit::Node & rootNode );
 
  Group( Group && source ) = default;
 
  virtual ~Group();
 
  Group() = delete;
 
  Group( Group const & ) = delete;
 
 
  Group & operator=( Group const & ) = delete;
 
  Group & operator=( Group && ) = delete;
 
 
 
 
  using CatalogInterface = dataRepository::CatalogInterface< Group, string const &, Group * const >;
 
  static CatalogInterface::CatalogType & getCatalog();
 
 
 
  void printDataHierarchy( integer indent = 0 ) const;
 
  string dumpInputOptions() const;
 
  string dumpSubGroupsNames() const;
 
  string dumpWrappersNames() const;
 
 
  //START_SPHINX_INCLUDE_REGISTER_GROUP
 
  template< typename T = Group >
  T & registerGroup( string const & name, std::unique_ptr< T > newObject )
  {
    newObject->m_parent = this;
    return dynamicCast< T & >( *m_subGroups.insert( name, newObject.release(), true ) );
  }
 
  template< typename T = Group >
  T & registerGroup( string const & name, T * newObject )
  { return dynamicCast< T & >( *m_subGroups.insert( name, newObject, false ) ); }
 
 
  template< typename T = Group >
  T & registerGroup( string const & name )
  { return registerGroup< T >( name, std::make_unique< T >( name, this ) ); }
 
  template< typename T = Group >
  T & registerGroup( subGroupMap::KeyIndex const & keyIndex )
  {
    T & rval = registerGroup< T >( keyIndex.key(), std::make_unique< T >( keyIndex.key(), this ) );
    keyIndex.setIndex( m_subGroups.getIndex( keyIndex.key() ) );
    return rval;
  }
 
  template< typename T = Group, typename TBASE = Group >
  T & registerGroup( string const & name, string const & catalogName )
  {
    std::unique_ptr< TBASE > newGroup = TBASE::CatalogInterface::Factory( catalogName, name, this );
    return registerGroup< T >( name, std::move( newGroup ) );
  }
 
  void deregisterGroup( string const & name );
 
  virtual Group * createChild( string const & childKey, string const & childName );
 
 
  //END_SPHINX_INCLUDE_REGISTER_GROUP
 
  //START_SPHINX_INCLUDE_GET_GROUP
 
  template< typename T = Group, typename KEY = void >
  T * getGroupPointer( KEY const & key )
  { return dynamicCast< T * >( m_subGroups[ key ] ); }
 
  template< typename T = Group, typename KEY = void >
  T const * getGroupPointer( KEY const & key ) const
  { return dynamicCast< T const * >( m_subGroups[ key ] ); }
 
  template< typename T = Group, typename KEY = void >
  T & getGroup( KEY const & key )
  {
    Group * const child = m_subGroups[ key ];
    GEOS_THROW_IF( child == nullptr,
                   "Group " << getDataContext() << " has no child named " << key << std::endl
                            << dumpSubGroupsNames(),
                   std::domain_error );
 
    return dynamicCast< T & >( *child );
  }
 
  template< typename T = Group, typename KEY = void >
  T const & getGroup( KEY const & key ) const
  {
    Group const * const child = m_subGroups[ key ];
    GEOS_THROW_IF( child == nullptr,
                   "Group " << getDataContext() << " has no child named " << key << std::endl
                            << dumpSubGroupsNames(),
                   std::domain_error );
 
    return dynamicCast< T const & >( *child );
  }
 
  template< typename T = Group >
  T & getGroupByPath( string const & path )
  { return dynamicCast< T & >( const_cast< Group & >( getBaseGroupByPath( path ) ) ); }
 
  template< typename T = Group >
  T const & getGroupByPath( string const & path ) const
  { return dynamicCast< T const & >( getBaseGroupByPath( path ) ); }
 
  //END_SPHINX_INCLUDE_GET_GROUP
 
  subGroupMap & getSubGroups()
  { return m_subGroups; }
 
  subGroupMap const & getSubGroups() const
  { return m_subGroups; }
 
  localIndex numSubGroups() const { return m_subGroups.size(); }
 
  std::vector< string > getSubGroupsNames() const;
 
  template< typename T = Group >
  bool hasGroup( string const & name ) const
  { return dynamicCast< T const * >( m_subGroups[ name ] ) != nullptr; }
 
  template< typename T >
  bool hasSubGroupOfType( ) const
  {
    bool hasSubGroup = false;
    // since forSubGroups only applies the lambda to groups matching the type,
    //   any calls to the lambda indicates that we have a subgroup of the correct type.
    forSubGroups< T >( [&]( T const & ){ hasSubGroup = true; } );
    return hasSubGroup;
  }
 
 
 
  template< typename CASTTYPE, typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE & container, LAMBDA && lambda )
  {
    using T = std::conditional_t< std::is_const< CONTAINERTYPE >::value, CASTTYPE const, CASTTYPE >;
    T * const castedContainer = dynamic_cast< T * >( &container );
 
    if( castedContainer != nullptr )
    {
      lambda( *castedContainer );
      return true;
    }
 
    return false;
  }
  template< typename T0, typename T1, typename ... CASTTYPES, typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE & container, LAMBDA && lambda )
  {
    using T = std::conditional_t< std::is_const< CONTAINERTYPE >::value, T0 const, T0 >;
    T * const castedContainer = dynamic_cast< T * >( &container );
 
    if( castedContainer != nullptr )
    {
      lambda( *castedContainer );
      return true;
    }
 
    return applyLambdaToContainer< T1, CASTTYPES... >( container, std::forward< LAMBDA >( lambda ) );
  }
 
 
  //START_SPHINX_INCLUDE_LOOP_INTERFACE
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forSubGroups( LAMBDA && lambda )
  {
    for( auto & subGroupIter : m_subGroups )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *subGroupIter.second, [&]( auto & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forSubGroups( LAMBDA && lambda ) const
  {
    for( auto const & subGroupIter : m_subGroups )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *subGroupIter.second, [&]( auto const & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }
 
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forSubGroupsIndex( LAMBDA && lambda )
  {
    localIndex counter = 0;
    for( auto & subGroupIter : m_subGroups )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *subGroupIter.second,
                                                          [&]( auto & castedSubGroup )
      {
        lambda( counter, castedSubGroup );
      } );
      ++counter;
    }
  }
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forSubGroupsIndex( LAMBDA && lambda ) const
  {
    localIndex counter = 0;
    for( auto const & subGroupIter : m_subGroups )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *subGroupIter.second,
                                                          [&]( auto const & castedSubGroup )
      {
        lambda( counter, castedSubGroup );
      } );
      ++counter;
    }
  }
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forSubGroups( LOOKUP_CONTAINER const & subGroupKeys, LAMBDA && lambda )
  {
    localIndex counter = 0;
    for( auto const & subgroup : subGroupKeys )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( getGroup( subgroup ), [&]( auto & castedSubGroup )
      {
        lambda( counter, castedSubGroup );
      } );
      ++counter;
    }
  }
 
  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forSubGroups( LOOKUP_CONTAINER const & subGroupKeys, LAMBDA && lambda ) const
  {
    localIndex counter = 0;
    for( auto const & subgroup : subGroupKeys )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( getGroup( subgroup ), [&]( auto const & castedSubGroup )
      {
        lambda( counter, castedSubGroup );
      } );
      ++counter;
    }
  }
 
 
  template< typename LAMBDA >
  void forWrappers( LAMBDA && lambda )
  {
    for( auto & wrapperIter : m_wrappers )
    {
      lambda( *wrapperIter.second );
    }
  }
 
  template< typename LAMBDA >
  void forWrappers( LAMBDA && lambda ) const
  {
    for( auto const & wrapperIter : m_wrappers )
    {
      lambda( *wrapperIter.second );
    }
  }
 
  template< typename TYPE, typename ... TYPES, typename LAMBDA >
  void forWrappers( LAMBDA && lambda )
  {
    for( auto & wrapperIter : m_wrappers )
    {
      applyLambdaToContainer< Wrapper< TYPE >, Wrapper< TYPES >... >( *wrapperIter.second,
                                                                      std::forward< LAMBDA >( lambda ));
    }
  }
 
  template< typename TYPE, typename ... TYPES, typename LAMBDA >
  void forWrappers( LAMBDA && lambda ) const
  {
    for( auto const & wrapperIter : m_wrappers )
    {
      applyLambdaToContainer< Wrapper< TYPE >, Wrapper< TYPES >... >( *wrapperIter.second,
                                                                      std::forward< LAMBDA >( lambda ));
    }
  }
 
  //END_SPHINX_INCLUDE_LOOP_INTERFACE
 
 
  virtual void initialize_postMeshGeneration();
 
 
  void initialize();
 
  virtual void initializationOrder( string_array & order );
 
 
  void initializePostInitialConditions();
 
  void postRestartInitializationRecursive();
 
  void processInputFileRecursive( xmlWrapper::xmlDocument & xmlDocument,
                                  xmlWrapper::xmlNode & targetNode );
  void processInputFileRecursive( xmlWrapper::xmlDocument & xmlDocument,
                                  xmlWrapper::xmlNode & targetNode,
                                  xmlWrapper::xmlNodePos const & nodePos );
 
  void postProcessInputRecursive();
 
 
  //START_SPHINX_INCLUDE_REGISTER_WRAPPER
 
  template< typename T, typename TBASE=T >
  Wrapper< TBASE > & registerWrapper( string const & name,
                                      wrapperMap::KeyIndex::index_type * const rkey = nullptr );
 
  template< typename T, typename TBASE=T >
  Wrapper< TBASE > & registerWrapper( Group::wrapperMap::KeyIndex const & viewKey );
 
  template< typename T >
  Wrapper< T > & registerWrapper( string const & name, std::unique_ptr< T > newObject );
 
  template< typename T >
  Wrapper< T > & registerWrapper( string const & name,
                                  T * newObject );
 
  WrapperBase & registerWrapper( std::unique_ptr< WrapperBase > wrapper );
 
  void deregisterWrapper( string const & name );
 
  //END_SPHINX_INCLUDE_REGISTER_WRAPPER
 
 
  void generateDataStructureSkeleton( integer const level )
  {
    expandObjectCatalogs();
    string indent( level*2, ' ' );
 
    for( auto const & subGroupIter : m_subGroups )
    {
      std::cout << indent << subGroupIter.second->getName() << std::endl;
      subGroupIter.second->generateDataStructureSkeleton( level + 1 );
    }
  }
 
  virtual void expandObjectCatalogs() {}
 
  virtual void setSchemaDeviations( xmlWrapper::xmlNode schemaRoot,
                                    xmlWrapper::xmlNode schemaParent,
                                    integer documentationType )
  {
    GEOS_UNUSED_VAR( schemaRoot );
    GEOS_UNUSED_VAR( schemaParent );
    GEOS_UNUSED_VAR( documentationType );
  }
 
 
 
  virtual void registerDataOnMeshRecursive( Group & meshBodies );
 
  virtual void registerDataOnMesh( Group & meshBodies )
  {
    GEOS_UNUSED_VAR( meshBodies );
  }
 
 
 
  virtual localIndex packSize( string_array const & wrapperNames,
                               integer const recursive,
                               bool onDevice,
                               parallelDeviceEvents & events ) const;
 
  virtual localIndex packSize( string_array const & wrapperNames,
                               arrayView1d< localIndex const > const & packList,
                               integer const recursive,
                               bool onDevice,
                               parallelDeviceEvents & events ) const;
 
  localIndex packSize( arrayView1d< localIndex const > const & packList,
                       integer const recursive,
                       bool onDevice,
                       parallelDeviceEvents & events ) const;
 
  virtual localIndex pack( buffer_unit_type * & buffer,
                           string_array const & wrapperNames,
                           integer const recursive,
                           bool onDevice,
                           parallelDeviceEvents & events ) const;
 
  virtual localIndex pack( buffer_unit_type * & buffer,
                           string_array const & wrapperNames,
                           arrayView1d< localIndex const > const & packList,
                           integer const recursive,
                           bool onDevice,
                           parallelDeviceEvents & events ) const;
 
  localIndex pack( buffer_unit_type * & buffer,
                   arrayView1d< localIndex const > const & packList,
                   integer const recursive,
                   bool onDevice,
                   parallelDeviceEvents & events ) const;
 
  virtual localIndex unpack( buffer_unit_type const * & buffer,
                             arrayView1d< localIndex > & packList,
                             integer const recursive,
                             bool onDevice,
                             parallelDeviceEvents & events,
                             MPI_Op op=MPI_REPLACE );
 
 
  //***********************************************************************************************
 
  //START_SPHINX_INCLUDE_GET_WRAPPER
 
  template< typename KEY >
  WrapperBase const & getWrapperBase( KEY const & key ) const
  {
    WrapperBase const * const wrapper = m_wrappers[ key ];
    GEOS_THROW_IF( wrapper == nullptr,
                   "Group " << getDataContext() << " has no wrapper named " << key << std::endl
                            << dumpWrappersNames(),
                   std::domain_error );
 
    return *wrapper;
  }
 
  template< typename KEY >
  WrapperBase & getWrapperBase( KEY const & key )
  {
    WrapperBase * const wrapper = m_wrappers[ key ];
    GEOS_THROW_IF( wrapper == nullptr,
                   "Group " << getDataContext() << " has no wrapper named " << key << std::endl
                            << dumpWrappersNames(),
                   std::domain_error );
 
    return *wrapper;
  }
 
  indexType getWrapperIndex( string const & name ) const
  { return m_wrappers.getIndex( name ); }
 
  wrapperMap const & wrappers() const
  { return m_wrappers; }
 
  wrapperMap & wrappers()
  { return m_wrappers; }
 
  indexType numWrappers() const
  { return m_wrappers.size(); }
 
  std::vector< string > getWrappersNames() const;
 
 
 
  template< typename LOOKUP_TYPE >
  bool hasWrapper( LOOKUP_TYPE const & lookup ) const
  { return m_wrappers[ lookup ] != nullptr; }
 
  template< typename T, typename LOOKUP_TYPE >
  Wrapper< T > const & getWrapper( LOOKUP_TYPE const & index ) const
  {
    WrapperBase const & wrapper = getWrapperBase( index );
    return dynamicCast< Wrapper< T > const & >( wrapper );
  }
 
  template< typename T, typename LOOKUP_TYPE >
  Wrapper< T > & getWrapper( LOOKUP_TYPE const & index )
  {
    WrapperBase & wrapper = getWrapperBase( index );
    return dynamicCast< Wrapper< T > & >( wrapper );
  }
 
  template< typename T, typename LOOKUP_TYPE >
  Wrapper< T > const * getWrapperPointer( LOOKUP_TYPE const & index ) const
  { return dynamicCast< Wrapper< T > const * >( m_wrappers[ index ] ); }
 
  template< typename T, typename LOOKUP_TYPE >
  Wrapper< T > * getWrapperPointer( LOOKUP_TYPE const & index )
  { return dynamicCast< Wrapper< T > * >( m_wrappers[ index ] ); }
 
 
 
  template< typename T, typename LOOKUP_TYPE >
  GEOS_DECLTYPE_AUTO_RETURN
  getReference( LOOKUP_TYPE const & lookup ) const
  { return getWrapper< T >( lookup ).reference(); }
 
  template< typename T, typename LOOKUP_TYPE >
  T & getReference( LOOKUP_TYPE const & lookup )
  { return getWrapper< T >( lookup ).reference(); }
 
  //END_SPHINX_INCLUDE_GET_WRAPPER
 
 
 
  virtual void resize( localIndex const newSize );
 
  virtual void reserve( indexType const newsize );
 
  inline localIndex capacity() const
  { return m_capacity; }
 
  inline localIndex size() const
  { return m_size; }
 
 
 
  inline string const & getName() const
  { return m_name; }
 
  string getPath() const;
 
  DataContext const & getDataContext() const
  { return *m_dataContext; }
 
  template< typename KEY >
  DataContext const & getWrapperDataContext( KEY key ) const
  { return getWrapperBase< KEY >( key ).getDataContext(); }
 
  Group & getParent()
  {
    GEOS_THROW_IF( m_parent == nullptr, "Group at " << getDataContext() << " does not have a parent.", std::domain_error );
    return *m_parent;
  }
 
  Group const & getParent() const
  {
    GEOS_THROW_IF( m_parent == nullptr, "Group at " << getDataContext() << " does not have a parent.", std::domain_error );
    return *m_parent;
  }
 
  bool hasParent() const
  { return m_parent != nullptr; }
 
  localIndex getIndexInParent() const
  { return m_parent->getSubGroups().getIndex( m_name ); }
 
  localIndex getSubGroupIndex( keyType const & key ) const;
 
  int sizedFromParent() const
  { return m_sizedFromParent; }
 
  Group & setSizedFromParent( int val )
  {
    m_sizedFromParent = val;
    return *this;
  }
  RestartFlags getRestartFlags() const { return m_restart_flags; }
 
  void setRestartFlags( RestartFlags flags ) { m_restart_flags = flags; }
 
  InputFlags getInputFlags() const { return m_input_flags; }
 
  void setInputFlags( InputFlags flags ) { m_input_flags = flags; }
 
 
  virtual bool registerCallback( void * func, const std::type_info & funcType )
  {
    GEOS_UNUSED_VAR( func );
    GEOS_UNUSED_VAR( funcType );
    return false;
  }
 
 
  conduit::Node & getConduitNode()
  { return m_conduitNode; }
 
  conduit::Node const & getConduitNode() const
  { return m_conduitNode; }
 
  void prepareToWrite();
 
  void finishWriting();
 
  void loadFromConduit();
 
  void enableLogLevelInput();
 
  void setLogLevel( integer const logLevel ) { m_logLevel = logLevel; }
 
  integer getLogLevel() const { return m_logLevel; }
 
  virtual void reinit() {}
 
#if defined(GEOSX_USE_PYGEOSX)
  virtual PyTypeObject * getPythonType() const;
#endif
 
protected:
 
 
  virtual void postProcessInput() {}
 
  virtual void initializePreSubGroups()
  {}
 
  virtual void initializePostSubGroups()
  {}
 
  virtual void initializePostInitialConditionsPreSubGroups()
  {}
 
  virtual void initializePostInitialConditionsPostSubGroups()
  {}
 
  virtual void postRestartInitialization()
  {}
 
 
 
 
private:
  virtual void processInputFile( xmlWrapper::xmlNode const & targetNode,
                                 xmlWrapper::xmlNodePos const & nodePos );
 
  Group const & getBaseGroupByPath( string const & path ) const;
 
  template< bool DO_PACKING >
  localIndex packImpl( buffer_unit_type * & buffer,
                       array1d< string > const & wrapperNames,
                       arrayView1d< localIndex const > const & packList,
                       integer const recursive,
                       bool onDevice,
                       parallelDeviceEvents & events ) const;
 
  //START_SPHINX_INCLUDE_02
  Group * m_parent = nullptr;
 
  integer m_sizedFromParent;
 
  wrapperMap m_wrappers;
 
  subGroupMap m_subGroups;
 
  indexType m_size;
 
  indexType m_capacity;
 
  string m_name;
 
  integer m_logLevel;
  //END_SPHINX_INCLUDE_02
 
  RestartFlags m_restart_flags;
 
  InputFlags m_input_flags;
 
  conduit::Node & m_conduitNode;
 
  std::unique_ptr< DataContext > m_dataContext;
 
};
 
using GroupKey = Group::subGroupMap::KeyIndex;
 
using ViewKey = Group::wrapperMap::KeyIndex;
 
// Doxygen bug - sees this as a separate function
template< typename T, typename TBASE >
Wrapper< TBASE > & Group::registerWrapper( string const & name,
                                           ViewKey::index_type * const rkey )
{
  std::unique_ptr< TBASE > newObj = std::make_unique< T >();
  m_wrappers.insert( name,
                     new Wrapper< TBASE >( name, *this, std::move( newObj ) ),
                     true );
 
  if( rkey != nullptr )
  {
    *rkey = m_wrappers.getIndex( name );
  }
 
  Wrapper< TBASE > & rval = getWrapper< TBASE >( name );
  if( rval.sizedFromParent() == 1 )
  {
    rval.resize( size());
  }
  return rval;
}
 
template< typename T, typename TBASE >
Wrapper< TBASE > & Group::registerWrapper( ViewKey const & viewKey )
{
  ViewKey::index_type index;
  Wrapper< TBASE > & rval = registerWrapper< T, TBASE >( viewKey.key(), &index );
  viewKey.setIndex( index );
 
  return rval;
}
 
 
template< typename T >
Wrapper< T > & Group::registerWrapper( string const & name,
                                       std::unique_ptr< T > newObject )
{
  static_assert( !std::is_base_of< WrapperBase, T >::value, "This function should not be used for `WrapperBase`. Use the dedicated `registerWrapper` instead." );
  m_wrappers.insert( name,
                     new Wrapper< T >( name, *this, std::move( newObject ) ),
                     true );
 
  Wrapper< T > & rval = getWrapper< T >( name );
  if( rval.sizedFromParent() == 1 )
  {
    rval.resize( size());
  }
  return rval;
}
 
template< typename T >
Wrapper< T > & Group::registerWrapper( string const & name,
                                       T * newObject )
{
  static_assert( !std::is_base_of< WrapperBase, T >::value, "This function should not be used for `WrapperBase`. Use the dedicated `registerWrapper` instead." );
  m_wrappers.insert( name,
                     new Wrapper< T >( name, *this, newObject ),
                     true );
 
  Wrapper< T > & rval = getWrapper< T >( name );
  if( rval.sizedFromParent() == 1 )
  {
    rval.resize( size());
  }
  return rval;
}
 
} /* end namespace dataRepository */
} /* end namespace geos */
 
#endif /* GEOS_DATAREPOSITORY_GROUP_HPP_ */