GDCM_NAME_SPACE::Util Class Reference

Here are some utility functions, belonging to the gdcm::Util class, dealing with strings, file names... that can be called from anywhere by whomsoever they can help. More...

#include <gdcmUtil.h>

List of all members.

Public Member Functions
void	hifpswap (double *a, double *b)
void	hNoifpswap (double *a, double *b)
void	hfpswap (double *a, double *b)
Static Public Member Functions
static std::string	Format (const char *format,...)
	Provide a better 'c++' approach for sprintf For example c code is: char result[2048]; // hope 2048 is enough sprintf(result, "%04x|%04x", group , elem);.
static void	Tokenize (const std::string &str, std::vector< std::string > &tokens, const std::string &delimiters=" ")
	Because not available in C++ (?).
static int	CountSubstring (const std::string &str, const std::string &subStr)
	Because not available in C++ (?) Counts the number of occurences of a substring within a string.
static std::string	CreateCleanString (std::string const &s)
	Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing).
static std::string	CreateCleanString (uint8_t *s, int l)
	Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing).
static bool	IsCleanString (std::string const &s)
	Checks whether a 'string' is printable or not (in order to avoid corrupting the terminal of invocation when printing).
static bool	IsCleanArea (uint8_t *s, int l)
	Checks whether an 'area' is printable or not (in order to avoid corrupting the terminal of invocation when printing).
static std::string	NormalizePath (std::string const &name)
	Add a SEPARATOR to the end of the name if necessary.
static std::string	GetPath (std::string const &fullName)
	Get the (directory) path from a full path file name.
static std::string	GetName (std::string const &fullName)
	Get the (last) name of a full path file name.
static std::string	GetCurrentDate ()
	Get the current date of the system in a dicom string.
static std::string	GetCurrentTime ()
	Get the current time of the system in a dicom string.
static std::string	GetCurrentDateTime ()
	Get both the date and time at the same time to avoid problem around midnight where the two calls could be before and after midnight.
static std::string	GetVersion ()
	Provides a simple static GetVersion() function.
static unsigned int	GetCurrentThreadID ()
static unsigned int	GetCurrentProcessID ()
static bool	IsCurrentProcessorBigEndian ()
	tells us whether the processor we are working with is BigEndian or not
static std::string	DicomString (const char *s, size_t l)
	Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want.
static std::string	DicomString (const char *s)
	Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. This function is similar to DicomString(const char*), except it doesn't take a length. It only pad with a null character if length is odd.
static bool	DicomStringEqual (const std::string &s1, const char *s2)
	Safely check the equality of two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space.
static bool	CompareDicomString (const std::string &s1, const char *s2, int op)
	Safely compare two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space.
static std::string	GetMACAddress ()
	Encode the mac address on a fixed length string of 15 characters. we save space this way.
static std::string	CreateUniqueUID (const std::string &root="")
	Creates a new UID. As stipulated in the DICOM ref each time a DICOM image is created it should have a unique identifier (URI).
static void	SetRootUID (const std::string &root="")
static const std::string &	GetRootUID ()
static const uint8_t *	GetFileMetaInformationVersion ()
static void	SetFileMetaInformationVersion (uint16_t fmiv)
static void	sthifpswap (double *a, double *b)
static void	sthNoifpswap (double *a, double *b)
static std::string	ConvertToMD5 (std::string &stringToCrypt)
Private Types
typedef GDCM_NAME_SPACE::Util::md5_state_s	md5_state_t
Static Private Member Functions
static std::string	GetIPAddress ()
	Return the IP adress of the machine writting the DICOM image.
static void	md5_process (md5_state_t *pms, const uint8_t *data)
static void	md5_init (md5_state_t *pms)
static void	md5_append (md5_state_t *pms, const uint8_t *data, int nbytes)
static void	md5_finish (md5_state_t *pms, uint8_t digest[16])
Static Private Attributes
static std::string	RootUID = GDCM_UID
static const std::string	GDCM_UID = "1.2.826.0.1.3680043.2.1143"
static uint8_t *	FileMetaInformationVersion = (uint8_t *)&FMIV
static const uint16_t	FMIV = 0x0100
static std::string	GDCM_MAC_ADRESS = GetMACAddress()
Classes
struct	md5_state_s

---

Detailed Description

Here are some utility functions, belonging to the gdcm::Util class, dealing with strings, file names... that can be called from anywhere by whomsoever they can help.

Definition at line 36 of file gdcmUtil.h.

---

Member Typedef Documentation

typedef struct GDCM_NAME_SPACE::Util::md5_state_s GDCM_NAME_SPACE::Util::md5_state_t [private]

---

Member Function Documentation

bool GDCM_NAME_SPACE::Util::CompareDicomString (  const std::string &  s1, const char *  s2, int  op )  [static]

Safely compare two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space. Definition at line 521 of file gdcmUtil.cxx. References DicomString(). Referenced by GDCM_NAME_SPACE::SerieHelper::AddFile(). { // s2 is the string from the DICOM reference e.g. : 'MONOCHROME1' std::string s1_even = s1; //Never change input parameter std::string s2_even = DicomString( s2 ); if ( s1_even[s1_even.size()-1] == ' ' ) { s1_even[s1_even.size()-1] = '\0'; //replace space character by null } switch (op) { case GDCM_EQUAL : return s1_even == s2_even; case GDCM_DIFFERENT : return s1_even != s2_even; case GDCM_GREATER : return s1_even > s2_even; case GDCM_GREATEROREQUAL : return s1_even >= s2_even; case GDCM_LESS : return s1_even < s2_even; case GDCM_LESSOREQUAL : return s1_even <= s2_even; default : gdcmDebugMacro(" Wrong operator : " << op); return false; } }

std::string GDCM_NAME_SPACE::Util::ConvertToMD5 (  std::string &  stringToCrypt  )  [static]

Definition at line 1129 of file gdcmUtil.cxx. References md5_append(), md5_finish(), and md5_init(). { char *szChar = new char[ inPszToCrypt.size()+1 ]; char *szHexOutput = new char[ 16 * 2 + 1 ]; int nLen,nDi; strcpy( szChar, inPszToCrypt.c_str() ); // création du code md5 nLen = strlen( szChar ); md5_state_t state; uint8_t digest[ 16 ]; md5_init ( &state ); md5_append ( &state, (const uint8_t *)szChar, nLen); md5_finish ( &state, digest ); for ( nDi = 0; nDi < 16; nDi++) sprintf( szHexOutput + nDi * 2, "%02x", digest[ nDi ] ); szHexOutput[16 * 2]=0; delete [] szChar; std::string md5String=szHexOutput; delete [] szHexOutput; return md5String; }

int GDCM_NAME_SPACE::Util::CountSubstring (  const std::string &  str, const std::string &  subStr )  [static]

Because not available in C++ (?) Counts the number of occurences of a substring within a string. Parameters: str  string to check subStr  substring to count Definition at line 170 of file gdcmUtil.cxx. Referenced by GDCM_NAME_SPACE::CheckVM(). { int count = 0; // counts how many times it appears std::string::size_type x = 0; // The index position in the string do { x = str.find(subStr,x); // Find the substring if (x != std::string::npos) // If present { count++; // increase the count x += subStr.length(); // Skip this word } } while (x != std::string::npos);// Carry on until not present return count; }

std::string GDCM_NAME_SPACE::Util::CreateCleanString (  uint8_t *  s, int  l )  [static]

Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  area to process (uint8_t is just for prototyping. feel free to cast) l  area length to check Definition at line 261 of file gdcmUtil.cxx. { std::string str; for( int i=0; i<l; i++) { if (!isprint((unsigned char)s[i]) ) { str = str + '.'; } else { str = str + (char )s[i]; } } return str; }

std::string GDCM_NAME_SPACE::Util::CreateCleanString (  std::string const &  s  )  [static]

Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  string to check (uint8_t is just for prototyping. feel free to cast) Definition at line 229 of file gdcmUtil.cxx. Referenced by GDCM_NAME_SPACE::DataEntry::Print(). { std::string str = s; for(unsigned int i=0; i<str.size(); i++) { if (!isprint((unsigned char)str[i]) ) { str[i] = '.'; } } if (str.size() > 0 ) { if (!isprint((unsigned char)s[str.size()-1]) ) { if (s[str.size()-1] == 0 ) { str[str.size()-1] = ' '; } } } return str; }

std::string GDCM_NAME_SPACE::Util::CreateUniqueUID (  const std::string &  root = ""  )  [static]

Creates a new UID. As stipulated in the DICOM ref each time a DICOM image is created it should have a unique identifier (URI). Parameters: root  is the DICOM prefix assigned by IOS group Definition at line 933 of file gdcmUtil.cxx. References RootUID. Referenced by GDCM_NAME_SPACE::FileHelper::CheckMandatoryElements(), and GDCM_NAME_SPACE::DicomDirMeta::WriteContent(). { std::string prefix; std::string append; if ( root.empty() ) { // gdcm UID prefix, as supplied by http://www.medicalconnections.co.uk prefix = RootUID; } else { prefix = root; } // A root was specified use it to forge our new UID: append += "."; //append += Util::GetMACAddress(); // to save CPU time append += Util::GDCM_MAC_ADRESS; append += "."; append += Util::GetCurrentDateTime(); append += "."; //Also add a mini random number just in case: char tmp[10]; int r = (int) (100.0*rand()/RAND_MAX); // Don't use Util::Format to accelerate the execution sprintf(tmp,"%02d", r); append += tmp; // If append is too long we need to rehash it if ( (prefix + append).size() > 64 ) { gdcmStaticErrorMacro( "Size of UID is too long." ); // we need a hash function to truncate this number // if only md5 was cross plateform // MD5(append); } return prefix + append; }

std::string GDCM_NAME_SPACE::Util::DicomString (  const char *  s  )  [static]

Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. This function is similar to DicomString(const char*), except it doesn't take a length. It only pad with a null character if length is odd. Definition at line 485 of file gdcmUtil.cxx. References gdcmAssertMacro. { size_t l = strlen(s); if ( l%2 ) { l++; } std::string r(s, s+l); gdcmAssertMacro( !(r.size() % 2) ); return r; }

std::string GDCM_NAME_SPACE::Util::DicomString (  const char *  s, size_t  l )  [static]

Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. Definition at line 467 of file gdcmUtil.cxx. References gdcmAssertMacro. Referenced by CompareDicomString(), DicomStringEqual(), GDCM_NAME_SPACE::FileHelper::SetWriteFileTypeToExplicitVR(), GDCM_NAME_SPACE::FileHelper::SetWriteFileTypeToImplicitVR(), GDCM_NAME_SPACE::FileHelper::SetWriteFileTypeToJPEG(), GDCM_NAME_SPACE::FileHelper::SetWriteFileTypeToJPEG2000(), and GDCM_NAME_SPACE::File::Write(). { std::string r(s, s+l); gdcmAssertMacro( !(r.size() % 2) ); // == basically 'l' is even return r; }

bool GDCM_NAME_SPACE::Util::DicomStringEqual (  const std::string &  s1, const char *  s2 )  [static]

Safely check the equality of two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space. Definition at line 503 of file gdcmUtil.cxx. References DicomString(). Referenced by GDCM_NAME_SPACE::File::GetNumberOfScalarComponents(), GDCM_NAME_SPACE::File::GetXSpacing(), GDCM_NAME_SPACE::File::GetYSpacing(), GDCM_NAME_SPACE::File::IsMonochrome(), and GDCM_NAME_SPACE::File::IsMonochrome1(). { // s2 is the string from the DICOM reference e.g. : 'MONOCHROME1' std::string s1_even = s1; //Never change input parameter std::string s2_even = DicomString( s2 ); if ( s1_even[s1_even.size()-1] == ' ' ) { s1_even[s1_even.size()-1] = '\0'; //replace space character by null } return s1_even == s2_even; }

std::string GDCM_NAME_SPACE::Util::Format (  const char *  format,   ... )  [static]

Provide a better 'c++' approach for sprintf For example c code is: char result[2048]; // hope 2048 is enough sprintf(result, "%04x|%04x", group , elem);. c++ code is std::ostringstream buf; buf << std::right << std::setw(4) << std::setfill('0') << std::hex << group << "|" << std::right << std::setw(4) << std::setfill('0') << std::hex << elem; buf.str(); gdcm style code is string result; result = gdcm::Util::Format("%04x|%04x", group , elem); Definition at line 129 of file gdcmUtil.cxx. Referenced by GetIPAddress(), GDCM_NAME_SPACE::DocEntry::Print(), and GDCM_NAME_SPACE::File::Write(). { char buffer[2048]; // hope 2048 is enough va_list args; va_start(args, format); vsprintf(buffer, format, args); //might be a security flaw va_end(args); // Each invocation of va_start should be matched // by a corresponding invocation of va_end // args is then 'undefined' return buffer; }

std::string GDCM_NAME_SPACE::Util::GetCurrentDate (   )  [static]

Get the current date of the system in a dicom string. Definition at line 358 of file gdcmUtil.cxx. { char tmp[512]; time_t tloc; time (&tloc); strftime(tmp,512,"%Y%m%d", localtime(&tloc) ); return tmp; }

std::string GDCM_NAME_SPACE::Util::GetCurrentDateTime (   )  [static]

Get both the date and time at the same time to avoid problem around midnight where the two calls could be before and after midnight. Definition at line 383 of file gdcmUtil.cxx. { char tmp[40]; long milliseconds; time_t timep; // We need implementation specific functions to obtain millisecond precision #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) struct timeb tb; ::ftime(&tb); timep = tb.time; milliseconds = tb.millitm; #else struct timeval tv; gettimeofday (&tv, NULL); timep = tv.tv_sec; // Compute milliseconds from microseconds. milliseconds = tv.tv_usec / 1000; #endif // Obtain the time of day, and convert it to a tm struct. struct tm *ptm = localtime (&timep); // Format the date and time, down to a single second. strftime (tmp, sizeof (tmp), "%Y%m%d%H%M%S", ptm); // Add milliseconds // Don't use Util::Format to accelerate execution of code char tmpAll[80]; sprintf(tmpAll,"%s%03ld",tmp,milliseconds); return tmpAll; }

unsigned int GDCM_NAME_SPACE::Util::GetCurrentProcessID (   )  [static]

Definition at line 436 of file gdcmUtil.cxx. { #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) // NOTE: There is also a _getpid()... return (unsigned int)GetCurrentProcessId(); #else // get process identification, POSIX return (unsigned int)getpid(); #endif }

unsigned int GDCM_NAME_SPACE::Util::GetCurrentThreadID (   )  [static]

Definition at line 415 of file gdcmUtil.cxx. { // FIXME the implementation is far from complete #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) return (unsigned int)GetCurrentThreadId(); #else #ifdef __linux__ return 0; // Doesn't work on fedora, but is in the man page... //return (unsigned int)gettid(); #else #ifdef __sun return (unsigned int)thr_self(); #else //default implementation return 0; #endif // __sun #endif // __linux__ #endif // Win32 }

std::string GDCM_NAME_SPACE::Util::GetCurrentTime (   )  [static]

Get the current time of the system in a dicom string. Definition at line 370 of file gdcmUtil.cxx. { char tmp[512]; time_t tloc; time (&tloc); strftime(tmp,512,"%H%M%S", localtime(&tloc) ); return tmp; }

static const uint8_t* GDCM_NAME_SPACE::Util::GetFileMetaInformationVersion (   )  [inline, static]

Definition at line 74 of file gdcmUtil.h. Referenced by GDCM_NAME_SPACE::FileHelper::CheckMandatoryElements(). { return FileMetaInformationVersion;}

std::string GDCM_NAME_SPACE::Util::GetIPAddress (   )  [static, private]

Return the IP adress of the machine writting the DICOM image. Definition at line 1159 of file gdcmUtil.cxx. References Format(), and HOST_NAME_MAX. { // This is a rip from // http://www.codeguru.com/Cpp/I-N/internet/network/article.php/c3445/ #ifndef HOST_NAME_MAX // SUSv2 guarantees that `Host names are limited to 255 bytes'. // POSIX 1003.1-2001 guarantees that `Host names (not including the // terminating NUL) are limited to HOST_NAME_MAX bytes'. #define HOST_NAME_MAX 255 // In this case we should maybe check the string was not truncated. // But I don't known how to check that... #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) // with WinSock DLL we need to initialize the WinSock before using gethostname WORD wVersionRequested = MAKEWORD(1,0); WSADATA WSAData; int err = WSAStartup(wVersionRequested,&WSAData); if (err != 0) { // Tell the user that we could not find a usable // WinSock DLL. WSACleanup(); return "127.0.0.1"; } #endif #endif //HOST_NAME_MAX std::string str; char szHostName[HOST_NAME_MAX+1]; int r = gethostname(szHostName, HOST_NAME_MAX); if ( r == 0 ) { // Get host adresses struct hostent *pHost = gethostbyname(szHostName); for( int i = 0; pHost!= NULL && pHost->h_addr_list[i]!= NULL; i++ ) { for( int j = 0; j<pHost->h_length; j++ ) { if ( j > 0 ) str += "."; str += Util::Format("%u", (unsigned int)((unsigned char*)pHost->h_addr_list[i])[j]); } // str now contains one local IP address #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) WSACleanup(); #endif } } // If an error occur r == -1 // Most of the time it will return 127.0.0.1... return str; }

std::string GDCM_NAME_SPACE::Util::GetMACAddress (   )  [static]

Encode the mac address on a fixed length string of 15 characters. we save space this way. Definition at line 892 of file gdcmUtil.cxx. References gdcmStaticWarningMacro, GDCM_NAME_SPACE::getlastdigit(), and GDCM_NAME_SPACE::GetMacAddrSys(). { // This code is the result of a long internet search to find something // as compact as possible (not OS independant). We only have to separate // 3 OS: Win32, SunOS and 'real' POSIX // http://groups-beta.google.com/group/comp.unix.solaris/msg/ad36929d783d63be // http://bdn.borland.com/article/0,1410,26040,00.html unsigned char addr[6]; int stat = GetMacAddrSys(addr); if (stat == 0) { // We need to convert a 6 digit number from base 256 to base 10, using integer // would requires a 48bits one. To avoid this we have to reimplement the div + modulo // with string only bool zero = false; int res; std::string sres; while(!zero) { res = getlastdigit(addr); sres.insert(sres.begin(), '0' + res); zero = (addr[0] == 0) && (addr[1] == 0) && (addr[2] == 0) && (addr[3] == 0) && (addr[4] == 0) && (addr[5] == 0); } return sres; } else { gdcmStaticWarningMacro("Problem in finding the MAC Address"); return ""; } }

std::string GDCM_NAME_SPACE::Util::GetName (  std::string const &  fullName  )  [static]

Get the (last) name of a full path file name. Parameters: fullName  file/directory name to extract end name from Definition at line 334 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::GDCM_FILESEPARATOR. Referenced by GDCM_NAME_SPACE::DicomDir::SetElement(). { std::string filename = fullName; /* std::string::size_type slash_pos = filename.rfind("/"); std::string::size_type backslash_pos = filename.rfind("\\"); // At least with my gcc4.0.1, unfound char results in pos =4294967295 ... //slash_pos = slash_pos > backslash_pos ? slash_pos : backslash_pos; slash_pos = slash_pos < backslash_pos ? slash_pos : backslash_pos; */ std::string::size_type slash_pos = filename.rfind(GDCM_FILESEPARATOR); if (slash_pos != std::string::npos ) { return filename.substr(slash_pos + 1); } else { return filename; } }

std::string GDCM_NAME_SPACE::Util::GetPath (  std::string const &  fullName  )  [static]

Get the (directory) path from a full path file name. Parameters: fullName  file/directory name to extract Path from Definition at line 309 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::GDCM_FILESEPARATOR. { std::string res = fullName; /* int pos1 = res.rfind("/"); int pos2 = res.rfind("\\"); if ( pos1 > pos2 ) { res.resize(pos1); } else { res.resize(pos2); } */ int pos = res.rfind(GDCM_FILESEPARATOR); res.resize(pos); return res; }

const std::string & GDCM_NAME_SPACE::Util::GetRootUID (   )  [static]

Definition at line 981 of file gdcmUtil.cxx. References RootUID. { return RootUID; }

static std::string GDCM_NAME_SPACE::Util::GetVersion (   )  [inline, static]

Provides a simple static GetVersion() function. Definition at line 57 of file gdcmUtil.h. Referenced by GDCM_NAME_SPACE::FileHelper::CheckMandatoryElements(). { return GDCM_VERSION;}

void GDCM_NAME_SPACE::Util::hfpswap (  double *  a, double *  b )

Definition at line 1217 of file gdcmUtil.cxx. { double tmp; tmp=*a; *a=*b; *b=tmp; }

void GDCM_NAME_SPACE::Util::hifpswap (  double *  a, double *  b )  [inline]

Definition at line 85 of file gdcmUtil.h. { double tmp; tmp = *a; *a = *b; *b = tmp; }

void GDCM_NAME_SPACE::Util::hNoifpswap (  double *  a, double *  b )  [inline]

Definition at line 92 of file gdcmUtil.h. { double tmp; tmp = *a; *a = *b; *b = tmp; }

bool GDCM_NAME_SPACE::Util::IsCleanArea (  uint8_t *  s, int  l )  [static]

Checks whether an 'area' is printable or not (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  area to check (uint8_t is just for prototyping. feel free to cast) l  area length to check Definition at line 213 of file gdcmUtil.cxx. Referenced by GDCM_NAME_SPACE::DataEntry::Print(). { for( int i=0; i<l; i++) { if (!isprint((unsigned char)s[i]) ) { return false; } } return true; }

bool GDCM_NAME_SPACE::Util::IsCleanString (  std::string const &  s  )  [static]

Checks whether a 'string' is printable or not (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  string to check Definition at line 195 of file gdcmUtil.cxx. { for(unsigned int i=0; i<s.size(); i++) { if (!isprint((unsigned char)s[i]) ) { return false; } } return true; }

bool GDCM_NAME_SPACE::Util::IsCurrentProcessorBigEndian (   )  [static]

tells us whether the processor we are working with is BigEndian or not Definition at line 450 of file gdcmUtil.cxx. Referenced by GDCM_NAME_SPACE::Document::CheckSwap(), and GDCM_NAME_SPACE::RLEFramesInfo::ConvertRLE16BitsFromRLE8Bits(). { #if defined(GDCM_WORDS_BIGENDIAN) return true; #else return false; #endif }

void GDCM_NAME_SPACE::Util::md5_append (  md5_state_t *  pms, const uint8_t *  data, int  nbytes )  [static, private]

Definition at line 1553 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::Util::md5_state_s::buf, GDCM_NAME_SPACE::Util::md5_state_s::count, and md5_process(). Referenced by ConvertToMD5(), and md5_finish(). { const uint8_t *p = data; int left = nbytes; int offset = (pms->count[0] >> 3) & 63; uint16_t nbits = (uint16_t)(nbytes << 3); if (nbytes <= 0) return; /* Update the message length. */ pms->count[1] += nbytes >> 29; pms->count[0] += nbits; if (pms->count[0] < nbits) pms->count[1]++; /* Process an initial partial block. */ if (offset) { int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); memcpy(pms->buf + offset, p, copy); if (offset + copy < 64) return; p += copy; left -= copy; md5_process(pms, pms->buf); } /* Process full blocks. */ for (; left >= 64; p += 64, left -= 64) md5_process(pms, p); /* Process a final partial block. */ if (left) memcpy(pms->buf, p, left); }

void GDCM_NAME_SPACE::Util::md5_finish (  md5_state_t *  pms, uint8_t  digest[16] )  [static, private]

Definition at line 1584 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::Util::md5_state_s::abcd, GDCM_NAME_SPACE::Util::md5_state_s::count, and md5_append(). Referenced by ConvertToMD5(). { static const uint8_t pad[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; uint8_t data[8]; int i; /* Save the length before padding. */ for (i = 0; i < 8; ++i) data[i] = (uint8_t)(pms->count[i >> 2] >> ((i & 3) << 3)); /* Pad to 56 bytes mod 64. */ md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); /* Append the length. */ md5_append(pms, data, 8); for (i = 0; i < 16; ++i) digest[i] = (uint8_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); }

void GDCM_NAME_SPACE::Util::md5_init (  md5_state_t *  pms  )  [static, private]

Definition at line 1542 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::Util::md5_state_s::abcd, GDCM_NAME_SPACE::Util::md5_state_s::count, and T_MASK. Referenced by ConvertToMD5(). { pms->count[0] = pms->count[1] = 0; pms->abcd[0] = 0x67452301; pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; pms->abcd[3] = 0x10325476; }

void GDCM_NAME_SPACE::Util::md5_process (  md5_state_t *  pms, const uint8_t *  data )  [static, private]

Definition at line 1361 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::Util::md5_state_s::abcd, SET, T1, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T2, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T3, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T4, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T5, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T6, T60, T61, T62, T63, T64, T7, T8, and T9. Referenced by md5_append(). { uint16_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3]; uint16_t t; #if BYTE_ORDER > 0 /* Define storage only for big-endian CPUs. */ uint16_t X[16]; #else /* Define storage for little-endian or both types of CPUs. */ uint16_t xbuf[16]; const uint16_t *X; #endif { #if BYTE_ORDER == 0 /* * Determine dynamically whether this is a big-endian or * little-endian machine, since we can use a more efficient * algorithm on the latter. */ static const int w = 1; if (*((const uint8_t *)&w)) /* dynamic little-endian */ #endif #if BYTE_ORDER <= 0 /* little-endian */ { /* * On little-endian machines, we can process properly aligned * data without copying it. */ if (!((data - (const uint8_t *)0) & 3)) { /* data are properly aligned */ X = (const uint16_t *)data; } else { /* not aligned */ memcpy(xbuf, data, 64); X = xbuf; } } #endif #if BYTE_ORDER == 0 else /* dynamic big-endian */ #endif #if BYTE_ORDER >= 0 /* big-endian */ { /* * On big-endian machines, we must arrange the bytes in the * right order. */ const uint8_t *xp = data; int i; # if BYTE_ORDER == 0 X = xbuf; /* (dynamic only) */ # else # define xbuf /* (static only) */ # endif for (i = 0; i < 16; ++i, xp += 4) xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); } #endif } #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) /* Round 1. */ /* Let [abcd k s i] denote the operation a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ #define F(x, y, z) (((x) & (y)) | (~(x) & (z))) #define SET(a, b, c, d, k, s, Ti) \ t = a + F(b,c,d) + X[k] + Ti;\ a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 0, 7, T1); SET(d, a, b, c, 1, 12, T2); SET(c, d, a, b, 2, 17, T3); SET(b, c, d, a, 3, 22, T4); SET(a, b, c, d, 4, 7, T5); SET(d, a, b, c, 5, 12, T6); SET(c, d, a, b, 6, 17, T7); SET(b, c, d, a, 7, 22, T8); SET(a, b, c, d, 8, 7, T9); SET(d, a, b, c, 9, 12, T10); SET(c, d, a, b, 10, 17, T11); SET(b, c, d, a, 11, 22, T12); SET(a, b, c, d, 12, 7, T13); SET(d, a, b, c, 13, 12, T14); SET(c, d, a, b, 14, 17, T15); SET(b, c, d, a, 15, 22, T16); #undef SET /* Round 2. */ /* Let [abcd k s i] denote the operation a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ #define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) #define SET(a, b, c, d, k, s, Ti)\ t = a + G(b,c,d) + X[k] + Ti; \ a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 1, 5, T17); SET(d, a, b, c, 6, 9, T18); SET(c, d, a, b, 11, 14, T19); SET(b, c, d, a, 0, 20, T20); SET(a, b, c, d, 5, 5, T21); SET(d, a, b, c, 10, 9, T22); SET(c, d, a, b, 15, 14, T23); SET(b, c, d, a, 4, 20, T24); SET(a, b, c, d, 9, 5, T25); SET(d, a, b, c, 14, 9, T26); SET(c, d, a, b, 3, 14, T27); SET(b, c, d, a, 8, 20, T28); SET(a, b, c, d, 13, 5, T29); SET(d, a, b, c, 2, 9, T30); SET(c, d, a, b, 7, 14, T31); SET(b, c, d, a, 12, 20, T32); #undef SET /* Round 3. */ /* Let [abcd k s t] denote the operation a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ #define H(x, y, z) ((x) ^ (y) ^ (z)) #define SET(a, b, c, d, k, s, Ti)\ t = a + H(b,c,d) + X[k] + Ti; \ a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 5, 4, T33); SET(d, a, b, c, 8, 11, T34); SET(c, d, a, b, 11, 16, T35); SET(b, c, d, a, 14, 23, T36); SET(a, b, c, d, 1, 4, T37); SET(d, a, b, c, 4, 11, T38); SET(c, d, a, b, 7, 16, T39); SET(b, c, d, a, 10, 23, T40); SET(a, b, c, d, 13, 4, T41); SET(d, a, b, c, 0, 11, T42); SET(c, d, a, b, 3, 16, T43); SET(b, c, d, a, 6, 23, T44); SET(a, b, c, d, 9, 4, T45); SET(d, a, b, c, 12, 11, T46); SET(c, d, a, b, 15, 16, T47); SET(b, c, d, a, 2, 23, T48); #undef SET /* Round 4. */ /* Let [abcd k s t] denote the operation a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ #define I(x, y, z) ((y) ^ ((x) | ~(z))) #define SET(a, b, c, d, k, s, Ti)\ t = a + I(b,c,d) + X[k] + Ti; \ a = ROTATE_LEFT(t, s) + b /* Do the following 16 operations. */ SET(a, b, c, d, 0, 6, T49); SET(d, a, b, c, 7, 10, T50); SET(c, d, a, b, 14, 15, T51); SET(b, c, d, a, 5, 21, T52); SET(a, b, c, d, 12, 6, T53); SET(d, a, b, c, 3, 10, T54); SET(c, d, a, b, 10, 15, T55); SET(b, c, d, a, 1, 21, T56); SET(a, b, c, d, 8, 6, T57); SET(d, a, b, c, 15, 10, T58); SET(c, d, a, b, 6, 15, T59); SET(b, c, d, a, 13, 21, T60); SET(a, b, c, d, 4, 6, T61); SET(d, a, b, c, 11, 10, T62); SET(c, d, a, b, 2, 15, T63); SET(b, c, d, a, 9, 21, T64); #undef SET /* Then perform the following additions. (That is increment each of the four registers by the value it had before this block was started.) */ pms->abcd[0] += a; pms->abcd[1] += b; pms->abcd[2] += c; pms->abcd[3] += d; }

std::string GDCM_NAME_SPACE::Util::NormalizePath (  std::string const &  pathname  )  [static]

Add a SEPARATOR to the end of the name if necessary. Parameters: pathname  file/directory name to normalize Definition at line 283 of file gdcmUtil.cxx. References GDCM_NAME_SPACE::GDCM_FILESEPARATOR. Referenced by GDCM_NAME_SPACE::DirList::Explore(). { /* const char SEPARATOR_X = '/'; const char SEPARATOR_WIN = '\\'; #ifdef _WIN32 const std::string SEPARATOR = "\\"; #else const std::string SEPARATOR = "/"; #endif */ std::string name = pathname; int size = name.size(); // if ( name[size-1] != SEPARATOR_X && name[size-1] != SEPARATOR_WIN ) if ( name[size-1] != GDCM_FILESEPARATOR ) { name += GDCM_FILESEPARATOR; } return name; }

static void GDCM_NAME_SPACE::Util::SetFileMetaInformationVersion (  uint16_t  fmiv  )  [inline, static]

Definition at line 76 of file gdcmUtil.h. { FileMetaInformationVersion = (uint8_t *)&fmiv; }

void GDCM_NAME_SPACE::Util::SetRootUID (  const std::string &  root = ""  )  [static]

Definition at line 973 of file gdcmUtil.cxx. References GDCM_UID, and RootUID. { if ( root.empty() ) RootUID = GDCM_UID; else RootUID = root; }

static void GDCM_NAME_SPACE::Util::sthifpswap (  double *  a, double *  b )  [inline, static]

Definition at line 100 of file gdcmUtil.h. { double tmp; tmp = *a; *a = *b; *b = tmp; }

static void GDCM_NAME_SPACE::Util::sthNoifpswap (  double *  a, double *  b )  [inline, static]

Definition at line 107 of file gdcmUtil.h. { double tmp; tmp = *a; *a = *b; *b = tmp; }

void GDCM_NAME_SPACE::Util::Tokenize (  const std::string &  str, std::vector< std::string > &  tokens, const std::string &  delimiters = " " )  [static]

Because not available in C++ (?). Parameters: str  string to check tokens  std::vector to receive the tokenized substrings delimiters  string containing the character delimitors Definition at line 149 of file gdcmUtil.cxx. Referenced by GDCM_NAME_SPACE::DataEntry::GetDSValue(), GDCM_NAME_SPACE::File::GetLUTNbits(), and GDCM_NAME_SPACE::DataEntry::SetString(). { std::string::size_type lastPos = str.find_first_not_of(delimiters,0); std::string::size_type pos = str.find_first_of (delimiters,lastPos); while (std::string::npos != pos || std::string::npos != lastPos) { tokens.push_back(str.substr(lastPos, pos - lastPos)); lastPos = str.find_first_not_of(delimiters, pos); pos = str.find_first_of (delimiters, lastPos); } }

---

Member Data Documentation

uint8_t * GDCM_NAME_SPACE::Util::FileMetaInformationVersion = (uint8_t *)&FMIV [static, private]

Definition at line 124 of file gdcmUtil.h.

const uint16_t GDCM_NAME_SPACE::Util::FMIV = 0x0100 [static, private]

Definition at line 125 of file gdcmUtil.h.

std::string GDCM_NAME_SPACE::Util::GDCM_MAC_ADRESS = GetMACAddress() [static, private]

Definition at line 126 of file gdcmUtil.h.

const std::string GDCM_NAME_SPACE::Util::GDCM_UID = "1.2.826.0.1.3680043.2.1143" [static, private]

Definition at line 123 of file gdcmUtil.h. Referenced by SetRootUID().

std::string GDCM_NAME_SPACE::Util::RootUID = GDCM_UID [static, private]

Definition at line 122 of file gdcmUtil.h. Referenced by CreateUniqueUID(), GetRootUID(), and SetRootUID().

---

The documentation for this class was generated from the following files:

• gdcmUtil.h
• gdcmUtil.cxx

---