Part.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_Part_hpp
#define stk_mesh_Part_hpp

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

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

#include <stk_util/util/CSet.hpp>
#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/PartRelation.hpp>
#include <stk_mesh/baseImpl/PartImpl.hpp>

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

namespace stk {
namespace mesh {

namespace impl {
  class PartRepository;
} // namespace impl

//----------------------------------------------------------------------
class Part {
public:

  MetaData & mesh_meta_data() const { return m_partImpl.mesh_meta_data(); }

  unsigned primary_entity_rank() const { return m_partImpl.primary_entity_rank(); }

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

  unsigned mesh_meta_data_ordinal() const { return m_partImpl.mesh_meta_data_ordinal(); }

  const PartVector & supersets() const { return m_partImpl.supersets(); }

  const PartVector & subsets() const { return m_partImpl.subsets(); }

  const PartVector & intersection_of() const { return m_partImpl.intersection_of(); }

  const std::vector<PartRelation> & relations() const { return m_partImpl.relations(); }

  bool operator == ( const Part & rhs ) const { return this == & rhs ; }

  bool operator != ( const Part & rhs ) const { return this != & rhs ; }

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

private:

  impl::PartImpl m_partImpl;

  /* \brief  A part is owned by a PartRepository, as such only the owning
   *         PartRepository can create, delete, or modify a part.
   *         The owner-modifies rule is enforced by the implementation being
   *         a private data object on the Part and the PartRepository is a
   *         friend.
   */
  friend class ::stk::mesh::impl::PartRepository ;

#ifndef DOXYGEN_COMPILE

  Part( MetaData * arg_meta_data , const std::string & arg_name, EntityRank arg_rank, size_t arg_ordinal)
    : m_partImpl(arg_meta_data,arg_name,arg_rank,arg_ordinal)
  { }

  ~Part() {}
  Part();
  Part( const Part & );
  Part & operator = ( const Part & );

#endif /* DOXYGEN_COMPILE */

};

//----------------------------------------------------------------------
struct PartLess {

  inline bool operator()( const Part & lhs , const Part & rhs ) const
    { return lhs.mesh_meta_data_ordinal() < rhs.mesh_meta_data_ordinal(); }

  inline bool operator()( const Part & lhs , const Part * rhs ) const
    { return lhs.mesh_meta_data_ordinal() < rhs->mesh_meta_data_ordinal(); }

  inline bool operator()( const Part * lhs , const Part & rhs ) const
    { return lhs->mesh_meta_data_ordinal() < rhs.mesh_meta_data_ordinal(); }

  inline bool operator()( const Part * lhs , const Part * rhs ) const
    { return lhs->mesh_meta_data_ordinal() < rhs->mesh_meta_data_ordinal(); }
};

void order( PartVector & );

bool insert( PartVector & , Part & );

void remove( PartVector & , Part & );

Part * find( const PartVector & , const std::string & );

bool contain( const PartVector & , const Part & );

bool contain( const PartVector & , const PartVector & );

size_t intersect( const PartVector & , const PartVector & );

size_t intersect( const PartVector & , const PartVector & , PartVector & );

bool intersect( const Part & , const Part & );

//----------------------------------------------------------------------
std::ostream & print( std::ostream & , const char * const , const Part & );


} // namespace mesh
} // namespace stk

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

#endif