Values.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
 
 * See LICENSE for the license information
 
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <gtsam/inference/Key.h>
#include <gtsam/base/FastDefaultAllocator.h>
#include <gtsam/base/GenericValue.h>
#include <gtsam/base/VectorSpace.h>
 
#ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/unique_ptr.hpp>
#endif
 
 
#include <memory>
#include <string>
#include <utility>
 
namespace gtsam {
 
  // Forward declarations / utilities
  class VectorValues;
  class ValueAutomaticCasting;
  template<typename T> static bool _truePredicate(const T&) { return true; }
 
  /* ************************************************************************* */
  class GTSAM_EXPORT ValueCloneAllocator {
  public:
    static Value* allocate_clone(const Value& a) { return a.clone_(); }
    static void deallocate_clone(const Value* a) { a->deallocate_(); }
    ValueCloneAllocator() {}
  };
 
  class GTSAM_EXPORT Values {
 
  private:
    // Internally we store a boost ptr_map, with a ValueCloneAllocator (defined
    // below) to clone and deallocate the Value objects, and our compile-flag-
    // dependent FastDefaultAllocator to allocate map nodes.  In this way, the
    // user defines the allocation details (i.e. optimize for memory pool/arenas
    // concurrency).
    typedef internal::FastDefaultAllocator<typename std::pair<const Key, void*>>::type KeyValuePtrPairAllocator;
    using KeyValueMap =
        std::map<Key, std::unique_ptr<Value>, std::less<Key>,
                 std::allocator<std::pair<const Key, std::unique_ptr<Value>>>>;
 
    // The member to store the values, see just above
    KeyValueMap values_;
 
  public:
 
    typedef std::shared_ptr<Values> shared_ptr;
 
    typedef std::shared_ptr<const Values> const_shared_ptr;
 
    struct GTSAM_EXPORT KeyValuePair {
      const Key key; 
      Value& value;  
 
      KeyValuePair(Key _key, Value& _value) : key(_key), value(_value) {}
    };
 
    struct GTSAM_EXPORT ConstKeyValuePair {
      const Key key; 
      const Value& value;  
 
      ConstKeyValuePair(Key _key, const Value& _value) : key(_key), value(_value) {}
      ConstKeyValuePair(const KeyValuePair& kv) : key(kv.key), value(kv.value) {}
    };
 
    typedef KeyValuePair value_type;
 
 
    Values() = default;
 
    Values(const Values& other);
 
    Values(Values&& other);
    
    Values(std::initializer_list<ConstKeyValuePair> init);
 
    Values(const Values& other, const VectorValues& delta);
 
 
    void print(const std::string& str = "", const KeyFormatter& keyFormatter = DefaultKeyFormatter) const;
 
    bool equals(const Values& other, double tol=1e-9) const;
 
 
    template <typename ValueType>
    const ValueType at(Key j) const;
 
    double atDouble(size_t key) const { return at<double>(key);}
 
    const Value& at(Key j) const;
 
    bool exists(Key j) const;
 
    template<typename ValueType>
    const ValueType * exists(Key j) const;
 
    size_t size() const { return values_.size(); }
 
    bool empty() const { return values_.empty(); }
 
 
    struct deref_iterator {
      using const_iterator_type = typename KeyValueMap::const_iterator;
      const_iterator_type it_;
      deref_iterator(const_iterator_type it) : it_(it) {}
      ConstKeyValuePair operator*() const { return {it_->first, *(it_->second)}; }
      std::unique_ptr<ConstKeyValuePair> operator->() const {
        return std::make_unique<ConstKeyValuePair>(it_->first, *(it_->second));
      }
      bool operator==(const deref_iterator& other) const {
        return it_ == other.it_;
      }
      bool operator!=(const deref_iterator& other) const { return it_ != other.it_; }
      deref_iterator& operator++() {
        ++it_;
        return *this;
      }
    };
 
    deref_iterator begin() const { return deref_iterator(values_.begin()); }
    deref_iterator end() const { return deref_iterator(values_.end()); }
 
    deref_iterator find(Key j) const { return deref_iterator(values_.find(j)); }
 
    deref_iterator lower_bound(Key j) const { return deref_iterator(values_.lower_bound(j)); }
    
    deref_iterator upper_bound(Key j) const { return deref_iterator(values_.upper_bound(j)); }
 
 
    Values retract(const VectorValues& delta) const;
 
    void retractMasked(const VectorValues& delta, const KeySet& mask);
 
    VectorValues localCoordinates(const Values& cp) const;
 
 
    void insert(Key j, const Value& val);
 
    void insert(const Values& values);
 
    template <typename ValueType>
    void insert(Key j, const ValueType& val);
 
    template <typename UnaryOp, typename ValueType>
    void insert(Key j, const Eigen::CwiseUnaryOp<UnaryOp, const ValueType>& val);
 
    template <typename BinaryOp, typename ValueType1, typename ValueType2>
    void insert(Key j, const Eigen::CwiseBinaryOp<BinaryOp, const ValueType1, const ValueType2>& val);
 
    void insertDouble(Key j, double c) { insert<double>(j,c); }
 
    void update(Key j, const Value& val);
 
    template <typename T>
    void update(Key j, const T& val);
 
    template <typename UnaryOp, typename ValueType>
    void update(Key j, const Eigen::CwiseUnaryOp<UnaryOp, const ValueType>& val);
 
    template <typename BinaryOp, typename ValueType1, typename ValueType2>
    void update(Key j, const Eigen::CwiseBinaryOp<BinaryOp, const ValueType1, const ValueType2>& val);
 
    void update(const Values& values);
 
    void insert_or_assign(Key j, const Value& val);
 
    void insert_or_assign(const Values& values);
 
    template <typename ValueType>
    void insert_or_assign(Key j, const ValueType& val);
 
    template <typename UnaryOp, typename ValueType>
    void insert_or_assign(Key j, const Eigen::CwiseUnaryOp<UnaryOp, const ValueType>& val);
 
    template <typename BinaryOp, typename ValueType1, typename ValueType2>
    void insert_or_assign(Key j, const Eigen::CwiseBinaryOp<BinaryOp, const ValueType1, const ValueType2>& val);
 
    void erase(Key j);
 
    KeyVector keys() const;
 
    KeySet keySet() const;
 
    Values& operator=(const Values& rhs);
 
    void swap(Values& other) { values_.swap(other.values_); }
 
    void clear() { values_.clear(); }
 
    size_t dim() const;
 
    std::map<Key,size_t> dims() const;
 
    VectorValues zeroVectors() const;
 
    // Count values of given type \c ValueType
    template <class ValueType>
    size_t count() const;
 
    template <class ValueType>
    std::map<Key, ValueType> // , std::less<Key>, Eigen::aligned_allocator<ValueType>
    extract(const std::function<bool(Key)>& filterFcn = &_truePredicate<Key>) const;
 
  private:
    // Filters based on ValueType (if not Value) and also based on the user-
    // supplied \c filter function.
    template<class ValueType>
    static bool filterHelper(const std::function<bool(Key)> filter, const ConstKeyValuePair& key_value) {
      // static_assert if ValueType is type: Value
      static_assert(!std::is_same<Value, ValueType>::value, "ValueType must not be type: Value to use this filter");
      // Filter and check the type
      return filter(key_value.key) && (dynamic_cast<const GenericValue<ValueType>*>(&key_value.value));
    }
 
#ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
 
    friend class boost::serialization::access;
    template<class ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
      ar & BOOST_SERIALIZATION_NVP(values_);
    }
#endif
 
  };
 
  /* ************************************************************************* */
  class ValuesKeyAlreadyExists : public std::exception {
  protected:
    const Key key_; 
 
  private:
    mutable std::string message_;
 
  public:
    ValuesKeyAlreadyExists(Key key) noexcept :
      key_(key) {}
 
    ~ValuesKeyAlreadyExists() noexcept override {}
 
    Key key() const noexcept { return key_; }
 
    GTSAM_EXPORT const char* what() const noexcept override;
  };
 
  /* ************************************************************************* */
  class ValuesKeyDoesNotExist : public std::exception {
  protected:
    const char* operation_; 
    const Key key_; 
 
  private:
    mutable std::string message_;
 
  public:
    ValuesKeyDoesNotExist(const char* operation, Key key) noexcept :
      operation_(operation), key_(key) {}
 
    ~ValuesKeyDoesNotExist() noexcept override {}
 
    Key key() const noexcept { return key_; }
 
    GTSAM_EXPORT const char* what() const noexcept override;
  };
 
  /* ************************************************************************* */
  class ValuesIncorrectType : public std::exception {
  protected:
    const Key key_; 
    const std::type_info& storedTypeId_;
    const std::type_info& requestedTypeId_;
 
  private:
    mutable std::string message_;
 
  public:
    ValuesIncorrectType(Key key,
        const std::type_info& storedTypeId, const std::type_info& requestedTypeId) noexcept :
      key_(key), storedTypeId_(storedTypeId), requestedTypeId_(requestedTypeId) {}
 
    ~ValuesIncorrectType() noexcept override {}
 
    Key key() const noexcept { return key_; }
 
    const std::type_info& storedTypeId() const { return storedTypeId_; }
 
    const std::type_info& requestedTypeId() const { return requestedTypeId_; }
 
    GTSAM_EXPORT const char* what() const noexcept override;
  };
 
  /* ************************************************************************* */
  class DynamicValuesMismatched : public std::exception {
 
  public:
    DynamicValuesMismatched() noexcept {}
 
    ~DynamicValuesMismatched() noexcept override {}
 
    const char* what() const noexcept override {
      return "The Values 'this' and the argument passed to Values::localCoordinates have mismatched keys and values";
    }
  };
 
  /* ************************************************************************* */
  class NoMatchFoundForFixed: public std::exception {
 
  protected:
    const size_t M1_, N1_;
    const size_t M2_, N2_;
 
  private:
    mutable std::string message_;
 
  public:
    NoMatchFoundForFixed(size_t M1, size_t N1, size_t M2, size_t N2) noexcept :
        M1_(M1), N1_(N1), M2_(M2), N2_(N2) {
    }
 
    ~NoMatchFoundForFixed() noexcept override {
    }
 
    GTSAM_EXPORT const char* what() const noexcept override;
  };
 
  /* ************************************************************************* */
  template<>
  struct traits<Values> : public Testable<Values> {
  };
 
} //\ namespace gtsam
 
 
#include <gtsam/nonlinear/Values-inl.h>