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