capacity_constraint.h

Go to the documentation of this file.

#ifndef CYCLUS_SRC_CAPACITY_CONSTRAINT_H_
#define CYCLUS_SRC_CAPACITY_CONSTRAINT_H_
 
#include <boost/shared_ptr.hpp>
 
#include "error.h"
#include "exchange_graph.h"
#include "exchange_translation_context.h"
 
namespace cyclus {
 
/// @class Converter
///
/// @brief a simple interface for converting resource objects to unit capacities
template <class T> struct Converter {
  typedef boost::shared_ptr<Converter<T>> Ptr;
 
  /// @brief convert a capacitated quantity for an offer in its exchange context
  /// @param offer the resource being offered
  /// @param a the associated arc for the potential offer
  /// @param ctx the exchange context in which the offer is being made
  ///
  /// @warning it is up to the user to inherit default parameters
  virtual double convert(
      boost::shared_ptr<T> offer,
      Arc const* a = NULL,
      ExchangeTranslationContext<T> const* ctx = NULL) const = 0;
 
  /// @brief operator== is available for subclassing, see
  /// cyclus::TrivialConverter for an example
  virtual bool operator==(Converter& other) const { return false; }
  bool operator!=(Converter& other) const { return !operator==(other); }
};
 
/// @class TrivialConverter
///
/// @brief The default converter returns the resource's quantity
template <class T> struct TrivialConverter : public Converter<T> {
  /// @returns the quantity of resource offer
  inline virtual double convert(
      boost::shared_ptr<T> offer,
      Arc const* a = NULL,
      ExchangeTranslationContext<T> const* ctx = NULL) const {
    return offer->quantity();
  }
 
  /// @returns true if a dynamic cast succeeds
  virtual bool operator==(Converter<T>& other) const {
    return dynamic_cast<TrivialConverter<T>*>(&other) != NULL;
  }
};
 
/// @class CapacityConstraint
///
/// @brief A CapacityConstraint provides an ability to determine an agent's
/// constraints on resource allocation given a capacity.
template <class T> class CapacityConstraint {
 public:
  /// @brief constructor for a constraint with a non-trivial converter
  CapacityConstraint(double capacity, typename Converter<T>::Ptr converter)
      : capacity_(capacity), converter_(converter), id_(next_id_++) {
    if (capacity_ <= 0)
      throw ValueError("Capacity is not positive, no trades will be executed");
  }
 
  /// @brief constructor for a constraint with a trivial converter (i.e., one
  /// that simply returns 1)
  explicit CapacityConstraint(double capacity)
      : capacity_(capacity), id_(next_id_++) {
    if (capacity_ <= 0)
      throw ValueError("Capacity is not positive, no trades will be executed");
    converter_ = typename Converter<T>::Ptr(new TrivialConverter<T>());
  }
 
  /// @brief constructor for a constraint with a non-trivial converter
  CapacityConstraint(const CapacityConstraint& other)
      : capacity_(other.capacity_),
        converter_(other.converter_),
        id_(next_id_++) {}
 
  /// @return the constraints capacity
  inline double capacity() const { return capacity_; }
 
  /// @return the converter
  inline typename Converter<T>::Ptr converter() const { return converter_; }
 
  inline double convert(boost::shared_ptr<T> offer,
                        Arc const* a = NULL,
                        ExchangeTranslationContext<T> const* ctx = NULL) const {
    return converter_->convert(offer, a, ctx);
  }
 
  /// @return a unique id for the constraint
  inline int id() const { return id_; }
 
 private:
  double capacity_;
  typename Converter<T>::Ptr converter_;
  int id_;
  static int next_id_;
};
 
template <class T> int CapacityConstraint<T>::next_id_ = 0;
 
/// @brief CapacityConstraint-CapacityConstraint equality operator
template <class T>
inline bool operator==(const CapacityConstraint<T>& lhs,
                       const CapacityConstraint<T>& rhs) {
  return ((lhs.capacity() == rhs.capacity()) &&
          (*lhs.converter() == *rhs.converter()));
}
 
/// @brief CapacityConstraint-CapacityConstraint comparison operator, allows
/// usage in ordered containers
template <class T>
inline bool operator<(const CapacityConstraint<T>& lhs,
                      const CapacityConstraint<T>& rhs) {
  return (lhs.id() < rhs.id());
}
 
}  // namespace cyclus
 
#endif  // CYCLUS_SRC_CAPACITY_CONSTRAINT_H_