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

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

namespace stk {
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 BucketIterator : std::iterator<std::random_access_iterator_tag,Entity > {
private:
  const Bucket * m_bucket_ptr;
  size_t         m_current_entity;

  inline Entity & entity( const size_t ) const ;

  void throw_error(const char *err) const;

  template< class field_type >
    friend
    typename FieldTraits< field_type >::data_type *
    field_data( const field_type & f , const BucketIterator &i );

  template< class field_type > friend struct BucketArray ;

public:

  template< typename intType >
  BucketIterator(const Bucket * const bucket_ptr, intType offset) {
    m_bucket_ptr = bucket_ptr;
    m_current_entity = offset;
  }

  BucketIterator() {
    m_bucket_ptr = NULL;
    m_current_entity = 0;
  }

  BucketIterator(const BucketIterator &i) {
    m_bucket_ptr = i.m_bucket_ptr;
    m_current_entity = i.m_current_entity;
  }

  BucketIterator & operator=(const BucketIterator &i) {
    m_bucket_ptr = i.m_bucket_ptr;
    m_current_entity = i.m_current_entity;
    return *this;
  }

  inline Entity & operator*() const { return entity(0); }

  inline Entity * operator->() const { return & entity(0); }

  inline BucketIterator & operator++() {
    ++m_current_entity;
    return *this;
  }

  inline BucketIterator & operator--() {
    --m_current_entity;
    return *this;
  }

  inline BucketIterator operator++(int) {
    BucketIterator temp = *this;
    ++m_current_entity;
    return temp;
  }

  inline BucketIterator operator--(int) {
    BucketIterator temp = *this;
    --m_current_entity;
    return temp;
  }

  inline bool operator<(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator < given iterator from different bucket");
    return (m_current_entity < i.m_current_entity);
  }

  inline bool operator<=(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator <= given iterator from different bucket");
    return (m_current_entity <= i.m_current_entity);
  }

  inline bool operator>(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator > given iterator from different bucket");
    return (m_current_entity > i.m_current_entity);
  }

  inline bool operator>=(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator >= given iterator from different bucket");
    return (m_current_entity >= i.m_current_entity);
  }

  inline bool operator==(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator == given iterator from different bucket");
    return (m_current_entity == i.m_current_entity);
  }

  inline bool operator!=(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator != given iterator from different bucket");
    return (m_current_entity != i.m_current_entity);
  }

  inline BucketIterator & operator+=(int n) {
    m_current_entity += n;
    return *this;
  }

  inline BucketIterator & operator-=(int n) {
    m_current_entity -= n;
    return *this;
  }

  inline BucketIterator operator+(int n) const {
    return BucketIterator(m_bucket_ptr, m_current_entity + n);
  }

  inline BucketIterator operator-(int n) const {
    return BucketIterator(m_bucket_ptr, m_current_entity - n);
  }

  inline ptrdiff_t operator-(const BucketIterator &i) const {
    if (m_bucket_ptr != i.m_bucket_ptr)
      throw_error("operator - given iterator from different bucket");
    return static_cast<ptrdiff_t>(m_current_entity - i.m_current_entity);
  }

  template< typename intType >
  inline Entity & operator[]( const intType & n ) const { return entity(n); }

}; // class BucketIterator

//----------------------------------------------------------------------
class Bucket {
private:
  friend class impl::BucketRepository ;
  friend class impl::BucketImpl ;

  impl::BucketImpl       m_bucketImpl ;

public:

  //--------------------------------
  // Container-like types and methods:

  typedef BucketIterator iterator ;

  inline iterator begin() const { return iterator(this,0); }

  inline iterator end() const { return iterator(this,size()); }

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

  //--------------------------------
  bool member( const Part & ) const ;

  bool member_all( const std::vector<Part*> & ) const ;

  bool member_any( const std::vector<Part*> & ) 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() ; }

private:

  ~Bucket();
  Bucket();
  Bucket( const Bucket & );
  Bucket & operator = ( const Bucket & );

  Bucket( BulkData        & arg_mesh ,
          unsigned          arg_entity_rank ,
          const unsigned  * arg_key ,
          size_t            arg_alloc_size ,
          size_t            arg_capacity ,
          impl::BucketImpl::DataMap * arg_field_map ,
          Entity         ** arg_entity_array );

};



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



} // namespace mesh
} // namespace stk

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

namespace stk {
namespace mesh {

inline Entity & BucketIterator::entity( const size_t i ) const
{
  //if ( ! m_bucket_ptr ) { throw_error("is NULL"); }
  return (*m_bucket_ptr)[ m_current_entity + i ] ;
}

}
}

#endif