base/EntityKey.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_EntityKey_hpp
#define stk_mesh_EntityKey_hpp

#include <stdint.h>
#include <limits>
#include <boost/functional/hash.hpp>

#include <stk_mesh/base/Types.hpp>

namespace stk_classic {
namespace mesh {


// Note:  EntityRank and EntityId typedefs are defined in Types.hpp

//----------------------------------------------------------------------
union EntityKey {
public:
  typedef uint64_t raw_key_type ;

  enum { rank_digits = 8 };

private:

  enum {
    invalid_key = ~raw_key_type(0) ,
    raw_digits  = std::numeric_limits<raw_key_type>::digits ,
    id_digits   = raw_digits - rank_digits ,
    id_mask     = ~raw_key_type(0) >> rank_digits
  };

  raw_key_type key ;

  struct {
    raw_key_type id   : id_digits ;
    raw_key_type rank : rank_digits ;
  } normal_view ;

  struct {
    raw_key_type rank : rank_digits ;
    raw_key_type id   : id_digits ;
  } reverse_view ;

public:
  ~EntityKey() {}

  EntityKey() : key(invalid_key) { }

  EntityKey( const EntityKey & rhs ) : key( rhs.key ) {}

  EntityKey & operator = ( const EntityKey & rhs )
    { key = rhs.key ; return *this ; }

  EntityKey( EntityRank entity_rank, raw_key_type entity_id );

  raw_key_type id() const { return key & id_mask ; }

  EntityRank rank() const { return key >> id_digits ; }

  EntityRank type() const { return rank(); }

  bool operator==(const EntityKey &rhs) const {
    return key == rhs.key;
  }

  bool operator!=(const EntityKey &rhs) const {
    return !(key == rhs.key);
  }

  bool operator<(const EntityKey &rhs) const {
    return key < rhs.key;
  }

  bool operator>(const EntityKey &rhs) const {
    return rhs.key < key;
  }

  bool operator<=(const EntityKey &rhs) const {
    return !(key < rhs.key);
  }

  bool operator>=(const EntityKey &rhs) const {
    return !(rhs.key < key);
  }

  //------------------------------
  // As safe and explict a conversion
  // as possible between the raw_key_type and value.

  explicit EntityKey( const raw_key_type * const value )
   : key( *value ) {}

  raw_key_type raw_key() const { return key ; }
};

// Functions for encoding / decoding entity keys.

inline
EntityRank entity_rank( const EntityKey & key ) {
  return key.rank();
}

inline
EntityId  entity_id( const EntityKey & key ) {
  return key.id();
}

inline
bool entity_key_valid( const EntityKey & key ) {
  return key != EntityKey();
}

inline
bool entity_id_valid( EntityKey::raw_key_type id ) {
  return 0 < id && id <= EntityKey().id();
}

inline
size_t hash_value( EntityKey key) {
  return boost::hash_value(key.raw_key());
}



} // namespace mesh
} // namespace stk_classic

#endif /* stk_mesh_EntityKey_hpp */