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 <algorithm>

#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_classic {
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:

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


  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_classic::mesh::impl::PartRepository ;
  friend class ::stk_classic::mesh::MetaData ;

#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 */

};

static const char INTERNAL_PART_PREFIX  = '{';
static const char INTERNAL_PART_POSTFIX = '}';

inline
bool is_internal(const std::string& part_name)
{
  return part_name.size() > 2 && *part_name.begin() == INTERNAL_PART_PREFIX && *part_name.rbegin() == INTERNAL_PART_POSTFIX;
}

inline
bool is_internal(const Part& part)
{ return is_internal(part.name()); }

std::string convert_to_internal_name(const std::string& part_name);

//----------------------------------------------------------------------
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 & );

inline
void order( OrdinalVector & v )
{
  OrdinalVector::iterator ev = v.end();
  OrdinalVector::iterator iv = v.begin();
  std::sort( iv , ev );
  iv = std::unique( iv , ev );
  v.erase( iv , ev );
}

bool insert( PartVector & , Part & );

inline
bool insert_ordinal( OrdinalVector & v , unsigned part_ordinal )
{
  for(OrdinalVector::iterator i=v.begin(), e=v.end(); i!=e; ++i) {
    if (*i == part_ordinal) return false;
    if (*i > part_ordinal) {
      v.insert(i, part_ordinal);
      return true;
    }
  }

  v.push_back(part_ordinal);
  return true ;
}

void remove( PartVector & , Part & );

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

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

template<class Iterator>
inline
bool contains_ordinal( Iterator beg, Iterator end, unsigned part_ordinal )
{
  for(Iterator i=beg; i!=end; ++i) {
    if (*i == part_ordinal) return true;
  }

  return false;
}

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_classic

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

#endif