mlParameterInfoUtils.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//------------------------------------------------------------------------------
 
#pragma once
 
#include "MLParameterInfoSystem.h"
#include <mlModuleInterfaces.h>
#include <mlRangeCasts.h>
#include <FMEThirdPartyWarningsDisable.h> 
#include <QVariant>
#include <FMEThirdPartyWarningsRestore.h>
 
 
ML_START_NAMESPACE
 
namespace parameter_info_utils {
 
  template < class ValueType >
  QVariantList ToQVariantList( const TImageVector< ValueType >& vec )   
  {
    QVariantList result;
    for (size_t i = 0; i < TImageVector< ValueType >::NumberOfDimensions; ++i )
    {
      result << vec[ i ];
    }
    return result;
  }
 
  template < class ValueType, size_t N, class DC >
  QVariantList FloatVectorToQVariantList( const FloatingPointVector< ValueType, N, DC >& vec )
  {
    QVariantList result;
    for (size_t i = 0; i < N; ++i )
    {
      result << vec[ i ];
    }
    return result;
  }
 
  /*
   * Note that QVariant::fromValue() does not work for all types, so need some specializations.
   * Just using result << v results in other problems, e.g. there not being an non-ambiguous
   * auto-conversion to QVariant for int64_t on gcc.
   */
  template <class ValueType >
  void AppendToQVariantList( QVariantList& result, const ValueType& v )
  {
    QVariant qvar = QVariant::fromValue( v );
    result << qvar;
  }
 
  inline void AppendToQVariantList( QVariantList& result, const char* v )
  {
    QString qstr = QString::fromUtf8( v );
    result << qstr;
  }
 
  inline void AppendToQVariantList( QVariantList& result, const std::string& v )
  {
    QString qstr = QString::fromStdString( v );
    result << qstr;
  }
 
  template < class Iterable >
  QVariantList IterableToQVariantList( const Iterable& iterable )   
  {
    QVariantList result;
    for ( const auto& v: iterable )
    {
      AppendToQVariantList( result, v );
    }
    return result;
  }
 
  inline QVariantList ToQVariantList( const SubImageBox& box )   
  {
    QVariantList result;
    result.insert( 0, ToQVariantList( box.v1) );
    result.insert( 1, ToQVariantList( box.v2) );
    return result;
  }
 
//--------------------------------------------------------------------------
  inline QVariantList ToQVariant( const ImageVector& vec )
  {
    return ToQVariantList( vec );
  }
 
  template < class ValueType, size_t N >
  QVariantList ToQVariant( const FloatingPointVector< ValueType, N >& vec )
  {
    return FloatVectorToQVariantList( vec );
  }
  
  template < class ValueType >
  QVariantList ToQVariant( const std::vector< ValueType >& vec )
  {
    return IterableToQVariantList( vec );
  }
 
  inline QVariantList ToQVariant( const SubImageBox& box )   
  {
    return ToQVariantList( box );
  }
 
  inline QVariant ToQVariant( const std::string& x ) { return { QString::fromStdString( x ) }; }
  inline QVariant ToQVariant( const char* x ) { return { x }; }
 
  inline QVariant ToQVariant( bool x ) { return { x }; }
  inline QVariant ToQVariant( MLuint8 x ) { return { x }; }
  inline QVariant ToQVariant( MLint8 x ) { return { x }; }
  inline QVariant ToQVariant( MLuint16 x ) { return { x }; }
  inline QVariant ToQVariant( MLint16 x ) { return { x }; }
  inline QVariant ToQVariant( MLuint32 x ) { return { x }; }
  inline QVariant ToQVariant( MLint32 x ) { return { x }; }
  inline QVariant ToQVariant( MLuint64 x ) { return { x }; }
  inline QVariant ToQVariant( MLint64 x ) { return { x }; }
  inline QVariant ToQVariant( MLfloat x ) { return { x }; }
  inline QVariant ToQVariant( MLdouble x ) { return { x }; }
 
}
 
ML_END_NAMESPACE