mlImageFormatTag.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_IMAGE_FORMAT_TAG_H
#define ML_IMAGE_FORMAT_TAG_H
 
 
// Resolve platform independencies.
#include "MLImageFormatBaseSystem.h"
 
#include "mlModuleIncludes.h"
 
// Implement everything in ML namespace.
ML_START_NAMESPACE
 
  //----------------------------------------------------------------------
  //----------------------------------------------------------------------
  class MLIMAGEFORMATBASE_EXPORT MLImageFormatTag {
    public:
 
      //------------------------------------------------------------------
      //------------------------------------------------------------------
      inline MLImageFormatTag() :
        _name (""),
        _value("")
      {}
 
      inline MLImageFormatTag(const MLImageFormatTag &tag) :
        _name (tag._name),
        _value(tag._value)
      {}
 
      inline MLImageFormatTag(const std::string &name,
                              const std::string &value) :
        _name (name),
        _value(value)
      {}
 
      inline MLImageFormatTag(const std::string &name, MLint value) :
        _name (name)
      {
        setValue(value);
      }
 
      inline MLImageFormatTag(const std::string &name, MLdouble value) :
        _name (name)
      {
        setValue(value);
      }
 
      inline MLImageFormatTag(const std::string &name, MLldouble value) :
        _name (name)
      {
        setValue(value);
      }
 
      inline MLImageFormatTag& operator=(const MLImageFormatTag &tag)
      {
        // Assign only if different.
        if (&tag != this){
          _name  = tag._name ;
          _value = tag._value;
        }
        return *this;
      }
 
 
      //------------------------------------------------------------------
      //------------------------------------------------------------------
      inline const std::string &getName()  const     { return _name;  }
 
      inline const std::string &getValue() const     { return _value; }
 
      inline void setName(const std::string &newName){ _name = newName; }
 
 
      //------------------------------------------------------------------
      //------------------------------------------------------------------
      inline void setValue(const std::string &newVal)
      {
        _value = newVal;
      }
 
      inline void setValue(MLint newVal)
      {
        char strBuf[128]="";
        snprintf(strBuf, 127, "%lld", newVal);
        _value = strBuf;
      }
 
      inline void setValue(MLdouble newVal)
      {
        char frmt[256]="";
        char bufferStr[512]="";
 
        // Create the format string with full number of digits.
        snprintf(frmt, 255,  "%%.%dg", DBL_DIG);
 
        // Print the long double value with full number of digits.
        snprintf(bufferStr, 511, frmt, newVal);
        _value = bufferStr;
      }
 
      inline void setValue(MLldouble newVal)
      {
        char frmt[256]="";
        char bufferStr[512]="";
 
        // Create the format string with full number of digits.
        snprintf(frmt, 255,  "%%.%dLg", LDBL_DIG);
 
        // Print the long double value with full number of digits.
        snprintf(bufferStr, 511, frmt, newVal);
        _value = bufferStr;
      }
 
      inline size_t getTagSize() const
      {
        return _name.size() + _value.size() + 2;
      }
 
      inline void writeNameAndValueIntoMemory(char *memPos) const
      {
        const size_t nameSize  = _name .size();
        const size_t valueSize = _value.size();
        memcpy(memPos           , _name .c_str(), nameSize ); memPos[nameSize            ] = '\0';
        memcpy(memPos+nameSize+1, _value.c_str(), valueSize); memPos[nameSize+1+valueSize] = '\0';
      }
 
      inline const char * setNameAndValueFromMemory(const char* mem, const char* lastValidMemByte)
      {
        // Get start and end of buffers to parse content safely.
        const char * bufSeek   = mem;
 
        // Search first terminating character.
        int         numTerms   = 0;
        const char *firstTerm  = nullptr;
        const char *secondTerm = nullptr;
        for (; (bufSeek <= lastValidMemByte) && (numTerms < 2); ++bufSeek){
          if (*bufSeek == 0){
            // Found character is a null-terminating character. Save it
            // as firstTerm if firstTerm is still NULL, otherwise save
            // it pointer to the second terminating character. Also
            // increase the number of found terminating characters.
            // We need 2.
            numTerms++;
            if (firstTerm && !secondTerm){ secondTerm = bufSeek; }
            if (!firstTerm              ){ firstTerm  = bufSeek; }
          }
        } // for
 
        // Do we have two terminators found? If yes, then assign both values
        // which is safe then.
        if ((2 == numTerms) && firstTerm && secondTerm){
          _name  = mem;
          _value = firstTerm+1;
        }
 
        // Return pointer to second termination null or NULL on failure.
        return secondTerm;
      }
 
 
 
      //------------------------------------------------------------------
      //------------------------------------------------------------------
      inline const std::string &getStringValue()     const
      {
        return _value;
      }
 
      inline MLint              getMLintValue()      const
      {
        // Print the long double value with full number of digits.
        MLint intVal=0;
        int numRead = sscanf(_value.c_str(), "%lld", &intVal);
        return (numRead == 1) ? intVal : 0;
      }
 
      inline MLdouble           getDoubleValue()     const
      {
        // Scan for a double value.
        MLdouble dblVal=0;
        int numRead = sscanf(_value.c_str(), "%lf", &dblVal);
        return (numRead == 1) ? dblVal : 0;
      }
 
      inline MLldouble          getLongDoubleValue() const
      {
        // Scan for a long double value.
        MLldouble ldblVal=0;
        int numRead = sscanf(_value.c_str(), "%Lf", &ldblVal);
        return (numRead == 1) ? ldblVal : 0;
      }
 
    protected:
      std::string _name;
 
      std::string _value;
  };
 
 
 
  //----------------------------------------------------------------------
  //----------------------------------------------------------------------
  inline bool operator==(const MLImageFormatTag &tag1, const MLImageFormatTag &tag2)
  {
    // Assign only if different.
    return (tag1.getName()  == tag2.getName() ) &&
           (tag1.getValue() == tag2.getValue());
  }
 
  //----------------------------------------------------------------------
  //----------------------------------------------------------------------
  inline bool operator!=(const MLImageFormatTag &tag1, const MLImageFormatTag &tag2)
  {
    // Assign only if different.
    return (tag1.getName()  != tag2.getName() ) ||
           (tag1.getValue() != tag2.getValue());
  }
 
 
ML_END_NAMESPACE
 
#endif // of __mlImageFormat_H