MeVis/Foundation/Sources/ML/include/mlStringConversion.h

Go to the documentation of this file.

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


#ifndef __mlStringConversion_H
#define __mlStringConversion_H

#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlLinearAlgebra_H
#include "mlLinearAlgebra.h"
#endif
#ifndef __mlBasics_H
#include "mlBasics.h"
#endif

ML_START_NAMESPACE

class SubImageBoxd;
class Base;

class MLEXPORT StringConversion 
{
  
public:  
  




  static char* newString    (const std::string &str) ML_RETURN_VALUE_SHOULD_BE_USED;
  
  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)
  {
    ML_TRACE_IN("StringConversion::writeToStdString(const std::vector<T>& vec, const std::string &separatorString");
    std::string retVal;
    ML_TRY
    {
      for (size_t k = 0; k < vec.size(); k++){
        if (k){ retVal += separatorString; }
        retVal += writeToStdString(vec[k]);
      }
      return retVal;
    }
    ML_CATCH_RETHROW;
  }
  
  
  

  
  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)
  {
    ML_TRACE_IN("StringConversion::readFromString(const std::string& vecstr, ..., std::string& separatorString)");
    ML_TRY
    {
      bool retVal = false;
      
      size_t startPos = 0, endPos = 0;      
      size_t sepLen = separatorString.size();
      bool eos = false;
      // Initialize the object with 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;
    }
    ML_CATCH_RETHROW;
  }
  
  
  

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

ML_END_NAMESPACE


#endif // __mlStringConversion_H