MeVis/Foundation/Sources/MLImageFormatBase/mlImageFormatTag.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __mlImageFormatTag_H
#define __mlImageFormatTag_H

// Resolve platform independencies.
#ifndef __MLImageFormatBaseSystem_H
#include "MLImageFormatBaseSystem.h"
#endif

#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif

// 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]="";
        MLsnprintf(strBuf, 127, "%I64Ld", newVal);
        _value = strBuf;
      }

      inline void setValue(MLdouble newVal)
      {
        char frmt[256]="";
        char bufferStr[512]="";

        // Create the format string with full number of digits.
        MLsnprintf(frmt, 255,  "%%.%dg", DBL_DIG);

        // Print the long double value with full number of digits.
        MLsnprintf(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.
        MLsnprintf(frmt, 255,  "%%.%dLg", LDBL_DIG);

        // Print the long double value with full number of digits.
        MLsnprintf(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  = NULL;
        const char *secondTerm = NULL;
        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 = MLsscanf(_value.c_str(), "%I64Ld", &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