IdentProc.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_search_IdentProc_hpp
#define stk_search_IdentProc_hpp

#include <ostream>
#include <iomanip>

#include <stk_search/SearchTypes.hpp>
#include <stk_util/util/SimpleArrayOps.hpp>

namespace stk {
namespace search {
namespace ident {

template <class K = uint64_t, class P = unsigned>
struct IdentProc {

  typedef K Key;
  typedef P Proc;

  IdentProc()
    : ident(),
      proc()
  {}

  ~IdentProc()
  {}

  IdentProc( const IdentProc & rhs )
    : ident(rhs.ident),
      proc(rhs.proc)
  {}

  IdentProc( Key i , Proc p )
    : ident(i),
      proc(p)
  {}

  IdentProc & operator = ( const IdentProc & rhs ) {
    ident = rhs.ident ;
    proc = rhs.proc ;
    return *this ;
  }
  inline bool operator==( const IdentProc<K, P> & rhs ) const {
    return !( (ident < rhs.ident || rhs.ident < ident) ||
              (proc  < rhs.proc  || rhs.proc  < proc ) );
  }

  inline bool operator<( const IdentProc<K, P> & rhs ) const {
    return ident < rhs.ident || (!(rhs.ident < ident) && proc < rhs.proc);
  }

  inline bool operator!=( const IdentProc<K, P> &rhs ) const {
    return  ( (ident < rhs.ident || rhs.ident < ident) ||
              (proc  < rhs.proc  || rhs.proc  < proc ) );
  }

  inline bool operator>( const IdentProc<K, P> &rhs ) const{
    return rhs < *this;
  }

  inline bool operator<=( const IdentProc<K, P> &rhs ) const {
    return !(rhs < *this);
  }

  inline bool operator>=(const IdentProc<K, P> &rhs ) const {
    return !(*this < rhs);
  }


  Key           ident;          
  Proc          proc;           
};


template <class K, class P>
std::ostream& operator<<(std::ostream &dout, const IdentProc<K, P> &ident_proc){
  dout << "id " << ident_proc.ident << ", proc " << ident_proc.proc;
  return dout;
}


} // namespace ident
} // namespace search
} // namespace stk

#endif