UUID.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "UUID.hh"

#include <sstream>

#include <limits>

#ifndef WIN32
#include <unistd.h> // for usleep
#endif

using namespace BIAS;
using namespace std;

// static initialization 
timeval BIAS::UUID::LastGenerationTime_ = {
#ifdef WIN32
  0,0
#else
  numeric_limits<time_t>::min(),
  numeric_limits<suseconds_t>::min()
#endif
};
long BIAS::UUID::g_uniqueCounter = 0;


// jw
BIAS::UUID::~UUID(){}


// TODO: discuss change from bool isValid to IsNUL comparison ?
BIAS::UUID::UUID() 
{
  this->clear();
}


// copy ctor
BIAS::UUID::UUID(const BIAS::UUID& id) 
{ 
  (*this) = id; 
}


BIAS::UUID::UUID(const uuid_t &id) {
  // TOOD: use uuid_copy instead on Linux (jw)
  memcpy(
         (void*)&theID_,
         (void*)&id,
         sizeof(uuid_t)
         );
  IsValid_ = true;
}


// very slow. JW
BIAS::UUID::UUID(const std::string &sID){
  SetFromString(sID);
}


BIAS::UUID::UUID(const unsigned long & n)
{
  SetFromLong(n);
}


// jw
void BIAS::UUID::clear()
{
#ifdef WIN32
  // does not take significant performace. (1.000.000 =16 msec) JW
  UuidCreateNil( &(this->theID_) );
#else //WIN32
  uuid_clear(this->theID_);
#endif //WIN32

  // invalidate because NULL UID is not unique in general.
  IsValid_ = false;
}


// jw
bool BIAS::UUID::IsNil() const
{
  if (IsConsecutive()){
    return !IsValid_;
  } 
  // the following does not work for consecutive ids...
    bool result=false;
#ifdef WIN32    
  RPC_STATUS status=RPC_S_OK;
  result = (TRUE==UuidIsNil( 
                            (uuid_t * )(&theID_), 
                            &status )
            );
  BIASASSERT(status==RPC_S_OK);
#else //WIN32
  result = (1==uuid_is_null(theID_));
#endif //WIN32
  return result;
}



bool BIAS::UUID::SetFromString(const std::string &sID) {
#ifdef WIN32
  char *tmp = const_cast<char *>(sID.c_str());
  unsigned char * cUUIDwin = reinterpret_cast<unsigned char *>(tmp);
  // jw: WIN system func from rpcdce.h
  // maps to UuidFromStringA for ASCII (standard for us ) 
  // and UuidFromStringW for UNICODE build (untested)
  if (UuidFromString(cUUIDwin, &theID_)!=RPC_S_OK) {
    BIASERR("UUID could not be read!");
    IsValid_ = false;
  }
  else IsValid_ = true;
  //  std::cout <<"After Parser: "<<std::hex<<theID_.Data1<<"-"
  //     <<theID_.Data2<<std::dec<<std::endl;
#else
  if (sID.length()!=36) 
    BIASERR("Wrong size of string to construct from: "<<sID);
  if (uuid_parse(sID.c_str(), theID_)!=0) {
    BIASERR("UUID could not be read!");
    IsValid_ = false;
  }
  else   IsValid_ = true;
#endif
  return IsValid_;
}


// jw
bool BIAS::UUID::SetFromLong(const unsigned long & n) {
  clear();
  this->IsValid_ = true;

#ifdef WIN32
  theID_.Data1=n; // unsigned long 
  // distinguish sequential 0 ID from NIL ID by setting exactly one more element to one:
  theID_.Data2=1; // unsigned short 
  // keep a copy for future consistency checks: 
  //BIASASSERT(sizeof(n) <= 8);
  memcpy( 
         (void*)(&(theID_.Data4[8-sizeof(n)])), // dest ptr
         (void*)(&n), // src ptr
         sizeof(n) );
  return true;
#else // WIN32       
  // TODO: inefficient, store the unsigned long directly in the unsigned char[16] JW 
  std::stringstream ss;
  // unused prefix:
  ss<<"00000000-0000-0000-0000-";
  // 12 digit hex format with leading zeroes
  ss<<setfill('0')<<setw(12)<<noshowbase<<hex<<n;
  return SetFromString( ss.str() );    
#endif // WIN32
}

// jw
unsigned long BIAS::UUID::GetLong() const 
{
  if ( !IsConsecutive() ){
    // uuid is not consecutive and the call to GetLong is not allowed
    BIASERR("cannot extract non-consecutive uuid into long");
    BIASABORT;
  }
  
    unsigned long n=0;
#ifdef WIN32
#  ifdef BIAS_DEBUG
  // compare values to reserved pattern for consecutive ID`s
  if (
      (theID_.Data2   !=1) || 
      (theID_.Data3   !=0) ||
      (theID_.Data4[0]!=0) ||
      (theID_.Data4[1]!=0) 
      )
    {
      BIASWARNONCE("you are trying to GetLong a consecutive ID "<<endl
                   <<(*this)<<endl
                   <<"with data fields that dont match the reserved consecutive pattern: \"<longID>-0001-0000-0000-*"
                   <<"This is inconsistent !");
      //BIASBREAK;
      return n;
    };
#  endif // BIAS_DEBUG
  n=theID_.Data1;
#else //WIN32
  // TODO: efficient
  std::string s;
  std::istringstream iss;
  GetString(s);
  // parse result and extract least significat value (12 hex Bytes)
  // to be compatible with SetFromLong
  // find last numerical part: 
  std::string::size_type pos = s.rfind('-');
  if (pos != string::npos){
    // found, extract last 12 hex Bytes
    iss.str(  s.substr(pos+1, 12) );
    iss>>hex>> n;
  }
#endif //WIN32
  return n;
}



// static
BIAS::UUID 
BIAS::UUID::GenerateUUID(const bool & consecutively) 
{
  BIAS::UUID id;
  id.AssignUUID(consecutively);
  return id;
}


// static
BIAS::UUID 
BIAS::UUID::GenerateUUID_Consecutive() 
{
  BIAS::UUID id;
  id.AssignUUID_Consecutive();
  return id;
}

// static
BIAS::UUID 
BIAS::UUID::GenerateUUID_Global() 
{
  BIAS::UUID id;    
  id.AssignUUID_Global();
  return id;
}


// jw
void 
BIAS::UUID::AssignUUID(const bool & consecutively)
{
  if (consecutively)
    return AssignUUID_Consecutive();
  else
    return AssignUUID_Global();
}



// TODO: thread safe increase of g_uniqueCounter? (JW)
// JW
void 
BIAS::UUID::AssignUUID_Consecutive()
{
  this->SetFromLong(g_uniqueCounter);
  g_uniqueCounter++;

    // set the valid flag for backward compatibillty
    this->IsValid_ = true;
}


// jw
void 
BIAS::UUID::AssignUUID_Global()
{
  //uuid_t id;
#ifdef WIN32
  //JW details:  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/rpc/rpc/uuid_1.asp 
  // creation uses ethernet/token ring addresses; UUID is guaranteed to be unique for the network
  HRESULT hr = UuidCreate( &theID_);
  switch (hr) 
    {
    case RPC_S_UUID_LOCAL_ONLY:
      BIASERR("UUID_LOCAL_ONLY guaranteed uniqueness for the generating machine, only!");
    case RPC_S_OK:
      break;
    default:
      BIASERR("Could not create UUID!");
    } // of switch 

#else // WIN32
  uuid_generate_time(theID_);
  timeval CurTime;
  uuid_time(theID_, &CurTime);
  if ((CurTime.tv_sec  < LastGenerationTime_.tv_sec) ||
      ((CurTime.tv_sec == LastGenerationTime_.tv_sec) &&
       (CurTime.tv_usec <= LastGenerationTime_.tv_usec)))  {
    //       BIASERR("There is a system clock problem !  The last time used for UUID"
    //               <<" generation lies in the future ! Maybe someone has turned"
    //               <<" back the clock (NTP ?). UUIDs may not be unique anymore."
    //               <<" CurTime="<<CurTime.tv_sec<<":"<<CurTime.tv_usec
    //               <<" LastTime="<<LastGenerationTime_.tv_sec<<":"
    //               <<LastGenerationTime_.tv_usec); 
    // sleeping a little and retry
    usleep(1);
    uuid_generate_time(theID_);
    timeval CurTime;
# ifdef __APPLE__
    uuid_generate_time(theID_);
# else 
    uuid_time(theID_, &CurTime);
# endif // APPLE
    if ((CurTime.tv_sec  < LastGenerationTime_.tv_sec) ||
        ((CurTime.tv_sec == LastGenerationTime_.tv_sec) &&
        (CurTime.tv_usec <= LastGenerationTime_.tv_usec)))  {
//       BIASERR("There is a system clock problem !  The last time used for UUID"
//               <<" generation lies in the future ! Maybe someone has turned"
//               <<" back the clock (NTP ?). UUIDs may not be unique anymore."
//               <<" CurTime="<<CurTime.tv_sec<<":"<<CurTime.tv_usec
//               <<" LastTime="<<LastGenerationTime_.tv_sec<<":"
//               <<LastGenerationTime_.tv_usec); 
      // sleeping a little and retry
      usleep(1);
      uuid_generate_time(theID_);
# ifndef __APPLE__
      timeval CurTime;
      uuid_time(theID_, &CurTime);
# endif //__APPLE__
      if ((CurTime.tv_sec  < LastGenerationTime_.tv_sec) ||
          ((CurTime.tv_sec == LastGenerationTime_.tv_sec) &&
           (CurTime.tv_usec <= LastGenerationTime_.tv_usec)))  {
//         BIASERR("There is a system clock problem !  The last time used for UUID"
//                 <<" generation lies in the future ! Maybe someone has turned"
//                 <<" back the clock (NTP ?). UUIDs may not be unique anymore."
//                 <<" CurTime="<<CurTime.tv_sec<<":"<<CurTime.tv_usec
//                 <<" LastTime="<<LastGenerationTime_.tv_sec<<":"
//                 <<LastGenerationTime_.tv_usec); 
      }
    }
  }
  LastGenerationTime_.tv_sec  = CurTime.tv_sec;
  LastGenerationTime_.tv_usec = CurTime.tv_usec;
#endif // WIN32

    // set the valid flag for backward compatibillty
    this->IsValid_ = true;
}



void BIAS::UUID::GetString(std::string& sUUID) const {
#ifdef WIN32
  unsigned char * cUUIDwin;
  UuidToString (const_cast<uuid_t*>(&theID_), &cUUIDwin);
  sUUID = (char *)cUUIDwin;
#else
  char cUUID[37];
  uuid_unparse(theID_, cUUID);
  sUUID = cUUID;
#endif
}

// jw
std::string BIAS::UUID::GetString() const {
  std::string str;
  GetString(str);
  return str;
}


time_t BIAS::UUID::GetUUIDCreationTime() const {
#ifdef WIN32
  BIASERR("Not yet implemented!");
  return time_t();
#else
    
    time_t thetime;
# ifdef __APPLE__
    BIAS::UUID *t = const_cast<BIAS::UUID *>(this);
    uuid_generate_time(t->theID_);
# else
    timeval CreationTime;
        thetime = uuid_time(theID_, &CreationTime);
# endif
    return thetime;
#endif
}

timeval BIAS::UUID::GetUUIDCreationTimeStruct() const {
#ifdef WIN32
  BIASERR("Not yet implemented!");
  return timeval();
#else
    
  timeval CreationTime;
  uuid_time(theID_, &CreationTime);

  return CreationTime;
#endif
}

std::ostream& BIAS::operator<<(std::ostream & os, const UUID& id) 
{
  std::string suid;
  id.GetString(suid); 
  os << suid;
  return os; 
}


std::istream& BIAS::operator>>(std::istream & is, UUID& id) 
{
  std::string suid;
  is >> suid;
            
  id.IsValid_ = true;
  // call libuuid function to get id out of string:
#ifdef WIN32
  GUID tmpGUID = ((GUID)id.theID_);
  if (UuidFromString((unsigned char*)suid.c_str(), &tmpGUID)!=RPC_S_OK) 
#else
    if (uuid_parse(suid.c_str(), id.theID_)!=0) 
#endif
      {
        BIASERR("UUID could not be read from \""<<suid<<"\"");
        id.IsValid_ = false;
        is.setstate(std::ios_base::failbit | std::ios_base::badbit);
        //        BIASABORT;
      }

  return is;
}


bool BIAS::UUID::IsConsecutive() const
{
  static const BIAS::UUID max_consecutive = 
#if defined(__x86_64__) ||   defined(__sparc64__) ||            \
  defined(__arch64__) ||   defined(__powerpc64__) ||   defined (__s390x__) 
    BIAS::UUID(0xffffffffffff);
#else
    BIAS::UUID(0xffffffff);
#endif
  static const string mc= max_consecutive.GetString();
  return (this->GetString()<=mc);
}
  

const unsigned char *BIAS::UUID::GetUUIDRaw() const 
{
#ifdef WIN32 
  return NULL;
#else
  return (unsigned char *)theID_;
#endif
}


void BIAS::UUID::SetUUIDRaw(const unsigned char *rawid) 
{
#ifdef WIN32
  BIASASSERT(rawid!=NULL);
#else
  memcpy((unsigned char *)theID_, rawid, 16); 
  if (IsConsecutive()) {
    IsValid_ = true; 
  } else {
    IsValid_ = !IsNil();
  }
#endif
}