mlStringConversion.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_STRING_CONVERSION_H
#define ML_STRING_CONVERSION_H

 
#include "mlLinearAlgebra.h"
#include "mlSubImageBox.h"
 
ML_START_NAMESPACE

class SubImageBoxd;
class Base;

class MLEXPORT StringConversion
{
public:
  [[nodiscard]]
  static char* newString    (const std::string &str);

  static void  deleteString (char* str);


  static std::string writeToStdString(unsigned char val);

  static std::string writeToStdString(char val);

  static std::string writeToStdString(unsigned short val);

  static std::string writeToStdString(short val);

  static std::string writeToStdString(MLuint32 val);

  static std::string writeToStdString(MLint32 val);

  static std::string writeToStdString(unsigned long val);

  static std::string writeToStdString(long val);

  static std::string writeToStdString(MLuint64 val);

  static std::string writeToStdString(MLint64 val);

  static std::string writeToStdString(MLfloat val);

  static std::string writeToStdString(MLdouble val);

  static std::string writeToStdString(MLldouble val);

  static std::string writeToStdString(const Vector2& val);

  static std::string writeToStdString(const Vector3& val);

  static std::string writeToStdString(const Vector4& val);

  static std::string writeToStdString(const Vector5& val);

  static std::string writeToStdString(const Vector6& val);

  static std::string writeToStdString(const Vector7& val);

  static std::string writeToStdString(const Vector8& val);

  static std::string writeToStdString(const Vector9& val);

  static std::string writeToStdString(const Vector10& val);

  static std::string writeToStdString(const Vector16& val);

  static std::string writeToStdString(const Vector32& val);

  static std::string writeToStdString(const Vector64& val);

  static std::string writeToStdString(const ImageVector& val);

  static std::string writeToStdString(SubImageBox const & box);

  static std::string writeToStdString(SubImageBoxd const & box);

  static std::string writeToStdString(Matrix2 const & mat);

  static std::string writeToStdString(Matrix3 const & mat);

  static std::string writeToStdString(Matrix4 const & mat);

  static std::string writeToStdString(Matrix5 const & mat);

  static std::string writeToStdString(Matrix6 const & mat);

  static std::string writeToStdString(const Base* const obj);

  static std::string writeToStdString(const Base& obj);

  template <typename T>
  static std::string writeToStdString(const std::vector<T>& vec, const std::string &separatorString)
  {
    std::string retVal;
    for (size_t k = 0; k < vec.size(); k++){
      if (k){ retVal += separatorString; }
      retVal += writeToStdString(vec[k]);
    }
    return retVal;
  }

  static std::string writeToStdString(const std::string& str);
 
 


  static bool readFromString(const std::string& arg, unsigned char& val);

  static bool readFromString(const std::string& arg, char& val);

  static bool readFromString(const std::string& arg, unsigned short& val);

  static bool readFromString(const std::string& arg, short& val);

  static bool readFromString(const std::string& arg, MLuint32& val);

  static bool readFromString(const std::string& arg, MLint32& val);

  static bool readFromString(const std::string& arg, MLuint64& val);

  static bool readFromString(const std::string& arg, MLint64& val);

  static bool readFromString(std::string const& arg, unsigned long& val);

  static bool readFromString(std::string const& arg, long& val);

  static bool readFromString(std::string const& arg, float& val);

  static bool readFromString(std::string const& arg, double& val);

  static bool readFromString(std::string const& arg, long double& val);

  static bool readFromString(const std::string& vecstr, Vector2& v);

  static bool readFromString(const std::string& vecstr, Vector3& v);

  static bool readFromString(const std::string& vecstr, Vector4& v);

  static bool readFromString(const std::string& vecstr, Vector5& v);

  static bool readFromString(const std::string& vecstr, Vector6& v);

  static bool readFromString(const std::string& vecstr, Vector7& v);

  static bool readFromString(const std::string& vecstr, Vector8& v);

  static bool readFromString(const std::string& vecstr, Vector9& v);

  static bool readFromString(const std::string& vecstr, Vector10& v);

  static bool readFromString(const std::string& vecstr, Vector16& v);

  static bool readFromString(const std::string& vecstr, Vector32& v);

  static bool readFromString(const std::string& vecstr, Vector64& v);

  static bool readFromString(const std::string& vecstr, ImageVector& v);

  static bool readFromString(const std::string& str, Matrix2& val);

  static bool readFromString(const std::string& str, Matrix3& val);

  static bool readFromString(const std::string& str, Matrix4& val);

  static bool readFromString(const std::string& str, Matrix5& val);

  static bool readFromString(const std::string& str, Matrix6& val);

  static bool readFromString (const std::string& arg, SubImageBox& val);

  static bool readFromString (const std::string& arg, SubImageBoxd& val);

  static bool readFromString(const std::string& source, Base& obj);

  template <typename T>
  static bool readFromString(const std::string& vecstr,
                             std::vector<T>&    vec,
                             const std::string& separatorString)
  {
    bool retVal = false;
 
    size_t startPos = 0, endPos = 0;
    size_t sepLen = separatorString.size();
    bool eos = false;
    // Initialize the object with the default value of the type to avoid uninitialized object warnings.
    T item = T();
 
    while (!eos) {
      endPos = vecstr.find(separatorString, startPos);
      if (endPos == std::string::npos) {
        endPos = vecstr.size();
        eos = true;
      }
 
      // Use type specific read function to parse the string.
      retVal = readFromString(vecstr.substr(startPos, endPos - startPos), item);
 
      // Append the read item to the end of the vector.
      vec.push_back(item);
 
      // Set position of the next item to read.
      startPos = endPos + sepLen;
    }
    return retVal;
  }

  static bool readFromString(const std::string& source, std::string& target);
 
 


  static MLint getFirstNonSpacePos(const std::string& str, MLint pos = 0);
 
 
private:
  static void instantiateTemplateFctDummy(void);
};
 
ML_END_NAMESPACE
 
 
#endif // __mlStringConversion_H