14 #ifndef smtk_attribute_ValueItemTemplate_h
15 #define smtk_attribute_ValueItemTemplate_h
17 #include "smtk/attribute/ComponentItem.h"
18 #include "smtk/attribute/Evaluator.h"
19 #include "smtk/attribute/ValueItem.h"
20 #include "smtk/attribute/ValueItemDefinitionTemplate.h"
32 template<
typename DataT>
37 typedef DataT DataType;
38 typedef typename std::vector<DataT> value_type;
39 typedef typename value_type::const_iterator const_iterator;
43 const_iterator begin()
const {
return m_values.begin(); }
44 const_iterator end()
const {
return m_values.end(); }
45 bool setNumberOfValues(std::size_t newSize)
override;
49 DataT value(std::size_t element = 0)
const;
54 using ValueItem::valueAsString;
55 std::string valueAsString(std::size_t element)
const override;
56 virtual bool setValue(
const DataT& val) {
return this->setValue(0, val); }
57 virtual bool setValue(std::size_t element,
const DataT& val);
59 using ValueItem::setValueFromString;
60 bool setValueFromString(std::size_t element,
const std::string& val)
override;
63 bool setValues(I vbegin, I vend)
66 std::size_t num = std::distance(vbegin, vend);
67 if (this->setNumberOfValues(num))
71 for (I it = vbegin; it != vend; ++it, ++i)
73 if (!this->setValue(i, *it))
82 virtual bool appendValue(
const DataT& val);
83 virtual bool removeValue(std::size_t element);
84 void reset()
override;
85 bool rotate(std::size_t fromPosition, std::size_t toPosition)
override;
86 bool setToDefault(std::size_t element = 0)
override;
87 bool isUsingDefault(std::size_t element)
const override;
88 bool isUsingDefault()
const override;
89 DataT defaultValue()
const;
90 const std::vector<DataT>& defaultValues()
const;
100 const CopyAssignmentOptions& options,
103 shared_ptr<const DefType> concreteDefinition()
const
105 return dynamic_pointer_cast<const DefType>(this->definition());
109 ValueItemTemplate(Attribute* owningAttribute,
int itemPosition);
110 ValueItemTemplate(Item* owningItem,
int myPosition,
int mySubGroupPosition);
111 void updateDiscreteValue(std::size_t element)
override;
112 bool initializeValues()
override;
114 std::vector<DataT> m_values;
115 const std::vector<DataT> m_dummy;
117 std::string streamValue(
const DataT& val)
const;
120 template<
typename DataT>
121 ValueItemTemplate<DataT>::ValueItemTemplate(Attribute* owningAttribute,
int itemPosition)
122 : ValueItem(owningAttribute, itemPosition)
123 , m_dummy(1, DataT())
127 template<
typename DataT>
128 ValueItemTemplate<DataT>::ValueItemTemplate(
131 int mySubGroupPosition)
132 : ValueItem(inOwningItem, itemPosition, mySubGroupPosition)
133 , m_dummy(1, DataT())
137 template<
typename DataT>
140 return this->value(element, smtk::io::Logger::instance());
146 template<
typename DataT>
149 if (!this->isSet(element))
153 "Item \"" << this->name() <<
"\" element " << element <<
" is not set (attribute \""
154 << this->attribute()->name() <<
"\").");
165 "Item \"" << this->name() <<
"\" has no reference expression (attribute \""
166 << this->attribute()->name() <<
"\").");
170 std::unique_ptr<smtk::attribute::Evaluator> evaluator = expAtt->createEvaluator();
175 "Item \"" << this->name() <<
"\" expression is not evaluate (attribute \""
176 << this->attribute()->name() <<
"\").");
180 smtk::attribute::Evaluator::ValueType result;
182 if (!evaluator->evaluate(
183 result, log, element, Evaluator::DependentEvaluationMode::EVALUATE_DEPENDENTS))
191 resultAsDataT = boost::get<DataT>(result);
193 catch (
const boost::bad_get&)
197 "Item \"" << this->name() <<
"\" evaluation result was not compatible (attribute \""
198 << this->attribute()->name() <<
"\").");
202 return resultAsDataT;
206 return m_values[element];
210 template<
typename DataT>
213 const DefType* def =
dynamic_cast<const DefType*
>(this->definition().get());
218 size_t n = def->numberOfRequiredValues();
221 if (def->hasDefault())
225 if (def->defaultValues().size() > 1)
227 m_values = def->defaultValues();
231 m_values.resize(n, def->defaultValue());
242 template<
typename DataT>
243 bool ValueItemTemplate<DataT>::setValueFromString(std::size_t element,
const std::string& sval)
248 this->unset(element);
252 std::istringstream iss(sval);
255 return !iss.fail() && this->setValue(element, val);
258 template<
typename DataT>
259 bool ValueItemTemplate<DataT>::setValue(std::size_t element,
const DataT& val)
262 if (m_values.size() <= element)
266 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
267 if (def->isDiscrete())
269 int index = def->findDiscreteIndex(val);
271 assert(m_discreteIndices.size() > element);
272 if (index == m_discreteIndices[element])
279 m_discreteIndices[element] = index;
280 m_values[element] = val;
281 if (def->allowsExpressions())
283 m_expression->unset();
285 assert(m_isSet.size() > element);
286 m_isSet[element] =
true;
292 this->updateActiveChildrenItems();
298 if (def->isValueValid(val))
300 m_values[element] = val;
301 assert(m_isSet.size() > element);
302 m_isSet[element] =
true;
303 if (def->allowsExpressions())
305 m_expression->unset();
312 template<
typename DataT>
313 void ValueItemTemplate<DataT>::updateDiscreteValue(std::size_t element)
315 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
316 m_values[element] = def->discreteValue(
static_cast<size_t>(m_discreteIndices[element]));
319 template<
typename DataT>
320 std::string ValueItemTemplate<DataT>::valueAsString(std::size_t element)
const
322 if (this->isExpression())
327 DataT val = value(element, log);
330 return "CANNOT_EVALUATE";
333 return streamValue(val);
337 assert(m_isSet.size() > element);
338 if (m_isSet[element])
340 assert(m_values.size() > element);
341 return streamValue(m_values[element]);
344 return "VALUE_IS_NOT_SET";
348 template<
typename DataT>
349 bool ValueItemTemplate<DataT>::appendValue(
const DataT& val)
352 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
353 if (!this->isExtensible())
358 std::size_t n = this->maxNumberOfValues();
359 if (n && (this->numberOfValues() >= n))
364 if (def->isDiscrete())
366 int index = def->findDiscreteIndex(val);
369 m_values.push_back(val);
370 m_discreteIndices.push_back(index);
371 m_isSet.push_back(
true);
376 if (def->isValueValid(val))
378 if (def->allowsExpressions())
380 m_expression->unset();
382 m_values.push_back(val);
383 m_isSet.push_back(
true);
389 template<
typename DataT>
390 bool ValueItemTemplate<DataT>::setNumberOfValues(std::size_t newSize)
393 if (this->numberOfValues() == newSize)
399 if (!this->isExtensible())
405 if (newSize < this->numberOfRequiredValues())
410 std::size_t n = this->maxNumberOfValues();
411 if (n && (newSize > n))
416 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
417 n = this->numberOfValues();
421 m_values.resize(newSize);
422 m_isSet.resize(newSize);
423 if (def->isDiscrete())
425 m_discreteIndices.resize(newSize);
429 if (def->hasDefault())
431 if (def->defaultValues().size() == newSize)
433 m_values = def->defaultValues();
437 m_values.resize(newSize, def->defaultValue());
439 m_isSet.resize(newSize,
true);
443 m_values.resize(newSize);
444 m_isSet.resize(newSize,
false);
446 if (def->isDiscrete())
448 m_discreteIndices.resize(newSize, def->defaultDiscreteIndex());
453 template<
typename DataT>
454 bool ValueItemTemplate<DataT>::removeValue(std::size_t i)
456 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
459 if (i < def->numberOfRequiredValues())
464 if (i >= this->numberOfValues())
468 m_values.erase(m_values.begin() + i);
469 m_isSet.erase(m_isSet.begin() + i);
470 if (def->isDiscrete())
472 m_discreteIndices.erase(m_discreteIndices.begin() + i);
477 template<
typename DataT>
478 bool ValueItemTemplate<DataT>::setToDefault(std::size_t element)
480 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
481 if (!def->hasDefault())
486 if (def->isDiscrete())
488 this->setDiscreteIndex(element, def->defaultDiscreteIndex());
492 assert(def->defaultValues().size() > element);
495 def->defaultValues().size() > 1 ? def->defaultValues()[element] : def->defaultValue());
500 template<
typename DataT>
501 bool ValueItemTemplate<DataT>::isUsingDefault()
const
503 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
504 if (!def->hasDefault())
509 std::size_t i, n = this->numberOfValues();
510 const DataT& dval = def->defaultValue();
511 const std::vector<DataT>& dvals = def->defaultValues();
512 bool vectorDefault = (dvals.size() == n);
513 for (i = 0; i < n; i++)
515 assert(m_isSet.size() > i);
516 assert(m_values.size() > i);
517 if (!(m_isSet[i] && (vectorDefault ? m_values[i] == dvals[i] : m_values[i] == dval)))
525 template<
typename DataT>
526 bool ValueItemTemplate<DataT>::isUsingDefault(std::size_t element)
const
528 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
529 assert(m_isSet.size() > element);
530 if (!(def->hasDefault() && m_isSet[element]))
535 const DataT& dval = def->defaultValue();
536 const std::vector<DataT>& dvals = def->defaultValues();
537 bool vectorDefault = (dvals.size() == def->numberOfRequiredValues());
538 assert(m_values.size() > element);
539 return (vectorDefault ? m_values[element] == dvals[element] : m_values[element] == dval);
542 template<
typename DataT>
543 DataT ValueItemTemplate<DataT>::defaultValue()
const
545 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
549 return def->defaultValue();
552 template<
typename DataT>
553 const std::vector<DataT>& ValueItemTemplate<DataT>::defaultValues()
const
555 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
559 return def->defaultValues();
562 template<
typename DataT>
563 void ValueItemTemplate<DataT>::reset()
565 const DefType* def =
static_cast<const DefType*
>(this->definition().get());
567 if (def->allowsExpressions())
569 m_expression->unset();
573 std::size_t i, n = this->numberOfRequiredValues();
574 if (this->numberOfValues() != n)
576 this->setNumberOfValues(n);
582 m_discreteIndices.clear();
587 if (!def->hasDefault())
589 for (i = 0; i < n; i++)
597 if (def->isDiscrete())
599 int index = def->defaultDiscreteIndex();
600 for (i = 0; i < n; i++)
602 this->setDiscreteIndex(i, index);
607 DataT dval = def->defaultValue();
608 const std::vector<DataT>& dvals = def->defaultValues();
609 bool vectorDefault = (dvals.size() == n);
610 for (i = 0; i < n; i++)
612 this->setValue(i, vectorDefault ? dvals[i] : dval);
618 template<
typename DataT>
622 if (!ValueItem::rotate(fromPosition, toPosition))
628 this->rotateVector(m_values, fromPosition, toPosition);
632 template<
typename DataT>
638 Item::Status result = ValueItem::assign(sourceItem, options, logger);
647 if (!sourceValueItemTemplate)
650 smtkErrorMacro(logger,
"Source Item: " << name() <<
" is not a ValueItemTemplate");
654 if (sourceValueItemTemplate->isExpression() || sourceValueItemTemplate->isDiscrete())
661 if (this->numberOfValues() != sourceValueItemTemplate->numberOfValues())
663 status = this->setNumberOfValues(sourceValueItemTemplate->numberOfValues());
671 std::size_t myNumVals, sourceNumVals, numVals;
672 myNumVals = this->numberOfValues();
673 sourceNumVals = sourceValueItemTemplate->numberOfValues();
674 if (myNumVals < sourceNumVals)
682 "ValueItem: " << this->name() <<
"'s number of values (" << myNumVals
683 <<
") is smaller than source Item's number of values (" << sourceNumVals
684 <<
") - will partially copy the values");
691 "ValueItem: " << name() <<
"'s number of values (" << myNumVals
692 <<
") can not hold source ValueItem's number of values (" << sourceNumVals
693 <<
") and Partial Copying was not permitted");
699 numVals = sourceNumVals;
702 for (std::size_t i = 0; i < numVals; ++i)
704 if (sourceValueItemTemplate->isSet(i))
706 if (this->valueAsString(i) == sourceValueItemTemplate->valueAsString(i))
710 status = this->setValueFromString(i, sourceValueItemTemplate->valueAsString(i));
717 "Could not assign Value:" << sourceValueItemTemplate->
value(i)
718 <<
" to ValueItem: " << sourceItem->name());
727 "Could not assign Value:" << sourceValueItemTemplate->
value(i)
728 <<
" to ValueItem: " << sourceItem->name()
729 <<
" and allowPartialValues options was not specified.");
742 template<
typename DataT>
745 std::stringstream buffer;
746 buffer.precision(std::numeric_limits<DataT>::max_digits10);