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/inference/Symbol.h>

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(gtsam::Key key);

  operator gtsam::Key() const;

  // Testable Requirements
  void print(const std::string& s = "") const;

  bool equals(const LabeledSymbol& expected, double tol = 0.0) const {
    return (*this) == expected;
  }

  gtsam::Key key() const { return (gtsam::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;

  bool operator<(const LabeledSymbol& comp) const;
  bool operator==(const LabeledSymbol& comp) const;
  bool operator==(gtsam::Key comp) const;
  bool operator!=(const LabeledSymbol& comp) const;
  bool operator!=(gtsam::Key comp) const;

  // Checks only the type
  static boost::function<bool(gtsam::Key)> TypeTest(unsigned char c);

  // Checks only the robot ID (label_)
  static boost::function<bool(gtsam::Key)> LabelTest(unsigned char label);

  // Checks both type and the robot ID
  static boost::function<bool(gtsam::Key)> TypeLabelTest(unsigned char c, unsigned char label);

  // Converts to upper/lower versions of labels
  LabeledSymbol upper() const { return LabeledSymbol(c_, toupper(label_), j_); }
  LabeledSymbol lower() const { return LabeledSymbol(c_, tolower(label_), j_); }

  // Create a new symbol with a different value
  LabeledSymbol newChr(unsigned char c) const { return LabeledSymbol(c, label_, j_); }
  LabeledSymbol newLabel(unsigned char label) const { return LabeledSymbol(c_, label, j_); }

private:

  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_);
  }
}; // \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