ZGPeerID.h

Go to the documentation of this file.

#ifndef ZGPeerID_h
#define ZGPeerID_h

#include <string.h>  // for strchr()
#include "support/Flattenable.h"
#include "util/String.h"
#include "zg/ZGNameSpace.h"

namespace zg
{

enum {ZG_PEER_ID_TYPE = 2053597540}; 
class ZGPeerID : public PseudoFlattenable
{
public:
   ZGPeerID() : _highBits(0), _lowBits(0) {/* empty */}

   ZGPeerID(uint64 highBits, uint64 lowBits) : _highBits(highBits), _lowBits(lowBits) {/* empty */}

   bool operator == (const ZGPeerID & rhs) const {return ((_highBits == rhs._highBits)&&(_lowBits == rhs._lowBits));}

   bool operator != (const ZGPeerID & rhs) const {return !(*this==rhs);}

   bool operator <  (const ZGPeerID & rhs) const {return ((_highBits < rhs._highBits)||((_highBits == rhs._highBits)&&(_lowBits < rhs._lowBits)));}

   bool operator >= (const ZGPeerID & rhs) const {return !(*this<rhs);}

   bool operator >  (const ZGPeerID & rhs) const {return ((_highBits > rhs._highBits)||((_highBits == rhs._highBits)&&(_lowBits > rhs._lowBits)));}

   bool operator <= (const ZGPeerID & rhs) const {return !(*this>rhs);}

   ZGPeerID & operator = (const ZGPeerID & rhs) {_highBits = rhs._highBits; _lowBits = rhs._lowBits; return *this;}

   bool IsValid() const {return ((_highBits != 0)||(_lowBits != 0));}

   void FromString(const String & s)
   {
      _highBits = _lowBits = 0;

      const char * colon = strchr(s(), ':');
      if (colon)
      {
         _highBits = Atoxll(s());
         _lowBits  = Atoxll(colon+1);
      }
   }

   String ToString() const
   {
      char buf[256];
      muscleSprintf(buf, XINT64_FORMAT_SPEC ":" XINT64_FORMAT_SPEC, _highBits, _lowBits);
      return buf;
   }

   static MUSCLE_CONSTEXPR bool IsFixedSize() {return true;}

   static MUSCLE_CONSTEXPR uint32 TypeCode() {return ZG_PEER_ID_TYPE;}

   static MUSCLE_CONSTEXPR bool AllowsTypeCode(uint32 tc) {return (TypeCode()==tc);}

   static MUSCLE_CONSTEXPR uint32 FlattenedSize() {return 2*sizeof(uint64);}

   uint32 CalculateChecksum() const {return CalculateChecksumForUint64(_highBits) + (3*CalculateChecksumForUint64(_lowBits));}

   void Flatten(uint8 * buffer) const
   {
      muscleCopyOut(&buffer[0*sizeof(uint64)], B_HOST_TO_LENDIAN_INT64(_highBits));
      muscleCopyOut(&buffer[1*sizeof(uint64)], B_HOST_TO_LENDIAN_INT64(_lowBits));
   }

   status_t Unflatten(const uint8 * buffer, uint32 size)
   {
      if (size >= FlattenedSize())
      {
         _highBits = B_LENDIAN_TO_HOST_INT64(muscleCopyIn<uint64>(&buffer[0*sizeof(int64)]));
         _lowBits  = B_LENDIAN_TO_HOST_INT64(muscleCopyIn<uint64>(&buffer[1*sizeof(int64)]));
         return B_NO_ERROR;
      }
      else return B_ERROR;
   }

   uint32 HashCode() const {return CalculateChecksum();}

private:
   uint64 _highBits;
   uint64 _lowBits;
};

};  // end namespace zg

#endif