LabeledSymbol.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/base/Testable.h>
#include <gtsam/inference/Symbol.h>
 
#include <functional>
 
namespace gtsam {
 
class GTSAM_EXPORT LabeledSymbol {
 protected:
  unsigned char c_, label_;
  std::uint64_t j_;
 
 public:
 
  LabeledSymbol();
 
  LabeledSymbol(const LabeledSymbol& key);
 
  LabeledSymbol(unsigned char c, unsigned char label, std::uint64_t j);
 
  LabeledSymbol(Key key);
 
 
  void print(const std::string& s = "") const;
 
  bool equals(const LabeledSymbol& expected, double tol = 0.0) const {
    return (*this) == expected;
  }
 
 
  operator Key() const;
 
  Key key() const { return (Key) * this; }
 
  inline unsigned char label() const { return label_; }
 
  inline unsigned char chr() const { return c_; }
 
  inline size_t index() const { return j_; }
 
  operator std::string() const;
 
  friend GTSAM_EXPORT std::ostream& operator<<(std::ostream&,
                                               const LabeledSymbol&);
 
 
  bool operator<(const LabeledSymbol& comp) const;
  bool operator==(const LabeledSymbol& comp) const;
  bool operator==(Key comp) const;
  bool operator!=(const LabeledSymbol& comp) const;
  bool operator!=(Key comp) const;
 
 
  static std::function<bool(Key)> TypeTest(unsigned char c);
 
  static std::function<bool(Key)> LabelTest(unsigned char label);
 
  static std::function<bool(Key)> TypeLabelTest(unsigned char c,
                                                unsigned char label);
 
 
  LabeledSymbol upper() const { return LabeledSymbol(c_, toupper(label_), j_); }
  LabeledSymbol lower() const { return LabeledSymbol(c_, tolower(label_), j_); }
 
  LabeledSymbol newChr(unsigned char c) const {
    return LabeledSymbol(c, label_, j_);
  }
 
  LabeledSymbol newLabel(unsigned char label) const {
    return LabeledSymbol(c_, label, j_);
  }
 
 
 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(c_);
    ar& BOOST_SERIALIZATION_NVP(label_);
    ar& BOOST_SERIALIZATION_NVP(j_);
  }
#endif
};  // \class LabeledSymbol
 
inline Key mrsymbol(unsigned char c, unsigned char label, size_t j) {
  return (Key)LabeledSymbol(c, label, j);
}
 
inline unsigned char mrsymbolChr(Key key) { return LabeledSymbol(key).chr(); }
 
inline unsigned char mrsymbolLabel(Key key) {
  return LabeledSymbol(key).label();
}
 
inline size_t mrsymbolIndex(Key key) { return LabeledSymbol(key).index(); }
 
template <>
struct traits<LabeledSymbol> : public Testable<LabeledSymbol> {};
 
}  // namespace gtsam