mlListField.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2018, 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
**
**************************************************************************************/
 
 
 
#pragma once
 
#include "mlField.h"
#include "mlValuePersistence.h"
 
#include <vector>
 
ML_START_NAMESPACE
 
template<class T>
class ListField : public Field
{
public:
  ListField() = default;
 
  ListField(const std::string& name) { setName(name); }
 
  size_t size() const { return _values.size(); }
 
  void clear() { _values.clear(); }
 
  void setValues(const std::vector<T>& values) {
    _values = values;
    touch();
  }
 
  void updateValues(const std::vector<T>& values) {
    if (values != _values) {
      setValues(values);
    }
  }
 
  std::vector<T> getValues() const { return _values; }
 
  void setValueAt(size_t index, T value) {
    if (index >= _values.size()) {
      _values.resize(index+1);
    }
    _values[index] = value;
    touch();
  }
 
  void updateValueAt(size_t index, T value) {
    if ((index >= _values.size()) || (_values[index] != value)) {
      setValueAt(index, value);
    }
  }
 
  T getValueAt(size_t index) const {
    return _values[index];
  }
 
  std::string getStringValue() const override
  {
    std::string result;
    if (_values.size() != 1) {
      result.append("[ ");
    }
    bool first = true;
    for (const T& value : _values) {
      if (!first) {
        result.append(", ");
      } else {
        first = false;
      }
      result.append(ValuePersistence::valueToString(value));
    }
    if (_values.size() != 1) {
      result.append(" ]");
    }
    return result;
  }
 
  void setStringValue(const std::string& value) override
  {
    size_t endPos = std::min(value.find("]"), value.length());
    _values.clear();
    if (endPos > 1 && value[0] == '[') {
      size_t pos = 1;
      if (!isWhitespace(value, pos, endPos)) {
        while (pos < endPos) {
          size_t commaPos = std::min(value.find(",", pos), endPos);
          T comp;
          ValuePersistence::stringToValue(value.substr(pos, commaPos-pos), comp);
          _values.push_back(comp);
          pos = commaPos+1;
        }
      }
    }
    else {
      T comp;
      ValuePersistence::stringToValue(value, comp);
      _values.push_back(comp);
    }
    touch();
  }
 
private:
  static bool isWhitespace(const std::string& s, size_t start, size_t end)
  {
    for (size_t i = start; i < end; i++) {
      if (!::isspace(static_cast<int>(s[i]))) {
        return false;
      }
    }
    return true;
  }
 
  std::vector<T> _values;
};
 
ML_END_NAMESPACE