Bucket.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_Bucket_hpp
#define stk_mesh_Bucket_hpp
 
//----------------------------------------------------------------------
 
#include <iosfwd>
#include <vector>
#include <algorithm>
 
#include <stk_util/environment/ReportHandler.hpp>
 
#include <stk_mesh/baseImpl/BucketImpl.hpp>
 
#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/Field.hpp>
#include <stk_mesh/base/Part.hpp>
#include <stk_mesh/base/Entity.hpp>
 
#include <boost/iterator/transform_iterator.hpp>
#include <boost/iterator/indirect_iterator.hpp>
 
//----------------------------------------------------------------------
 
#ifdef SIERRA_MIGRATION
 
namespace sierra {
namespace Fmwk {
 
class MeshBulkData;
 
}
}
 
 
#endif
 
namespace stk_classic {
namespace mesh {
 
namespace impl {
class BucketRepository;
} // namespace impl
 
 
std::ostream & operator << ( std::ostream & , const Bucket & );
 
std::ostream &
print( std::ostream & , const std::string & indent , const Bucket & );
 
// The part count and parts are equal
bool bucket_part_equal( const unsigned * lhs , const unsigned * rhs );
 
//----------------------------------------------------------------------
bool has_superset( const Bucket & ,  const Part & p );
 
bool has_superset( const Bucket & ,  const unsigned & ordinal );
 
bool has_superset( const Bucket & , const PartVector & );
 
 
//----------------------------------------------------------------------
class Bucket {
private:
  friend class impl::BucketRepository;
  friend class impl::BucketImpl;
 
  impl::BucketImpl       m_bucketImpl;
 
#ifdef SIERRA_MIGRATION
  const void*            m_fmwk_mesh_bulk_data;
#endif
 
public:
 
  //--------------------------------
  // Container-like types and methods:
 
  typedef boost::indirect_iterator<Entity*const*> iterator ;
 
  inline iterator begin() const { return iterator(m_bucketImpl.begin()); }
 
  inline iterator end() const { return iterator(m_bucketImpl.end()); }
 
  size_t size() const { return m_bucketImpl.size() ; }
 
  size_t capacity() const { return m_bucketImpl.capacity() ; }
 
  Entity & operator[] ( size_t i ) const { return m_bucketImpl[i] ; }
 
  unsigned field_data_size(const FieldBase & field) const
  { return m_bucketImpl.field_data_size(field); }
 
  const FieldBase::Restriction::size_type * field_data_stride( const FieldBase & field ) const
  { return m_bucketImpl.field_data_stride(field); }
 
  unsigned char * field_data_location( const FieldBase & field, const Entity & entity ) const
  { return m_bucketImpl.field_data_location(field,entity); }
 
  unsigned char * field_data_location( const FieldBase & field, unsigned ordinal ) const
  { return m_bucketImpl.field_data_location(field, ordinal); }
 
  unsigned char * fast_field_data_location( const FieldBase & field, unsigned ordinal ) const
  { return m_bucketImpl.fast_field_data_location(field, ordinal); }
 
  unsigned char * field_data_location( const FieldBase & field ) const
  { return m_bucketImpl.field_data_location(field); }
 
  template< class field_type >
  typename FieldTraits< field_type >::data_type *
  field_data( const field_type & field , const Entity & entity ) const
  { return m_bucketImpl.field_data(field,entity.bucket_ordinal()); }
 
  //--------------------------------
  BulkData & mesh() const { return m_bucketImpl.mesh(); }
 
  unsigned entity_rank() const { return m_bucketImpl.entity_rank(); }
 
  void supersets( PartVector & ) const ;
  void supersets( OrdinalVector & ) const ;
 
  //--------------------------------
  bool member( const Part & ) const ;
 
  bool member_all( const PartVector & ) const ;
  bool member_all( const OrdinalVector & ) const ;
 
  bool member_any( const PartVector & ) const ;
  bool member_any( const OrdinalVector & ) const ;
 
  //--------------------------------
  std::pair<const unsigned *, const unsigned *>
    superset_part_ordinals() const { return m_bucketImpl.superset_part_ordinals() ; }
 
  bool equivalent( const Bucket& b ) const {
    return m_bucketImpl.equivalent(b.m_bucketImpl);
  }
 
#ifndef DOXYGEN_COMPILE
  const unsigned * key() const { return m_bucketImpl.key() ; }
#endif /* DOXYGEN_COMPILE */
 
  unsigned allocation_size() const { return m_bucketImpl.allocation_size() ; }
 
  bool assert_correct() const;
 
#ifdef SIERRA_MIGRATION
  typedef std::pair<iterator, iterator> EntityRange;
 
  bool is_empty() const { return size() == 0; }
 
  const sierra::Fmwk::MeshBulkData* get_bulk_data() const
  {
    return static_cast<const sierra::Fmwk::MeshBulkData*>(m_fmwk_mesh_bulk_data);
  }
 
  template <class T>
  void set_bulk_data(const T* bulk_ptr) { m_fmwk_mesh_bulk_data = bulk_ptr; }
#endif
 
private:
  BulkData & bulk_data() const { return m_bucketImpl.mesh(); }
 
  // Only reason to define this at all is to ensure it's private
  ~Bucket() {}
 
  Bucket();
  Bucket( const Bucket & );
  Bucket & operator = ( const Bucket & );
 
  Bucket( BulkData & arg_mesh ,
          EntityRank arg_entity_rank,
          const std::vector<unsigned> & arg_key,
          size_t arg_capacity
        );
 
  friend class ::stk_classic::mesh::BulkData;
};
 
 
struct BucketLess {
  bool operator()( const Bucket * lhs_bucket , const unsigned * rhs ) const ;
  bool operator()( const unsigned * lhs , const Bucket * rhs_bucket ) const ;
};
 
 
inline
std::vector<Bucket*>::iterator
lower_bound( std::vector<Bucket*> & v , const unsigned * key )
{ return std::lower_bound( v.begin() , v.end() , key , BucketLess() ); }
 
inline
Bucket::Bucket( BulkData & arg_mesh ,
                EntityRank arg_entity_rank,
                const std::vector<unsigned> & arg_key,
                size_t arg_capacity
        )
  : m_bucketImpl(arg_mesh,arg_entity_rank,arg_key,arg_capacity)
{}
 
inline
bool Bucket::member_all( const OrdinalVector& parts ) const
{
  const unsigned * const i_beg = key() + 1 ;
  const unsigned * const i_end = key() + key()[0] ;
 
  const OrdinalVector::const_iterator ip_end = parts.end();
        OrdinalVector::const_iterator ip     = parts.begin() ;
 
  bool result_all = true ;
 
  for ( ; result_all && ip_end != ip ; ++ip ) {
    const unsigned ord = *ip;
    result_all = contains_ordinal(i_beg, i_end, ord);
  }
  return result_all ;
}
 
struct To_Ptr : std::unary_function<Entity&, Entity*>
{
  Entity* operator()(Entity& entity) const
  {
    return &entity;
  }
};
 
// Sometimes, we want a bucket-iterator to dereference to an Entity*
typedef boost::transform_iterator<To_Ptr, Bucket::iterator> BucketPtrIterator;
 
typedef Bucket::iterator BucketIterator;
 
} // namespace mesh
} // namespace stk_classic
 
#endif