Selector.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_Selector_hpp
#define stk_mesh_Selector_hpp

#include <iosfwd>
#include <algorithm>
#include <stk_mesh/base/Types.hpp>
#include <string>

namespace stk_classic {
namespace mesh {

//An operator to obtain a part-ordinal from a part-iterator.
//This general template handles cases where the part-iterator
//iterates either stk_classic::mesh::Part or Fmwk::MeshPart objects.
//Specializations for part-ordinal-pointers follow below.
template<typename PartIterator>
struct GetPartIterOrdinal {
unsigned operator()(PartIterator p_it) const
{ return (*p_it)->mesh_meta_data_ordinal(); }
};

template<>
struct GetPartIterOrdinal<const unsigned*> {
unsigned operator()(const unsigned* p_it) const
{ return *p_it; }
};

template<>
struct GetPartIterOrdinal<unsigned*> {
unsigned operator()(unsigned* p_it) const
{ return *p_it; }
};


struct PartOrdLess {

bool operator()(unsigned lhs, unsigned rhs) const
{ return lhs < rhs; }

};

//Function to determine whether a specified part-ordinal is present
//in a given range of parts.
//Caller-provided comparison-operator compares a part-ordinal with
//one obtained from whatever a PartIterator dereferences to.
template<typename PartIterator, class Compare>
bool part_is_present(unsigned part_ord,
                     const std::pair<PartIterator, PartIterator>& part_range,
                     Compare comp)
{
  GetPartIterOrdinal<PartIterator> get_part_ordinal;

  // Search for 'part_ord' in the bucket's list of sorted integer part ords
  PartIterator p_it = std::lower_bound(part_range.first, part_range.second, part_ord, comp);
  return (p_it != part_range.second && get_part_ordinal(p_it) == part_ord);
}

enum Op{
        INVALID = 0,
        COMPOUND = 1,
        PART_ID = 2
       };

struct OpType {
  unsigned       m_part_id ; 
  unsigned short m_unary ;   
  unsigned short m_count ;   
  Op             m_op      ; 

  OpType() : m_part_id(0), m_unary(0), m_count(0), m_op(INVALID) {}
  OpType( unsigned part_id , unsigned unary , unsigned count, Op op=INVALID )
    : m_part_id( part_id ), m_unary( unary ), m_count( count ), m_op(op)  {}

  bool operator == (const OpType & opType ) const
  {
    return m_part_id == opType.m_part_id &&
           m_unary == opType.m_unary &&
           m_count == opType.m_count &&
           m_op == opType.m_op;
  }
  bool operator != (const OpType & opType ) const
  { return !(*this == opType); }
};

class Selector {
public:
  Selector();

  bool operator == (const Selector & rhs) const
  { return m_op == rhs.m_op; }

  bool operator != (const Selector & rhs) const
  { return m_op != rhs.m_op; }

  Selector( const Part & part);

  Selector & operator &= ( const Selector & selector);

  Selector & operator |= ( const Selector & selector);

  Selector & complement();

  Selector operator ! () const
    { Selector S( *this ); return S.complement(); }

  bool operator()( const Part & part ) const;

  bool operator()( const Bucket & candidate ) const;

  bool operator()( const Bucket * candidate ) const;

  bool operator()( const Entity & candidate ) const;

  template<typename PartIterator, class Compare>
  bool apply(const std::pair<PartIterator,PartIterator>& part_range, Compare comp) const
  { return apply(m_op.begin(), m_op.end(), part_range, comp); }

#ifndef SWIG
  friend std::ostream & operator << ( std::ostream & out, const Selector & selector);
#endif

  const std::vector<OpType>& get_ops() const { return m_op; }
  void set_ops(const std::vector<OpType>& ops) { m_op = ops; }

  void compoundAll();

private:

  const MetaData * m_mesh_meta_data ;

  std::vector< OpType > m_op ;

  void verify_compatible( const Selector & B ) const;

  void verify_compatible( const Bucket & B ) const;

  template<typename PartIterator, class Compare>
  bool apply(
      std::vector<OpType>::const_iterator i,
      std::vector<OpType>::const_iterator j,
      const std::pair<PartIterator,PartIterator>& part_range,
      Compare comp) const
  {
    bool result = i != j ;
    while ( result && i != j ) {
      const unsigned statement_length = i->m_count;
      if ( statement_length > 0 ) { // Check if compound statement
        result = i->m_unary ^ apply( i + 1 , i + statement_length , part_range , comp );
        i += statement_length;
      }
      else { // Test for containment of bucket in this part, or not in
        result = i->m_unary ^ part_is_present( i->m_part_id , part_range , comp );
        ++i ;
      }
    }
    return result ;
  }

  std::string printExpression(
      const std::vector<OpType>::const_iterator start,
      const std::vector<OpType>::const_iterator finish
      ) const;

};

class Part;

#ifndef SWIG
std::ostream & operator<<( std::ostream & out, const Selector & selector);
#endif

Selector operator & ( const Part & A , const Part & B );

Selector operator & ( const Part & A , const Selector & B );

Selector operator & ( const Selector & A, const Part & B );

Selector operator & ( const Selector & A, const Selector & B );

Selector operator | ( const Part & A , const Part & B );

Selector operator | ( const Part & A , const Selector & B );

Selector operator | ( const Selector & A, const Part & B  );

Selector operator | ( const Selector & A , const Selector & B );

Selector operator ! ( const Part & A );


Selector selectUnion( const PartVector& union_part_vector );

Selector selectIntersection( const PartVector& intersection_part_vector );

Selector selectField( const FieldBase& field );

} // namespace mesh
} // namespace stk_classic

#endif // stk_mesh_Selector_hpp