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 <stk_mesh/base/Types.hpp>

namespace stk {
namespace mesh {

class Selector {
public:
  ~Selector();

  Selector();

  Selector( const Selector & selector);

  Selector & operator = ( const Selector & B );

  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 Bucket & candidate ) const ;

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

  friend std::ostream & operator << ( std::ostream & out, const Selector & selector);

private:

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

    OpType() : m_part_id(0), m_unary(0), m_count(0) {}
    OpType( unsigned part_id , unsigned unary , unsigned count )
      : m_part_id( part_id ), m_unary( unary ), m_count( count ) {}
    OpType( const OpType & opType );
    OpType & operator = ( const OpType & opType );
  };

  friend class std::vector<OpType> ;

  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;

  bool apply(
      unsigned part_id ,
      const Bucket & candidate
      ) const;

  bool apply(
      std::vector<OpType>::const_iterator start,
      std::vector<OpType>::const_iterator finish,
      const Bucket & candidate
      ) const;

  void compoundAll();

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

};

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

} // namespace mesh
} // namespace stk

#endif // stk_mesh_Selector_hpp