Teuchos_StandardDependencies.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TEUCHOS_STANDARDDEPENDCIES_HPP_
#define TEUCHOS_STANDARDDEPENDCIES_HPP_
 
#include "Teuchos_Dependency.hpp"
#include "Teuchos_StandardParameterEntryValidators.hpp"
#include "Teuchos_StandardConditions.hpp"
#include "Teuchos_StandardFunctionObjects.hpp"
#include "Teuchos_ScalarTraits.hpp"
#include "Teuchos_OrdinalTraits.hpp"
 
 
namespace Teuchos{
 
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT VisualDependency : public Dependency{
 
public:
 
  static const bool& getShowIfDefaultValue(){
    static const bool SHOW_IF_DEFAULT_VALUE = true;
    return SHOW_IF_DEFAULT_VALUE;
  }
 
 
 
  VisualDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    bool showIf=getShowIfDefaultValue());
 
  VisualDependency(
    RCP<const ParameterEntry> dependee,
    ParameterEntryList dependents,
    bool showIf=getShowIfDefaultValue());
 
  VisualDependency(
    ConstParameterEntryList dependees,
    RCP<ParameterEntry> dependent,
    bool showIf=getShowIfDefaultValue());
 
  VisualDependency(
    ConstParameterEntryList dependees,
    ParameterEntryList dependents,
    bool showIf=getShowIfDefaultValue());
 
 
 
 
  virtual bool getDependeeState() const = 0;
 
  bool isDependentVisible() const;
 
  bool getShowIf() const;
 
 
 
  void evaluate();
 
 
private:
 
 
  bool dependentVisible_;
 
  bool showIf_;
 
 
};
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT ValidatorDependency : public Dependency{
 
public:
 
 
  ValidatorDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent);
 
  ValidatorDependency(
    RCP<const ParameterEntry> dependee,
    ParameterEntryList dependents);
 
 
 
  virtual void evaluate() = 0;
 
 
};
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT StringVisualDependency : public VisualDependency{
 
public:
 
 
  typedef Array<std::string> ValueList;
 
 
 
  StringVisualDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    std::string value,
    bool showIf=true);
 
  StringVisualDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    const ValueList& values,
    bool showIf=true);
 
  StringVisualDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    const std::string& value,
    bool showIf=true);
 
  StringVisualDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    const ValueList& values,
    bool showIf=true);
 
 
 
  const ValueList& getValues() const;
 
 
 
  bool getDependeeState() const;
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void validateDep() const;
 
 
private:
 
 
  const ValueList values_;
 
 
};
 
 
template<>
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<StringVisualDependency>{
 
public:
 
 
  static RCP<StringVisualDependency> getDummyObject();
 
 
};
 
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT BoolVisualDependency : public VisualDependency{
 
public:
 
 
  BoolVisualDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    bool showIf=true);
 
  BoolVisualDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    bool showIf=true);
 
 
 
  bool getDependeeState() const;
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void validateDep() const;
 
 
};
 
 
template<>
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<BoolVisualDependency>{
 
public:
 
 
  static RCP<BoolVisualDependency> getDummyObject();
 
 
};
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT ConditionVisualDependency : public VisualDependency{
 
public:
 
 
  ConditionVisualDependency(
    RCP<const Condition> condition,
    RCP<ParameterEntry> dependent,
    bool showIf=true);
 
  ConditionVisualDependency(
    RCP<const Condition> condition,
    Dependency::ParameterEntryList dependents,
    bool showIf=true);
 
 
 
  RCP<const Condition> getCondition() const;
 
 
  bool getDependeeState() const;
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void validateDep() const {}
 
 
 
private:
 
 
  RCP<const Condition> condition_;
 
 
};
 
 
template<>
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<ConditionVisualDependency>{
 
public:
 
 
  static RCP<ConditionVisualDependency> getDummyObject();
 
 
};
 
 
template <class T>
class NumberVisualDependency : public VisualDependency{
 
public:
 
 
  NumberVisualDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    bool showIf=true,
    RCP<SimpleFunctionObject<T> > func=null);
 
  NumberVisualDependency(
    RCP<const ParameterEntry> dependee,
    ParameterEntryList dependents,
    bool showIf=true,
    RCP<SimpleFunctionObject<T> > func=null);
 
 
 
  bool getDependeeState() const;
 
 
 
  std::string getTypeAttributeValue() const;
 
 
 
  RCP<const SimpleFunctionObject<T> > getFunctionObject() const;
 
 
protected:
 
 
  void validateDep() const;
 
 
private:
 
 
    RCP<SimpleFunctionObject<T> > func_;
 
  //
};
 
template<class T>
NumberVisualDependency<T>::NumberVisualDependency(
  RCP<const ParameterEntry> dependee,
  RCP<ParameterEntry> dependent,
  bool showIf,
  RCP<SimpleFunctionObject<T> > func)
  :VisualDependency(dependee, dependent, showIf),
  func_(func)
{
  validateDep();
}
 
template<class T>
NumberVisualDependency<T>::NumberVisualDependency(
  RCP<const ParameterEntry> dependee,
  ParameterEntryList dependents,
  bool showIf,
  RCP<SimpleFunctionObject<T> > func)
  :VisualDependency(dependee, dependents, showIf),
  func_(func)
{
  validateDep();
}
 
template<class T>
bool NumberVisualDependency<T>::getDependeeState() const{
  T value = getFirstDependeeValue<T>();
  if(!func_.is_null()){
    value = func_->runFunction(value);
  }
  return value > ScalarTraits<T>::zero() ? true : false;
}
 
template<class T>
std::string NumberVisualDependency<T>::getTypeAttributeValue() const{
  return "NumberVisualDependency(" + TypeNameTraits<T>::name() + ")";
}
 
template<class T>
RCP<const SimpleFunctionObject<T> >
  NumberVisualDependency<T>::getFunctionObject() const
{
  return func_.getConst();
}
 
template<class T>
void NumberVisualDependency<T>::validateDep() const{
  RCP<const ParameterEntry> dependee = getFirstDependee();
  TEUCHOS_TEST_FOR_EXCEPTION(
    !dependee->isType<T>(),
    InvalidDependencyException,
    "The dependee of a " <<
    "Number Visual Dependency must the same type as the dependency's " <<
    "template type!" << std::endl <<
    "Type Encountered: " << dependee->getAny().typeName() << std::endl <<
    "Template Type: " << TypeNameTraits<T>::name() << std::endl <<
    std::endl);
}
 
 
template<class T>
class DummyObjectGetter<NumberVisualDependency<T> >{
 
public:
 
 
  static RCP<NumberVisualDependency<T> > getDummyObject();
 
 
};
 
template<class T>
RCP<NumberVisualDependency<T> >
  DummyObjectGetter<NumberVisualDependency<T> >::getDummyObject()
{
  return rcp(new NumberVisualDependency<T>(
    rcp(new ParameterEntry(ScalarTraits<T>::zero())),
    DummyObjectGetter<ParameterEntry>::getDummyObject()));
}
 
template<class DependeeType, class DependentType>
class ArrayModifierDependency : public Dependency{
public:
 
 
  ArrayModifierDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
  ArrayModifierDependency(
    RCP<const ParameterEntry> dependee,
    ParameterEntryList dependents,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
 
 
  inline RCP<const SimpleFunctionObject<DependeeType> >
    getFunctionObject() const
  {
    return func_;
  }
 
 
 
  virtual void evaluate();
 
protected:
 
  virtual void validateDep() const;
 
 
 
  virtual void modifyArray(
    DependeeType newAmount,
    RCP<ParameterEntry> dependentToModify) = 0;
 
  virtual std::string getBadDependentValueErrorMessage() const=0;
 
private:
 
 
  RCP<const SimpleFunctionObject<DependeeType> > func_;
 
  //}
};
 
template<class DependeeType, class DependentType>
ArrayModifierDependency<DependeeType,DependentType>::ArrayModifierDependency(
  RCP<const ParameterEntry> dependee,
  RCP<ParameterEntry> dependent,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  Dependency(dependee, dependent),
  func_(func)
{}
 
template<class DependeeType, class DependentType>
ArrayModifierDependency<DependeeType,DependentType>::ArrayModifierDependency(
  RCP<const ParameterEntry> dependee,
  ParameterEntryList dependents,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  Dependency(dependee, dependents),
  func_(func)
{}
 
template<class DependeeType, class DependentType>
void ArrayModifierDependency<DependeeType,DependentType>::validateDep() const{
  TEUCHOS_TEST_FOR_EXCEPTION(
    typeid(DependeeType) != getFirstDependee()->getAny().type(),
    InvalidDependencyException,
    "Ay no! The dependee parameter types don't match." << std::endl <<
    "Dependee Template Type: " << TypeNameTraits<DependeeType>::name() <<
    std::endl <<
    "Dependee Parameter Type: " << getFirstDependee()->getAny().typeName()
    << std::endl << std::endl);
}
 
template<class DependeeType, class DependentType>
void ArrayModifierDependency<DependeeType,DependentType>::evaluate(){
  DependeeType newAmount = Dependency::getFirstDependeeValue<DependeeType>();
  if(!this->getFunctionObject().is_null()){
    newAmount = this->getFunctionObject()->runFunction(newAmount);
  }
 
  TEUCHOS_TEST_FOR_EXCEPTION(newAmount < OrdinalTraits<DependeeType>::zero(),
    Exceptions::InvalidParameterValue,
    getBadDependentValueErrorMessage());
 
  for(
    Dependency::ParameterEntryList::iterator it = this->getDependents().begin();
    it != this->getDependents().end();
    ++it)
  {
    modifyArray(newAmount, *it);
  }
}
 
 
template<class DependeeType, class DependentType>
class NumberArrayLengthDependency :
  public ArrayModifierDependency<DependeeType, DependentType>
{
 
public:
 
 
  NumberArrayLengthDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
  NumberArrayLengthDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  virtual void validateDep() const;
 
  void modifyArray(
    DependeeType newAmount, RCP<ParameterEntry> dependentToModify);
 
  std::string getBadDependentValueErrorMessage() const;
 
 
};
 
template<class DependeeType, class DependentType>
NumberArrayLengthDependency<DependeeType, DependentType>::NumberArrayLengthDependency(
  RCP<const ParameterEntry> dependee,
  RCP<ParameterEntry> dependent,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  ArrayModifierDependency<DependeeType, DependentType>(dependee, dependent, func)
{
  validateDep();
}
 
template<class DependeeType, class DependentType>
NumberArrayLengthDependency<DependeeType, DependentType>::NumberArrayLengthDependency(
  RCP<const ParameterEntry> dependee,
  Dependency::ParameterEntryList dependents,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  ArrayModifierDependency<DependeeType, DependentType>(dependee, dependents, func)
{
  validateDep();
}
 
 
template<class DependeeType, class DependentType>
std::string
NumberArrayLengthDependency<DependeeType, DependentType>::getTypeAttributeValue()
const
{
  return "NumberArrayLengthDependency(" +
    TypeNameTraits<DependeeType>::name() + ", " +
    TypeNameTraits<DependentType>::name() +")";
}
 
template <class DependeeType, class DependentType>
void
NumberArrayLengthDependency<DependeeType, DependentType>::modifyArray(
  DependeeType newAmount, RCP<ParameterEntry> dependentToModify)
{
  const Array<DependentType> originalArray =
    any_cast<Array<DependentType> >(dependentToModify->getAny());
  Array<DependentType> newArray(newAmount);
  DependeeType i;
  for(
    i=OrdinalTraits<DependeeType>::zero();
    i<originalArray.size() && i<newAmount;
    ++i)
  {
    newArray[i] = originalArray[i];
  }
 
  dependentToModify->setValue(newArray,
    false, dependentToModify->docString(), dependentToModify->validator());
}
 
template<class DependeeType, class DependentType>
std::string
NumberArrayLengthDependency<DependeeType, DependentType>::getBadDependentValueErrorMessage() const{
    std::ostringstream os;
    os <<
    "Ruh Roh Shaggy! Looks like a dependency tried to set the length "
    "of the Array(s) to a negative number. Silly. You can't have "
    "an Array with a negative length!" << std::endl << std::endl <<
    "Error:" << std::endl <<
    "An attempt was made to set the length of an Array to a negative "
    "number by a NumberArrayLengthDependency" << std::endl << std::endl;
    return os.str();
}
 
template<class DependeeType, class DependentType>
void
NumberArrayLengthDependency<DependeeType, DependentType>::validateDep()
  const
{
  ArrayModifierDependency<DependeeType, DependentType>::validateDep();
  for(
    Dependency::ConstParameterEntryList::const_iterator it =
      this->getDependents().begin();
    it != this->getDependents().end();
    ++it)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(
      typeid(Teuchos::Array<DependentType>) != (*it)->getAny().type(),
        InvalidDependencyException,
        "Ay no! The dependent parameter types don't match." << std::endl <<
        "Dependent Template Type: " <<
        TypeNameTraits<DependentType>::name() << std::endl <<
        "Dependent Parameter Type: " <<
        (*it)->getAny().typeName() << std::endl << std::endl);
  }
}
 
template<class DependeeType, class DependentType>
class DummyObjectGetter<NumberArrayLengthDependency<DependeeType, DependentType> >{
 
public:
 
 
  static RCP<NumberArrayLengthDependency<DependeeType, DependentType> >
    getDummyObject();
 
 
};
 
template<class DependeeType, class DependentType>
RCP<NumberArrayLengthDependency<DependeeType, DependentType> >
  DummyObjectGetter<NumberArrayLengthDependency<DependeeType, DependentType> >::getDummyObject()
{
  return rcp(
    new NumberArrayLengthDependency<DependeeType, DependentType>(
    rcp(new ParameterEntry(ScalarTraits<DependeeType>::zero())),
    rcp(new ParameterEntry(Array<DependentType>(1)))));
}
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT StringValidatorDependency : public ValidatorDependency{
 
public:
 
 
  typedef std::map<std::string, RCP<const ParameterEntryValidator> >
    ValueToValidatorMap;
 
  typedef std::pair<std::string, RCP<const ParameterEntryValidator> >
    ValueToValidatorPair;
 
 
 
  StringValidatorDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    ValueToValidatorMap valuesAndValidators,
    RCP<ParameterEntryValidator> defaultValidator=null);
 
  StringValidatorDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    ValueToValidatorMap valuesAndValidators,
    RCP<ParameterEntryValidator> defaultValidator = null);
 
 
 
  const ValueToValidatorMap& getValuesAndValidators() const;
 
  RCP<const ParameterEntryValidator> getDefaultValidator() const;
 
 
 
  void evaluate();
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void validateDep() const;
 
 
private:
 
 
  ValueToValidatorMap valuesAndValidators_;
 
  RCP<ParameterEntryValidator> defaultValidator_;
 
 
};
 
 
template<>
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<StringValidatorDependency>{
 
public:
 
 
  static RCP<StringValidatorDependency > getDummyObject();
 
 
};
 
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT BoolValidatorDependency : public ValidatorDependency{
 
public:
 
 
  BoolValidatorDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RCP<const ParameterEntryValidator> trueValidator,
    RCP<const ParameterEntryValidator> falseValidator=null);
 
  BoolValidatorDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    RCP<const ParameterEntryValidator> trueValidator,
    RCP<const ParameterEntryValidator> falseValidator=null);
 
 
 
  void evaluate();
 
 
 
  RCP<const ParameterEntryValidator> getTrueValidator() const;
 
  RCP<const ParameterEntryValidator> getFalseValidator() const;
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void validateDep() const;
 
 
private:
 
 
  RCP<const ParameterEntryValidator> trueValidator_, falseValidator_;
 
 
};
 
template<>
class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<BoolValidatorDependency>{
 
public:
 
 
  static RCP<BoolValidatorDependency > getDummyObject();
 
 
};
 
template<class T>
class RangeValidatorDependency : public ValidatorDependency{
 
public:
 
 
  typedef std::pair<T,T> Range;
 
  typedef std::map<Range, RCP<const ParameterEntryValidator> >
    RangeToValidatorMap;
 
  typedef std::pair<Range, RCP<const ParameterEntryValidator> >
    RangeValidatorPair;
 
 
 
  RangeValidatorDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RangeToValidatorMap rangesAndValidators,
    RCP<const ParameterEntryValidator> defaultValidator=null);
 
  RangeValidatorDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    RangeToValidatorMap rangesAndValidators,
    RCP<const ParameterEntryValidator> defaultValidator=null);
 
 
 
  const RangeToValidatorMap& getRangeToValidatorMap() const{
    return rangesAndValidators_;
  }
 
  RCP<const ParameterEntryValidator> getDefaultValidator() const{
    return defaultValidator_;
  }
 
 
 
  void evaluate();
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void validateDep() const;
 
 
 
private:
 
 
  RangeToValidatorMap rangesAndValidators_;
 
  void setDependentsToValidator(RCP<const ParameterEntryValidator> toSet);
 
  RCP<const ParameterEntryValidator> defaultValidator_;
 
 
};
 
template<class T>
RangeValidatorDependency<T>::RangeValidatorDependency(
  RCP<const ParameterEntry> dependee,
  RCP<ParameterEntry> dependent,
  RangeToValidatorMap rangesAndValidators,
  RCP<const ParameterEntryValidator> defaultValidator)
  :ValidatorDependency(dependee, dependent),
  rangesAndValidators_(rangesAndValidators),
  defaultValidator_(defaultValidator)
{
  validateDep();
}
 
template<class T>
RangeValidatorDependency<T>::RangeValidatorDependency(
  RCP<const ParameterEntry> dependee,
  Dependency::ParameterEntryList dependents,
  RangeToValidatorMap rangesAndValidators,
  RCP<const ParameterEntryValidator> defaultValidator)
  :ValidatorDependency(dependee, dependents),
  rangesAndValidators_(rangesAndValidators),
  defaultValidator_(defaultValidator)
{
  validateDep();
}
 
template<class T>
std::string RangeValidatorDependency<T>::getTypeAttributeValue() const
{
  return "RangeValidatorDependency(" + TypeNameTraits<T>::name() + ")";
}
 
 
template<class T>
void RangeValidatorDependency<T>::evaluate(){
  typename RangeToValidatorMap::const_iterator it;
  T dependeeValue = getFirstDependeeValue<T>();
  for(
    it = rangesAndValidators_.begin();
    it != rangesAndValidators_.end();
    ++it)
  {
    T min = it->first.first;
    T max = it->first.second;
    if(dependeeValue >= min && dependeeValue <max){
       setDependentsToValidator(it->second);
      return;
    }
  }
  setDependentsToValidator(defaultValidator_);
}
 
template<class T>
void RangeValidatorDependency<T>::validateDep() const{
  RCP<const ParameterEntry> dependee = getFirstDependee();
  TEUCHOS_TEST_FOR_EXCEPTION(dependee->getAny().type() != typeid(T),
    InvalidDependencyException,
    "The dependee of a RangeValidatorDependency must be the same type as " <<
    "The RangeValidatorDependency template type!" << std::endl <<
    "Dependee Type: " << dependee->getAny().typeName() << std::endl <<
    "Templated Type: " << TypeNameTraits<T>::name() << std::endl << std::endl);
 
  TEUCHOS_TEST_FOR_EXCEPTION(
    rangesAndValidators_.size() < 1,
    InvalidDependencyException,
    "The rangesAndValidators map RangeValidatorDependency "
    "must have at least one entry!" << std::endl << std::endl);
 
  typename RangeToValidatorMap::const_iterator it =
    rangesAndValidators_.begin();
  RCP<const ParameterEntryValidator> firstValidator = it->second;
  // getting the raw pointer avoids a Clang warning about side effects in typeid
  const ParameterEntryValidator* rawValidatorPtr = firstValidator.get();
  ++it;
  for(; it!=rangesAndValidators_.end(); ++it){
    TEUCHOS_TEST_FOR_EXCEPTION( typeid(*rawValidatorPtr) != typeid(*(it->second)),
      InvalidDependencyException,
      "Ay no! All of the validators in a RangeValidatorDependency "
      "must have the same type.");
    TEUCHOS_TEST_FOR_EXCEPTION(
      it->first.first > it->first.second,
      InvalidDependencyException,
      "The Range " << it->first.first << " to " << it->first.second <<
      " is invalid. The min can't be greater than the max, you silly goose!"
      );
  }
 
  TEUCHOS_TEST_FOR_EXCEPTION(
    nonnull(defaultValidator_)
    &&
    typeid(*rawValidatorPtr) != typeid(*defaultValidator_),
    InvalidDependencyException,
    "Ay no! The default validator of a RangeValidatorDependency "
    "must have the same type as the validators in rangesAndValidators map."
  );
 
}
 
template<class T>
void RangeValidatorDependency<T>::setDependentsToValidator(
  RCP<const ParameterEntryValidator> toSet)
{
  typename ParameterEntryList::const_iterator it;
  for(
    it = getDependents().begin();
    it != getDependents().end();
    ++it)
  {
    (*it)->setValidator(toSet);
  }
}
 
template<class T>
class DummyObjectGetter<RangeValidatorDependency<T> >{
 
public:
 
 
  static RCP<RangeValidatorDependency<T> > getDummyObject();
 
 
};
 
template<class T>
RCP<RangeValidatorDependency<T> >
  DummyObjectGetter<RangeValidatorDependency<T> >::getDummyObject()
{
  typename RangeValidatorDependency<T>::RangeToValidatorMap dummyMap;
  typename RangeValidatorDependency<T>::Range dummyRange(
    ScalarTraits<T>::zero(), ScalarTraits<T>::one());
  RCP<FileNameValidator> dummyValidator =
    DummyObjectGetter<FileNameValidator>::getDummyObject();
  dummyMap.insert(typename RangeValidatorDependency<T>::RangeValidatorPair(
    dummyRange, dummyValidator));
  return rcp(new RangeValidatorDependency<T>(
    rcp(new ParameterEntry(ScalarTraits<T>::zero())),
    DummyObjectGetter<ParameterEntry>::getDummyObject(),
    dummyMap));
}
 
template<class DependeeType, class DependentType>
class TwoDArrayModifierDependency :
  public ArrayModifierDependency<DependeeType, DependentType>
{
 
public:
 
 
  TwoDArrayModifierDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RCP<const SimpleFunctionObject<DependeeType> > func=null):
    ArrayModifierDependency<DependeeType, DependentType>(
      dependee,
      dependent,
      func)
  {}
 
 
  TwoDArrayModifierDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    RCP<const SimpleFunctionObject<DependeeType> > func=null):
    ArrayModifierDependency<DependeeType, DependentType>(
      dependee,
      dependents,
      func)
  {}
 
 
protected:
 
 
  virtual void validateDep() const;
 
 
};
 
template<class DependeeType, class DependentType>
void
TwoDArrayModifierDependency<DependeeType, DependentType>::validateDep()
  const
{
  ArrayModifierDependency<DependeeType, DependentType>::validateDep();
  for(
    Dependency::ConstParameterEntryList::const_iterator it =
      this->getDependents().begin();
    it != this->getDependents().end();
    ++it)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(
      typeid(Teuchos::TwoDArray<DependentType>) != (*it)->getAny().type(),
        InvalidDependencyException,
        "Ay no! The dependent parameter types don't match." << std::endl <<
        "Dependent Template Type: " <<
        TypeNameTraits<DependentType>::name() << std::endl <<
        "Dependent Parameter Type: " <<
        (*it)->getAny().typeName() << std::endl << std::endl);
  }
}
 
 
template<class DependeeType, class DependentType>
class TwoDRowDependency :
  public TwoDArrayModifierDependency<DependeeType, DependentType>
{
 
public:
 
 
  TwoDRowDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
 
  TwoDRowDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void modifyArray(
    DependeeType newAmount, RCP<ParameterEntry> dependentToModify);
 
  std::string getBadDependentValueErrorMessage() const;
 
};
 
template<class DependeeType, class DependentType>
TwoDRowDependency<DependeeType, DependentType>::TwoDRowDependency(
  RCP<const ParameterEntry> dependee,
  RCP<ParameterEntry> dependent,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  TwoDArrayModifierDependency<DependeeType, DependentType>(
    dependee, dependent, func)
{
  this->validateDep();
}
 
template<class DependeeType, class DependentType>
TwoDRowDependency<DependeeType, DependentType>::TwoDRowDependency(
  RCP<const ParameterEntry> dependee,
  Dependency::ParameterEntryList dependents,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  TwoDArrayModifierDependency<DependeeType, DependentType>(
    dependee, dependents, func)
{
  this->validateDep();
}
 
 
template<class DependeeType, class DependentType>
std::string
TwoDRowDependency<DependeeType, DependentType>::getTypeAttributeValue()
const
{
  return "TwoDRowDependency(" +
    TypeNameTraits<DependeeType>::name() + ", " +
    TypeNameTraits<DependentType>::name() +")";
}
 
template <class DependeeType, class DependentType>
void
TwoDRowDependency<DependeeType, DependentType>::modifyArray(
  DependeeType newAmount,
  RCP<ParameterEntry> dependentToModify)
{
  TwoDArray<DependentType> originalArray =
    any_cast<TwoDArray<DependentType> >(dependentToModify->getAny());
  originalArray.resizeRows(newAmount);
  dependentToModify->setValue(originalArray,
    false, dependentToModify->docString(), dependentToModify->validator());
}
 
template<class DependeeType, class DependentType>
std::string
TwoDRowDependency<DependeeType, DependentType>::getBadDependentValueErrorMessage() const{
  std::ostringstream os;
  os <<
    "Ruh Roh Shaggy! Looks like a dependency tried to set the number of "
    "rows in TwoDArray(s) to a negative number. Silly. You can't have "
    "a TwoDArray with a negative number of rows!" << std::endl << std::endl <<
    "Error:" << std::endl <<
    "An attempt was made to set the number of rows of a TwoDArray to a negative "
    "number by a TwoDRowDependency" << std::endl << std::endl;
  return os.str();
}
 
template<class DependeeType, class DependentType>
class DummyObjectGetter<TwoDRowDependency<DependeeType, DependentType> >{
 
public:
 
 
  static RCP<TwoDRowDependency<DependeeType, DependentType> >
    getDummyObject();
 
 
};
 
template<class DependeeType, class DependentType>
RCP<TwoDRowDependency<DependeeType, DependentType> >
  DummyObjectGetter<TwoDRowDependency<DependeeType, DependentType> >::getDummyObject()
{
  return rcp(
    new TwoDRowDependency<DependeeType, DependentType>(
    rcp(new ParameterEntry(ScalarTraits<DependeeType>::zero())),
    rcp(new ParameterEntry(TwoDArray<DependentType>(1,1)))));
}
 
 
template<class DependeeType, class DependentType>
class TwoDColDependency :
  public TwoDArrayModifierDependency<DependeeType, DependentType>
{
 
public:
 
 
  TwoDColDependency(
    RCP<const ParameterEntry> dependee,
    RCP<ParameterEntry> dependent,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
 
  TwoDColDependency(
    RCP<const ParameterEntry> dependee,
    Dependency::ParameterEntryList dependents,
    RCP<const SimpleFunctionObject<DependeeType> > func=null);
 
 
 
  std::string getTypeAttributeValue() const;
 
 
protected:
 
 
  void modifyArray(
    DependeeType newAmount, RCP<ParameterEntry> dependentToModify);
 
  std::string getBadDependentValueErrorMessage() const;
 
};
 
template<class DependeeType, class DependentType>
TwoDColDependency<DependeeType, DependentType>::TwoDColDependency(
  RCP<const ParameterEntry> dependee,
  RCP<ParameterEntry> dependent,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  TwoDArrayModifierDependency<DependeeType, DependentType>(
    dependee, dependent, func)
{
  this->validateDep();
}
 
template<class DependeeType, class DependentType>
TwoDColDependency<DependeeType, DependentType>::TwoDColDependency(
  RCP<const ParameterEntry> dependee,
  Dependency::ParameterEntryList dependents,
  RCP<const SimpleFunctionObject<DependeeType> > func):
  TwoDArrayModifierDependency<DependeeType, DependentType>(
    dependee, dependents, func)
{
  this->validateDep();
}
 
 
template<class DependeeType, class DependentType>
std::string
TwoDColDependency<DependeeType, DependentType>::getTypeAttributeValue()
const
{
  return "TwoDColDependency(" +
    TypeNameTraits<DependeeType>::name() + ", " +
    TypeNameTraits<DependentType>::name() +")";
}
 
template <class DependeeType, class DependentType>
void
TwoDColDependency<DependeeType, DependentType>::modifyArray(
  DependeeType newAmount,
  RCP<ParameterEntry> dependentToModify)
{
  TwoDArray<DependentType> originalArray =
    any_cast<TwoDArray<DependentType> >(dependentToModify->getAny());
  originalArray.resizeCols(newAmount);
  dependentToModify->setValue(originalArray,
    false, dependentToModify->docString(), dependentToModify->validator());
}
 
template<class DependeeType, class DependentType>
std::string
TwoDColDependency<DependeeType, DependentType>::getBadDependentValueErrorMessage() const{
  std::ostringstream os;
  os <<
    "Ruh Roh Shaggy! Looks like a dependency tried to set the number of "
    "cols in TwoDArray(s) to a negative number. Silly. You can't have "
    "a TwoDArray with a negative number of cols!" << std::endl << std::endl <<
    "Error:" << std::endl <<
    "An attempt was made to set the number of columns of a TwoDArrayArray to a negative "
    "number by a TwoDColDependency" << std::endl << std::endl;
  return os.str();
}
 
template<class DependeeType, class DependentType>
class DummyObjectGetter<TwoDColDependency<DependeeType, DependentType> >{
 
public:
 
 
  static RCP<TwoDColDependency<DependeeType, DependentType> >
    getDummyObject();
 
 
};
 
template<class DependeeType, class DependentType>
RCP<TwoDColDependency<DependeeType, DependentType> >
  DummyObjectGetter<TwoDColDependency<DependeeType, DependentType> >::getDummyObject()
{
  return rcp(
    new TwoDColDependency<DependeeType, DependentType>(
    rcp(new ParameterEntry(ScalarTraits<DependeeType>::zero())),
    rcp(new ParameterEntry(TwoDArray<DependentType>(1,1)))));
}
 
 
 
} //namespace Teuchos
#endif //TEUCHOS_STANDARDDEPENDCIES_HPP_