Relation.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_Relation_hpp
#define stk_mesh_Relation_hpp

#include <iosfwd>
#include <limits>

#include <stk_mesh/base/EntityKey.hpp>

namespace stk {
namespace mesh {

//----------------------------------------------------------------------
class Relation {
public:
  typedef uintptr_t raw_attr_type ;

  ~Relation() {}

  Relation() : m_attr(), m_entity(NULL) {}

  Relation( const Relation & r )
    : m_attr( r.m_attr ), m_entity(r.m_entity) {}

  Relation & operator = ( const Relation & r )
  {
    if( this != &r ) {
      m_attr   = r.m_attr ;
      m_entity = r.m_entity ;
    }
    return *this ;
  }

  Relation( raw_attr_type attr , Entity & entity );

  Relation( Entity & entity , unsigned identifier );

  static raw_attr_type attribute( unsigned rank , unsigned id );

  raw_attr_type attribute() const { return m_attr.value ; }

  unsigned entity_rank() const ;

  unsigned identifier() const ;

  Entity * entity() const { return m_entity ; }

  bool operator == ( const Relation & r ) const
    { return m_attr.value == r.m_attr.value && m_entity == r.m_entity ; }

  bool operator != ( const Relation & r ) const
    { return m_attr.value != r.m_attr.value || m_entity != r.m_entity ; }

  bool operator < ( const Relation & r ) const ;

private:

  enum {
    attr_digits   = std::numeric_limits<raw_attr_type>::digits ,
    uint_digits   = std::numeric_limits<unsigned>::digits ,
    rank_digits   = EntityKey::rank_digits ,
    id_max_digits = attr_digits - rank_digits ,
    id_digits     = uint_digits - rank_digits ,
    id_mask       = ~(0u) >> ( uint_digits - id_digits ),
    rank_shift    = id_max_digits
  };

  union AttrType {
  public:
    raw_attr_type value ;

    struct {
      raw_attr_type identifier  : id_digits ;
      raw_attr_type entity_rank : rank_digits ;
    } normal_view ;

    struct {
      raw_attr_type entity_rank : rank_digits ;
      raw_attr_type identifier  : id_digits ;
    } reverse_view ;

    AttrType( raw_attr_type v ) : value(v) {}
    AttrType() : value(0) {}
    AttrType( const AttrType & rhs ) : value( rhs.value ) {}
    AttrType & operator = ( const AttrType & rhs )
      { value = rhs.value ; return *this ; }
  };

  AttrType m_attr ;
  Entity * m_entity ;
};

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

inline
unsigned Relation::entity_rank() const
{ return unsigned( m_attr.value >> rank_shift ); }

inline
unsigned Relation::identifier() const
{ return unsigned( m_attr.value & id_mask ); }

struct LessRelation {
  bool operator() ( const Relation & lhs , const Relation & rhs ) const
    { return lhs < rhs ; }

  bool operator() ( const Relation & lhs , Relation::raw_attr_type rhs ) const
    { return lhs.attribute() < rhs ; }
};

//----------------------------------------------------------------------
void get_entities_through_relations(
  const std::vector<Entity*> & entities ,
        std::vector<Entity*> & entities_related );

void get_entities_through_relations(
  const std::vector<Entity*> & entities ,
        unsigned               entities_related_rank ,
        std::vector<Entity*> & entities_related );

//----------------------------------------------------------------------
bool membership_is_induced( const Part & part , unsigned entity_rank );

void induced_part_membership( Part & part ,
                              unsigned entity_rank_from ,
                              unsigned entity_rank_to ,
                              unsigned relation_identifier ,
                              PartVector & induced_parts );

void induced_part_membership( const Entity     & entity_from ,
                              const PartVector & omit ,
                                    unsigned     entity_rank_to ,
                                    unsigned     relation_identifier ,
                                    PartVector & entity_to_parts );

void induced_part_membership( const Entity     & entity ,
                              const PartVector & omit ,
                                    PartVector & induced );


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

#if 0

std::ostream &
print_relation( std::ostream & , Relation::raw__attr_type );

std::ostream &
print_relation( std::ostream & , const MetaData & ,
                Relation::raw__attr_type , EntityKey );
#endif

std::ostream & operator << ( std::ostream & , const Relation & );

} // namespace mesh
} // namespace stk

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

#endif /* stk_mesh_Relation_hpp */