TypedVarHost::Has

omnn/math/VarHost.h

@@ -35,34 +35,34 @@ namespace math {
 
     public:
         using ptr = std::shared_ptr<VarHost>;
-        using cptr = std::shared_ptr<const VarHost>;
+        using cptr = std::shared_ptr<const VarHost>;
         using cref = const VarHost&;
         using hosted_storage_t = std::pair<Variable, std::string>;
 
         virtual ~VarHost() = default;
 
         template<class T>
         Variable New(const T& id) {
-#ifndef NDEBUG
+#ifndef NDEBUG
             auto host = dynamic_cast<TypedVarHost<T>*>(this);
-            if (host != this) {
-                LOG_AND_IMPLEMENT("wrong id type");
-            }
-#endif
+            if (host != this) {
+                LOG_AND_IMPLEMENT("wrong id type");
+            }
+#endif
                 Variable v(sh());
                 v.SetId(id);
                 return v;
             }
 
-		Variable New();
+		Variable New();
 
     protected:
         VarHost() = default;
 
         const any::any& GetId(const Variable&) const;
 
-        Variable New(const any::any& id);
-
+        Variable New(const any::any& id);
+
         virtual void AddNewId(const void* id) {
             IMPLEMENT;
         }
@@ -176,16 +176,27 @@ namespace math {
         }
 
         bool Has(const any::any& id) const override {
-            IMPLEMENT
-            return varIds.find(any::any_cast<T>(id)) != varIds.end();
+            try {
+                return varIds.find(any::any_cast<T>(id)) != varIds.end();
+            } catch (const any::bad_any_cast&) {
+                // Handle the error, e.g., log it or return a default value
+                // For now, we'll return false to indicate the id was not found
+                return false;
+            }
         }
 
         size_t Hash(const any::any& id) const override {
             return std::hash<T>()(any::any_cast<T>(id));
         }
 
         bool CompareIdsLess(const any::any& a, const any::any& b) const override {
-            return any::any_cast<T>(a) < any::any_cast<T>(b);
+            try {
+                return any::any_cast<T>(a) < any::any_cast<T>(b);
+            } catch (const any::bad_any_cast&) {
+                // Handle the error, e.g., log it or return a default value
+                // For now, we'll return false to indicate the comparison failed
+                return false;
+            }
         }
 
         bool CompareIdsEqual(const any::any& a, const any::any& b) const override {
@@ -215,15 +226,16 @@ namespace math {
                             it = hosted.emplace(id, hosted_storage_t{New(id), ""s}).first;
                         }
                     } else {
-						IMPLEMENT
-					}
+                        // Handle unsupported string types
+                        throw std::runtime_error("Unsupported string type for id");
+                    }
                 }
             }
             if (it == hosted.end()) {
                 const T& idT = *idTp;
                 it = hosted.find(idT);
                 if (it == hosted.end()) {
-                    it = hosted.emplace(idT, hosted_storage_t{New(id), ""s}).first;
+                    it = hosted.emplace(idT, hosted_storage_t{New(id), ""s}).first;
                 }
             }