mlMultiFields.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_MULTI_FIELDS_H
#define ML_MULTI_FIELDS_H
 
 
 
#include "MLToolsSystem.h"
 
#include <mlPrintTemplateErrors.h>
 
#include <mlField.h>
#include <sstream>
 
ML_START_NAMESPACE
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <class DATATYPE> inline std::ostream& operator<<(std::ostream& s, const std::vector<DATATYPE>& vec)
  {
    s.precision(8);
    for (size_t i = 0; i < vec.size(); i++) {
      s << vec[i] << " ";
    }
    return s;
  }
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <class DATATYPE> inline std::istream& operator>>(std::istream& s, std::vector<DATATYPE>& vec)
  {
    vec.clear();
    DATATYPE i = {};
    while (s >> i) {
      vec.push_back(i);
    }
    return s;
  }
 
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  template <class DATATYPE> class MultiField : public Field {
 
  public:
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline MultiField(const std::string &name="") : Field(name)
    {
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void setStringValue(const std::string &value) override
    {
      std::istringstream ist(value);
      ist >> _fields;
      Field::touch();
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void setMultiField(const std::vector<DATATYPE> &value)
    {
      _fields = value;
      Field::touch();
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void setMultiField(const DATATYPE values[], size_t numValues)
    {
      if (nullptr == values){
        printTemplateFatalError("MultiField::setMultiField",
                             ML_BAD_POINTER_OR_0,
                             "Ignoring function call");
      }
      else{
        // Be sure that vector has enough entries.
        _fields.resize(numValues);
 
        // Copy values into field vector.
        for (size_t c=0; c < numValues; ++c){ _fields[c] = values[c]; }
 
        // Sent change signal to observers.
        Field::touch();
      }
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void getMultiField(DATATYPE values[], size_t numValues)
    {
      if (nullptr == values){
        printTemplateFatalError("MultiField::getMultiField",
                             ML_BAD_POINTER_OR_0,
                             "Ignoring function call");
      }
      else{
        // Read at most the number of values available in the fields.
        if (numValues > _fields.size()){ numValues = _fields.size(); }
 
        // Copy values to return array.
        for (size_t c=0; c < numValues; ++c){ values[c] = _fields[c]; }
      }
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline std::string getStringValue() const override
    {
      std::ostringstream ost;
      ost << _fields;
      return ost.str();
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline const std::vector<DATATYPE>& getMultiField() const
    {
      return _fields;
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline std::vector<DATATYPE>& getNonConstMultiField()
    {
      return _fields;
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline size_t getSize() const
    {
      return _fields.size();
    }
 
  private:
    std::vector<DATATYPE> _fields;
  };
 
  //-------------------------------------------------------------------------
  // Instantiations of different multi fields
  //-------------------------------------------------------------------------
 
#if !defined(_WIN32) && !defined(WIN32) && !defined(MACOS)
 
  // Needed to force instantiation of these types, because under linux
  // otherwise link problems may occur, because symbols of these specializations
  // otherwise are not created. See Stroustrup, 13, 2.7.
  template class MultiField<MLdouble>;
  template class MultiField<MLfloat>;
  template class MultiField<MLint>;
  template class MultiField<MLint32>;
  template class MultiField<MLuint32>;
 
#endif
 
 
#ifdef WIN32
#pragma warning( push )
 
#pragma warning(disable : 4275 )
#endif
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  // Instantiations of different multi fields
  //-------------------------------------------------------------------------
  class MLTOOLS_EXPORT DoubleMultiField : public MultiField<MLdouble>
  {
  public:
    DoubleMultiField(const std::string &name="");
 
    ML_CLASS_HEADER(DoubleMultiField);
  };
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  class MLTOOLS_EXPORT FloatMultiField : public MultiField<MLfloat>
  {
  public:
    FloatMultiField(const std::string &name="");
 
    ML_CLASS_HEADER(FloatMultiField);
  };
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  class MLTOOLS_EXPORT IntMultiField : public MultiField<MLint>
  {
  public:
    IntMultiField(const std::string &name="");
 
    ML_CLASS_HEADER(IntMultiField);
  };
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  class MLTOOLS_EXPORT Int32MultiField : public MultiField<MLint32>
  {
  public:
    Int32MultiField(const std::string &name="");
 
    ML_CLASS_HEADER(Int32MultiField);
  };
 
  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  class MLTOOLS_EXPORT UInt32MultiField : public MultiField<MLuint32>
  {
  public:
    UInt32MultiField(const std::string &name="");
 
    ML_CLASS_HEADER(UInt32MultiField);
  };
 
#ifdef WIN32
#pragma warning( pop )
#endif
 
ML_END_NAMESPACE
 
#endif //__mlMultiFields_H