add: isHahs(), isList(), isNull(), isValue()

admiswalker · Sep 18, 2023 · e0afbde · e0afbde
1 parent fe40ae1
commit e0afbde
Show file tree

Hide file tree

Showing 3 changed files with 114 additions and 49 deletions.
diff --git a/sstd/src/memory/terp/terp.cpp b/sstd/src/memory/terp/terp.cpp
@@ -346,6 +346,16 @@ std::string sstd::terp::var::typeStr() const {
     return sstd::typeNum2str((*_p).typeNum());
 }
 
+//-----------------------------------------------------------------------------------------------------------------------------------------------
+// sstd::terp::hash
+
+sstd::terp::var sstd::terp::hash(uint allocate_size){
+    sstd::terp::var r;
+    r.p()->overwrite(new std::unordered_map<std::string, sstd::void_ptr>(allocate_size));
+    return r;
+}
+sstd::terp::var sstd::terp::hash(){ return sstd::terp::hash(0); }
+
 //-----------------------------------------------------------------------------------------------------------------------------------------------
 // sstd::terp::list
 
@@ -357,13 +367,19 @@ sstd::terp::var sstd::terp::list(uint allocate_size){
 sstd::terp::var sstd::terp::list(){ return sstd::terp::list(0); }
 
 //-----------------------------------------------------------------------------------------------------------------------------------------------
-// sstd::terp::hash
+// type check
 
-sstd::terp::var sstd::terp::hash(uint allocate_size){
-    sstd::terp::var r;
-    r.p()->overwrite(new std::unordered_map<std::string, sstd::void_ptr>(allocate_size));
-    return r;
+bool sstd::terp::isHash (const sstd::terp::var& rhs){
+    return ( rhs.typeNum()==sstd::num_hash_str_void_ptr || rhs.typeNum()==sstd::num_hash_void_ptr_void_ptr );
+}
+bool sstd::terp::isList (const sstd::terp::var& rhs){
+    return rhs.typeNum()==sstd::num_vec_void_ptr;
+}
+bool sstd::terp::isNull (const sstd::terp::var& rhs){
+    return rhs.typeNum()==sstd::num_null;
+}
+bool sstd::terp::isValue(const sstd::terp::var& rhs){
+    return rhs.typeNum()==sstd::num_str;
 }
-sstd::terp::var sstd::terp::hash(){ return sstd::terp::hash(0); }
 
 //-----------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/sstd/src/memory/terp/terp.hpp b/sstd/src/memory/terp/terp.hpp
@@ -18,13 +18,19 @@ namespace sstd::terp{
     // iterator
     class iterator;
 
+    // hash
+    var hash(uint allocate_size);
+    var hash();
+
     // list
     var list(uint allocate_size);
     var list();
 
-    // hash
-    var hash(uint allocate_size);
-    var hash();
+    // type check
+    bool isHash (const sstd::terp::var& rhs);
+    bool isList (const sstd::terp::var& rhs);
+    bool isNull (const sstd::terp::var& rhs);
+    bool isValue(const sstd::terp::var& rhs);
 }
 
 //-----------------------------------------------------------------------------------------------------------------------------------------------
@@ -137,78 +143,59 @@ class sstd::terp::var{
     ~var();
 
     //---
+    // internal
+
+    sstd::void_ptr* p() const;
+
+    //---
+    // common
 
     var operator=(const char* rhs);
     var operator=(const sstd::terp::var& rhs);
 
-    //---
-
     bool operator==(const sstd::terp::var& rhs);
     bool operator!=(const sstd::terp::var& rhs);
 
-    //---
-
           var operator[](const int idx);
     const var operator[](const int idx) const;
           var operator[](const char* pKey);
     const var operator[](const char* pKey) const;
 
-    //---
-
     sstd::terp::iterator begin() const;
     sstd::terp::iterator end  () const;
 
+    uint size() const;
+
+//    void _to(std::string& dst, const sstd::void_ptr& src) const { dst = (*(std::string*)_p->ptr()); }
+    template <typename T>
+    const T to() const {
+        T ret = T();
+        sstd::terp::_to(ret, *_p);
+        return ret;
+    }
+
+    uint typeNum() const;
+    std::string typeStr() const;
+
     //---
+    // for hash type
 
     uint bucket_count();
-
-    //---
 
     sstd::terp::iterator erase(const sstd::terp::iterator& rhs);
     uint erase(const char* pKey);
 
-    //---
-
     sstd::terp::iterator find(const char* pKey) const;
 
     //---
-
-    sstd::void_ptr* p() const;
-
-    //---
+    // for list type
 
     void pop_back();
 
-    //---
-
     void push_back(const char* pRhs);
     void push_back(const sstd::terp::var& rhs);
 
-    //---
-
     void resize(uint len);
-
-    //---
-
-    uint size() const;
-
-    //---
-
-//    void _to(std::string& dst, const sstd::void_ptr& src) const { dst = (*(std::string*)_p->ptr()); }
-
-    template <typename T>
-    const T to() const {
-        T ret = T();
-        sstd::terp::_to(ret, *_p);
-        return ret;
-    }
-
-    //---
-
-    uint typeNum() const;
-    std::string typeStr() const;
-
-    //---
 };
 
 //-----------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/test/src_test/memory/terp/terp.cpp b/test/src_test/memory/terp/terp.cpp
@@ -670,6 +670,68 @@ TEST(memory_terp, var_ope_subscript_insert_number_to_hash_type){
     ASSERT_TRUE(sstd::strIn("Ope[](char*) is failed. Unexpedted data type. sstd::terp::var takes \"sstd::terp::hash()\" type, but treat as a \"sstd::terp::list()\".\n", ret.c_str()));
 }
 
+//-----------------------------------------------------------------------------------------------------------------------------------------------
+// type check
+
+// isHash()
+TEST(memory_terp, isHash_true01){
+    sstd::terp::var a;
+    a = sstd::terp::hash();
+    ASSERT_TRUE(sstd::terp::isHash(a));
+}
+TEST(memory_terp, isHash_true02){
+    sstd::terp::var a;
+    a = sstd::terp::hash();
+    a["k1"] = "v1";
+    ASSERT_TRUE(sstd::terp::isHash(a));
+}
+TEST(memory_terp, isHash_true03){
+    sstd::terp::var a;
+    a = sstd::terp::hash();
+    a["k1"] = sstd::terp::list();
+    ASSERT_TRUE(sstd::terp::isHash(a));
+}
+TEST(memory_terp, isHash_false){
+    sstd::terp::var a;
+    a = sstd::terp::list();
+    ASSERT_TRUE(!sstd::terp::isHash(a));
+}
+
+// isList()
+TEST(memory_terp, isList_true){
+    sstd::terp::var a;
+    a = sstd::terp::list();
+    ASSERT_TRUE(sstd::terp::isList(a));
+}
+TEST(memory_terp, isList_false){
+    sstd::terp::var a;
+    a = sstd::terp::hash();
+    ASSERT_TRUE(!sstd::terp::isList(a));
+}
+
+// isNull()
+TEST(memory_terp, isNull_true){
+    sstd::terp::var a;
+    ASSERT_TRUE(sstd::terp::isNull(a));
+}
+TEST(memory_terp, isNull_false){
+    sstd::terp::var a;
+    a = sstd::terp::hash();
+    ASSERT_TRUE(!sstd::terp::isNull(a));
+}
+
+// isValue()
+TEST(memory_terp, isValue_true){
+    sstd::terp::var a;
+    a = "str";
+    ASSERT_TRUE(sstd::terp::isValue(a));
+}
+TEST(memory_terp, isValue_false){
+    sstd::terp::var a;
+    a = sstd::terp::hash();
+    ASSERT_TRUE(!sstd::terp::isValue(a));
+}
+
 //-----------------------------------------------------------------------------------------------------------------------------------------------
 
 EXECUTE_TESTS();