MeVisLab/Standard/Sources/ML/MLTools/include/mlMultiFields.h

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------
#ifndef __mlMultiFields_H
#define __mlMultiFields_H

#ifndef __MLToolsSystem_H
#include "MLToolsSystem.h"
#endif

#ifndef __mlField_H
#include <mlField.h>
#endif

ML_START_NAMESPACE

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

  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <class DATATYPE> inline std::ostream& operator<<(std::ostream& s, const std::vector<DATATYPE>& vec)
  {
    ML_TRACE_IN("MultiField::operator<<");

    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)
  {
    ML_TRACE_IN("MultiField::operator>>");

    vec.clear();
    DATATYPE i=0;
    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)
    {
      ML_TRACE_IN("MultiField::MultiField()");
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void setStringValue(const std::string &value)
    {
      ML_TRACE_IN("MultiField::setStringValue()");

      ML_TRY
      {
        std::istringstream ist(value);
        ist >> _fields;
        Field::touch();
      }
      ML_CATCH_RETHROW
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void setMultiField(const std::vector<DATATYPE> &value)
    {
      ML_TRACE_IN("MultiField::setMultiField()");

      ML_TRY
      {
        _fields = value;
        Field::touch();
      }
      ML_CATCH_RETHROW
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void setMultiField(const DATATYPE values[], size_t numValues)
    {
      ML_TRACE_IN("MultiField::setMultiField()");

      ML_TRY
      {
        if (NULL == values){
          ML_PRINT_FATAL_ERROR("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();
        }
      }
      ML_CATCH_RETHROW
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline void getMultiField(DATATYPE values[], size_t numValues)
    {
      ML_TRACE_IN("MultiField::getMultiField()");

      ML_TRY
      {
        if (NULL == values){
          ML_PRINT_FATAL_ERROR("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]; }
        }
      }
      ML_CATCH_RETHROW
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline std::string getStringValue() const
    {
      ML_TRACE_IN("MultiField::getStringValue()");

      ML_TRY
      {
        std::ostringstream ost;
        ost << _fields;
        return ost.str();
      }
      ML_CATCH_RETHROW
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline const std::vector<DATATYPE>& getMultiField() const
    {
      ML_TRACE_IN_TIME_CRITICAL("MultiField::getMultiField()");

      return _fields;
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline std::vector<DATATYPE>& getNonConstMultiField()
    {
      ML_TRACE_IN_TIME_CRITICAL("MultiField::getNonConstMultiField()");

      return _fields;
    }

    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    inline size_t getSize() const
    {
      ML_TRACE_IN_TIME_CRITICAL("MultiField::getSize()");

      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