Factor.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
 
 * -------------------------------------------------------------------------- */
 
// \callgraph
 
#pragma once
 
#ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/nvp.hpp>
#endif
#include <gtsam/base/FastVector.h>
#include <gtsam/base/types.h>
#include <gtsam/inference/Key.h>
 
#include <algorithm>
#include <memory>
 
namespace gtsam {
 
  typedef FastVector<FactorIndex> FactorIndices;
  typedef FastSet<FactorIndex> FactorIndexSet;
 
  class HybridValues; // forward declaration of a Value type for error.
 
  class GTSAM_EXPORT Factor
  {
 
  private:
    // These typedefs are private because they must be overridden in derived classes.
    typedef Factor This; 
    typedef std::shared_ptr<Factor> shared_ptr; 
 
  public:
    typedef KeyVector::iterator iterator;
 
    typedef KeyVector::const_iterator const_iterator;
 
  protected:
 
    KeyVector keys_;
 
 
    Factor() {}
 
    template<typename CONTAINER>
    explicit Factor(const CONTAINER& keys) : keys_(keys.begin(), keys.end()) {}
 
    template<typename ITERATOR>
    Factor(ITERATOR first, ITERATOR last) : keys_(first, last) {}
 
    template<typename CONTAINER>
    static Factor FromKeys(const CONTAINER& keys) {
      return Factor(keys.begin(), keys.end()); }
 
    template<typename ITERATOR>
    static Factor FromIterators(ITERATOR first, ITERATOR last) {
      return Factor(first, last); }
 
 
  public:
   // public since it is required for boost serialization and static methods.
   // virtual since it is public.
   // http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-dtor-virtual
   virtual ~Factor() = default;
 
 
   bool empty() const { return keys_.empty(); }
 
   Key front() const { return keys_.front(); }
 
   Key back() const { return keys_.back(); }
 
   const_iterator find(Key key) const { return std::find(begin(), end(), key); }
 
   const KeyVector& keys() const { return keys_; }
 
   const_iterator begin() const { return keys_.begin(); }
 
   const_iterator end() const { return keys_.end(); }
 
  virtual double error(const HybridValues& c) const;
 
   size_t size() const { return keys_.size(); }
 
 
 
   virtual void print(
       const std::string& s = "Factor",
       const KeyFormatter& formatter = DefaultKeyFormatter) const;
 
   virtual void printKeys(
       const std::string& s = "Factor",
       const KeyFormatter& formatter = DefaultKeyFormatter) const;
 
    bool equals(const This& other, double tol = 1e-9) const;
 
 
    KeyVector& keys() { return keys_; }
 
    iterator begin() { return keys_.begin(); }
 
    iterator end() { return keys_.end(); }
 
 
  private:
#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(keys_);
    }
#endif
 
 
  };
 
} // \namespace gtsam