GenericValue.h

/* ----------------------------------------------------------------------------
 
 * 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
 
 * -------------------------------------------------------------------------- */
 
/*
 * @file GenericValue.h
 * @brief Wraps any type T so it can play as a Value
 * @date October, 2014
 * @author Michael Bosse, Abel Gawel, Renaud Dube
 * based on DerivedValue.h by Duy Nguyen Ta
 */
 
#pragma once
 
#include <gtsam/base/Manifold.h>
#include <gtsam/base/types.h>
#include <gtsam/base/Value.h>
 
#include <iostream>
#include <typeinfo> // operator typeid
 
// GenericValue's RTTI must remain visible so the C++ ABI can identify a
// specialization consistently when a Value crosses a shared-library boundary.
#if defined(_WIN32)
// Exporting this header-only template triggers linker errors on MSVC.
// Please refer to https://github.com/borglab/gtsam/blob/develop/Using-GTSAM-EXPORT.md
#define GENERICVALUE_VISIBILITY
#else
#define GENERICVALUE_VISIBILITY GTSAM_EXPORT
#endif
 
namespace gtsam {

template<class T>
class GENERICVALUE_VISIBILITY GenericValue: public Value {
 
public:
 
  typedef T type;
 
protected:
 
  T value_; 
 
public:
  // Only needed for serialization.
  GenericValue(){}

  GenericValue(const T& value) : Value(),
      value_(value) {}
 
  GenericValue(const GenericValue& other) = default;

  const T& value() const {
    return value_;
  }

  T& value() {
    return value_;
  }

  ~GenericValue() override {
  }

  bool equals_(const Value& p, double tol = 1e-9) const override {
    // Cast the base class Value pointer to a templated generic class pointer
    const GenericValue& genericValue2 = static_cast<const GenericValue&>(p);
    // Return the result of using the equals traits for the derived class
    return traits<T>::Equals(this->value_, genericValue2.value_, tol);
  }

  bool equals(const GenericValue &other, double tol = 1e-9) const {
    return traits<T>::Equals(this->value(), other.value(), tol);
  }

  void print(const std::string& str) const override {
    std::cout << "(" << demangle(typeid(T).name()) << ")\n";
    traits<T>::Print(value_, str);
  }

    Value* clone_() const override {
      GenericValue* ptr = new GenericValue(*this); // calls copy constructor to fill in
      return ptr;
    }

    void deallocate_() const override {
      delete this;
    }

    std::shared_ptr<Value> clone() const override {
      return std::allocate_shared<GenericValue>(Eigen::aligned_allocator<GenericValue>(), *this);
    }

    Value* retract_(const Vector& delta) const override {
      // Call retract on the derived class using the retract trait function
      const T retractResult = traits<T>::Retract(GenericValue<T>::value(), delta);
 
      Value* resultAsValue = new GenericValue(retractResult);
 
      // Return the pointer to the Value base class
      return resultAsValue;
    }

    Vector localCoordinates_(const Value& value2) const override {
      // Cast the base class Value pointer to a templated generic class pointer
      const GenericValue<T>& genericValue2 =
          static_cast<const GenericValue<T>&>(value2);
 
      // Return the result of calling localCoordinates trait on the derived class
      return traits<T>::Local(GenericValue<T>::value(), genericValue2.value());
    }

    GenericValue retract(const Vector& delta) const {
      return GenericValue(traits<T>::Retract(GenericValue<T>::value(), delta));
    }

    Vector localCoordinates(const GenericValue& value2) const {
      return localCoordinates_(value2);
    }

    size_t dim() const override {
      return traits<T>::GetDimension(value_);
    }

    Value& operator=(const Value& rhs) override {
      // Cast the base class Value pointer to a derived class pointer
      const GenericValue& derivedRhs = static_cast<const GenericValue&>(rhs);
 
      // Do the assignment and return the result
      *this = GenericValue(derivedRhs); // calls copy constructor
      return *this;
    }
 
  protected:

    GenericValue<T>& operator=(const GenericValue<T>& rhs) {
      Value::operator=(static_cast<Value const&>(rhs));
      value_ = rhs.value_;
      return *this;
    }
 
  private:
 
#if GTSAM_ENABLE_BOOST_SERIALIZATION
    friend class boost::serialization::access;
    template<class ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
      ar & boost::serialization::make_nvp("GenericValue",
              boost::serialization::base_object<Value>(*this));
      ar & boost::serialization::make_nvp("value", value_);
        }
#endif
};

#define GTSAM_VALUE_EXPORT(Type) BOOST_CLASS_EXPORT(gtsam::GenericValue<Type>)
 
// traits
template <typename ValueType>
struct traits<GenericValue<ValueType> >
    : public Testable<GenericValue<ValueType> > {};
 
// define Value::cast here since now GenericValue has been declared
template<typename ValueType>
const ValueType& Value::cast() const {
  return dynamic_cast<const GenericValue<ValueType>&>(*this).value();
}

template<class T>
GenericValue<T> genericValue(const T& v) {
  return GenericValue<T>(v);
}
 
 
} /* namespace gtsam */