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 {
namespace mesh {

namespace impl {
  class FieldRepository;
}

  //----------------------------------------------------------------------
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( unsigned 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 Restriction & restriction( unsigned entity_rank , const Part & part ) const {
    return m_impl.restriction( entity_rank, part);
  }

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

  FieldBase * field_state( unsigned i) const {
    return m_impl.field_state(i);
  }

private:

  friend class ::stk::mesh::impl::FieldRepository ;
  friend class ::stk::mesh::impl::FieldBaseImpl ;

  friend class ::stk::mesh::UnitTestMetaData ;


  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();
  ~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

#endif //stk_mesh_base_FieldBase_hpp