WrapperBase.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 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_DATAREPOSITORY_WRAPPERBASE_HPP_
#define GEOSX_DATAREPOSITORY_WRAPPERBASE_HPP_

#include "common/DataTypes.hpp"
#include "InputFlags.hpp"
#include "xmlWrapper.hpp"
#include "RestartFlags.hpp"
#include "rajaInterface/GEOS_RAJA_Interface.hpp"
#include "managers/TimeHistory/HistoryDataSpec.hpp"

#include <string>
#include <memory>
#include <set>

namespace conduit
{
class Node;
}


namespace geosx
{
namespace dataRepository
{

class Group;

class WrapperBase
{
public:


  explicit WrapperBase( string const & name,
                        Group * const parent );

  WrapperBase() = delete;
  WrapperBase( WrapperBase const & ) = delete;
  WrapperBase( WrapperBase && ) = delete;
  WrapperBase & operator=( WrapperBase const & ) = delete;
  WrapperBase & operator=( WrapperBase && ) = delete;

  virtual ~WrapperBase();



  virtual localIndex size() const = 0;

  virtual void const * voidPointer() const = 0;

  virtual localIndex elementByteSize() const = 0;

  virtual void resize( int num_dims, localIndex const * const dims ) = 0;

  virtual void reserve( localIndex const newCapacity ) = 0;

  virtual localIndex capacity() const = 0;

  virtual void resize( localIndex newsize ) = 0;

  void resize();

  virtual void copy( localIndex const sourceIndex, localIndex const destIndex ) = 0;

  virtual void move( LvArray::MemorySpace const space, bool const touch ) const = 0;

  virtual string typeRegex() const = 0;


  virtual bool hasDefaultValue() const = 0;

  virtual std::string getDefaultValueString() const = 0;

  virtual bool processInputFile( xmlWrapper::xmlNode const & targetNode ) = 0;

  virtual void addBlueprintField( conduit::Node & fields,
                                  std::string const & name,
                                  std::string const & topology,
                                  std::vector< std::string > const & componentNames = {} ) const = 0;

  virtual void populateMCArray( conduit::Node & node, std::vector< std::string > const & componentNames = {} ) const = 0;

  virtual std::unique_ptr< WrapperBase > averageOverSecondDim( std::string const & name, Group & group ) const = 0;


  virtual void registerToWrite() const = 0;

  virtual void finishWriting() const = 0;

  virtual bool loadFromConduit() = 0;


  virtual HistoryMetadata getHistoryMetadata( localIndex const packCount ) const = 0;


  virtual
  bool isPackable( bool onDevice ) const = 0;

  virtual
  localIndex Pack( buffer_unit_type * & buffer, bool withMetadata, bool onDevice ) const = 0;

  virtual
  localIndex PackByIndex( buffer_unit_type * & buffer, arrayView1d< localIndex const > const & packList, bool withMetadata, bool onDevice ) const = 0;

  virtual
  localIndex PackSize( bool withMetadata, bool onDevice ) const = 0;

  virtual
  localIndex PackByIndexSize( arrayView1d< localIndex const > const & packList, bool withMetadata, bool onDevice ) const = 0;

  virtual
  localIndex Unpack( buffer_unit_type const * & buffer, bool withMetadata, bool onDevice ) = 0;

  virtual
  localIndex UnpackByIndex( buffer_unit_type const * & buffer, arrayView1d< localIndex const > const & unpackIndices, bool withMetadata, bool onDevice ) = 0;



  int sizedFromParent() const
  {
    return m_sizedFromParent;
  }

  WrapperBase * setSizedFromParent( int val )
  {
    m_sizedFromParent = val;
    return this;
  }

  RestartFlags getRestartFlags() const { return m_restart_flags; }

  WrapperBase * setRestartFlags( RestartFlags flags )
  {
    m_restart_flags = flags;
    return this;
  }

  PlotLevel getPlotLevel() const { return m_plotLevel; }

  WrapperBase * setPlotLevel( PlotLevel const flag )
  {
    m_plotLevel = flag;
    return this;
  }

  string const & getName() const
  {
    return m_name;
  }

  WrapperBase * setInputFlag( InputFlags const input )
  {
    if( input == InputFlags::OPTIONAL || input == InputFlags::REQUIRED )
    {
      this->setSizedFromParent( 0 );
      m_restart_flags = RestartFlags::WRITE;
    }
    m_inputFlag = input;
    return this;
  }

  InputFlags getInputFlag() const
  {
    return m_inputFlag;
  }

  WrapperBase * setDescription( string const & description )
  {
    m_description = description;
    return this;
  }

  string const & getDescription() const
  {
    return m_description;
  }

  string dumpInputOptions( bool const outputHeader ) const;


  std::set< string > const & getRegisteringObjects() const
  {
    return m_registeringObjects;
  }

  WrapperBase * setRegisteringObjects( string const & objectName )
  {
    m_registeringObjects.insert( objectName );
    return this;
  }



  virtual void copyWrapperAttributes( WrapperBase const & source );

  virtual std::unique_ptr< WrapperBase > clone( string const & name,
                                                Group * const parent ) = 0;

  virtual void copyData( WrapperBase const & source ) = 0;

  virtual void copyWrapper( WrapperBase const & source ) = 0;

  virtual std::type_info const & get_typeid() const = 0;


#if defined(USE_TOTALVIEW_OUTPUT)

  virtual string totalviewTypeName() const = 0;

  virtual int setTotalviewDisplay() const;
//  static int TV_ttf_display_type( const WrapperBase * wrapper);
#endif

protected:


  conduit::Node & getConduitNode()
  {
    return m_conduitNode;
  }


protected:

  string m_name;

  Group * m_parent;

  int m_sizedFromParent;

  RestartFlags m_restart_flags;

  PlotLevel m_plotLevel;

  InputFlags m_inputFlag;

  string m_description;

  std::set< string > m_registeringObjects;

  conduit::Node & m_conduitNode;
};

} 
} 

#endif /* GEOSX_DATAREPOSITORY_WRAPPERBASE_HPP_ */