rename to Category and put inside HybridFactor class

gtsam/hybrid/HybridFactor.cpp

@@ -50,22 +50,20 @@ DiscreteKeys CollectDiscreteKeys(const DiscreteKeys &key1,
 
 /* ************************************************************************ */
 HybridFactor::HybridFactor(const KeyVector &keys)
-    : Base(keys),
+    : Base(keys), category_(Category::Continuous), continuousKeys_(keys) {}
-      category_(HybridCategory::Continuous),
-      continuousKeys_(keys) {}
 
 /* ************************************************************************ */
-HybridCategory GetCategory(const KeyVector &continuousKeys,
+HybridFactor::Category GetCategory(const KeyVector &continuousKeys,
-                           const DiscreteKeys &discreteKeys) {
+                                   const DiscreteKeys &discreteKeys) {
   if ((continuousKeys.size() == 0) && (discreteKeys.size() != 0)) {
-    return HybridCategory::Discrete;
+    return HybridFactor::Category::Discrete;
   } else if ((continuousKeys.size() != 0) && (discreteKeys.size() == 0)) {
-    return HybridCategory::Continuous;
+    return HybridFactor::Category::Continuous;
   } else if ((continuousKeys.size() != 0) && (discreteKeys.size() != 0)) {
-    return HybridCategory::Hybrid;
+    return HybridFactor::Category::Hybrid;
   } else {
     // Case where we have no keys. Should never happen.
-    return HybridCategory::None;
+    return HybridFactor::Category::None;
   }
 }
 
@@ -80,7 +78,7 @@ HybridFactor::HybridFactor(const KeyVector &continuousKeys,
 /* ************************************************************************ */
 HybridFactor::HybridFactor(const DiscreteKeys &discreteKeys)
     : Base(CollectKeys({}, discreteKeys)),
-      category_(HybridCategory::Discrete),
+      category_(Category::Discrete),
       discreteKeys_(discreteKeys),
       continuousKeys_({}) {}
 
@@ -97,16 +95,16 @@ void HybridFactor::print(const std::string &s,
                          const KeyFormatter &formatter) const {
   std::cout << (s.empty() ? "" : s + "\n");
   switch (category_) {
-    case HybridCategory::Continuous:
+    case Category::Continuous:
       std::cout << "Continuous ";
       break;
-    case HybridCategory::Discrete:
+    case Category::Discrete:
       std::cout << "Discrete ";
       break;
-    case HybridCategory::Hybrid:
+    case Category::Hybrid:
       std::cout << "Hybrid ";
       break;
-    case HybridCategory::None:
+    case Category::None:
       std::cout << "None ";
       break;
   }

gtsam/hybrid/HybridFactor.h

@@ -41,9 +41,6 @@ KeyVector CollectKeys(const KeyVector &keys1, const KeyVector &keys2);
 DiscreteKeys CollectDiscreteKeys(const DiscreteKeys &key1,
                                  const DiscreteKeys &key2);
 
-/// Enum to help with categorizing hybrid factors.
-enum class HybridCategory { None, Discrete, Continuous, Hybrid };
-
 /**
  * Base class for *truly* hybrid probabilistic factors
  *
@@ -55,9 +52,13 @@ enum class HybridCategory { None, Discrete, Continuous, Hybrid };
  * @ingroup hybrid
  */
 class GTSAM_EXPORT HybridFactor : public Factor {
+ public:
+  /// Enum to help with categorizing hybrid factors.
+  enum class Category { None, Discrete, Continuous, Hybrid };
+
  private:
   /// Record what category of HybridFactor this is.
-  HybridCategory category_ = HybridCategory::None;
+  Category category_ = Category::None;
 
  protected:
   // Set of DiscreteKeys for this factor.
@@ -118,13 +119,13 @@ class GTSAM_EXPORT HybridFactor : public Factor {
   /// @{
 
   /// True if this is a factor of discrete variables only.
-  bool isDiscrete() const { return category_ == HybridCategory::Discrete; }
+  bool isDiscrete() const { return category_ == Category::Discrete; }
 
   /// True if this is a factor of continuous variables only.
-  bool isContinuous() const { return category_ == HybridCategory::Continuous; }
+  bool isContinuous() const { return category_ == Category::Continuous; }
 
   /// True is this is a Discrete-Continuous factor.
-  bool isHybrid() const { return category_ == HybridCategory::Hybrid; }
+  bool isHybrid() const { return category_ == Category::Hybrid; }
 
   /// Return the number of continuous variables in this factor.
   size_t nrContinuous() const { return continuousKeys_.size(); }