FieldBase.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef stk_mesh_base_FieldBase_hpp
#define stk_mesh_base_FieldBase_hpp

#include <iosfwd>
#include <string>
#include <vector>

#include <Shards_Array.hpp>

#include <stk_util/util/SimpleArrayOps.hpp>
#include <stk_util/util/CSet.hpp>

#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/DataTraits.hpp>

#include <stk_mesh/base/FieldState.hpp>

#include <stk_mesh/base/FieldRestriction.hpp>
#include <stk_mesh/baseImpl/FieldBaseImpl.hpp>

namespace stk_classic {
namespace mesh {

class UnitTestFieldImpl;

namespace impl {

class FieldRepository;

}

//----------------------------------------------------------------------
// Implementation details:
//   Simply wraps a FieldBaseImpl object which is kept as a member, all calls are
//   inlined and passed through to the impl object. This design is analogous
//   to the "P-impl" pattern.
class FieldBase
{
  public:
  MetaData & mesh_meta_data() const { return m_impl.meta_data(); }
  unsigned mesh_meta_data_ordinal() const { return m_impl.ordinal(); }

  const std::string & name() const { return m_impl.name() ; }

  template<class Type> bool type_is() const
  { return m_impl.type_is<Type>(); }

  const DataTraits & data_traits() const { return m_impl.data_traits() ; }

  unsigned number_of_states() const { return m_impl.number_of_states() ; }

  FieldState state() const { return m_impl.state() ; }

  unsigned rank() const { return m_impl.rank(); }

  const shards::ArrayDimTag * const * dimension_tags() const
  { return m_impl.dimension_tags() ; }

  unsigned max_size( EntityRank entity_rank) const {
    return m_impl.max_size( entity_rank );
  }

  //----------------------------------------

  template<class A>
  const A * attribute() const { return m_impl.attribute<A>(); }

  typedef FieldRestriction Restriction;

  typedef FieldRestrictionVector RestrictionVector;

  const RestrictionVector &restrictions() const {
    return m_impl.restrictions();
  }

  const RestrictionVector &selector_restrictions() const {
    return m_impl.selector_restrictions();
  }

  const Restriction & restriction( unsigned entity_rank , const Part & part ) const {
    return m_impl.restriction( entity_rank, part);
  }

  //----------------------------------------

  FieldBase * field_state( FieldState fstate) const {
    return m_impl.field_state(fstate);
  }

  const void* get_initial_value() const { return m_impl.get_initial_value(); }

  void* get_initial_value() { return m_impl.get_initial_value(); }

  unsigned get_initial_value_num_bytes() const { return m_impl.get_initial_value_num_bytes(); }

private:

  MetaData & meta_data() const { return m_impl.meta_data(); }

  friend class ::stk_classic::mesh::MetaData ;
  friend class ::stk_classic::mesh::impl::FieldRepository ;
  friend class ::stk_classic::mesh::impl::FieldBaseImpl ;

  friend class ::stk_classic::mesh::UnitTestFieldImpl ;

  FieldBase(
      MetaData                   * arg_mesh_meta_data ,
      unsigned                     arg_ordinal ,
      const std::string          & arg_name ,
      const DataTraits           & arg_traits ,
      unsigned                     arg_rank,
      const shards::ArrayDimTag  * const * arg_dim_tags,
      unsigned                     arg_number_of_states ,
      FieldState                   arg_this_state
      )
    : m_impl(
        arg_mesh_meta_data,
        arg_ordinal,
        arg_name,
        arg_traits,
        arg_rank,
        arg_dim_tags,
        arg_number_of_states,
        arg_this_state
        )
  {}

  // WORKAROUND 5/19/2010 [DGB]: intel 10.? and pgi do not link if this is made virtual
  //  virtual ~FieldBase();

  impl::FieldBaseImpl  m_impl;

  //the following functions are declared but not defined
  FieldBase();
  FieldBase( const FieldBase & );
  FieldBase & operator = ( const FieldBase & );
};

std::ostream & operator << ( std::ostream & , const FieldBase & );

std::ostream & print( std::ostream & ,
                      const char * const , const FieldBase & );

} //namespace mesh
} //namespace stk_classic

#endif //stk_mesh_base_FieldBase_hpp