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 std::uint64_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:
#if 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, std::uint64_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 std::uint64_t mrsymbolIndex(Key key) {
  return LabeledSymbol(key).index();
}

template <>
struct traits<LabeledSymbol> : public Testable<LabeledSymbol> {};
 
}  // namespace gtsam