s_matrix 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 873b7c7f5cf89a315b84cd9b373923819962522c
-  data.tar.gz: 9706ed9b6207ddeba5970c09ba027c6bc0739b62
+  metadata.gz: d0a1d9986c5eee4c83153245c8ecb30da21d3609
+  data.tar.gz: 8cd70ce3cf6a73ac9acb964b3bb7483979c1686e
 SHA512:
-  metadata.gz: 5015507f5e37081199965b0098dc2ee9d0f6e4df0bab055c55d159bbb1127b6e9295e36350586634980d140ab80adcfdc3906a7a8b33aff6f4156bec27518793
-  data.tar.gz: c16ea95270874368b5c53f531f455d1c2abef4e3412c335860a8b3b2e8c754be8187694b3eb20d5778335b55dc59b7e9b10f0533a0ee00a660f420486fa2712e
+  metadata.gz: 6840c3d37d7b86ebb9c2034a7cf295587daff1ac5be8273a2c8bf3eabf33593b0ab334807c9dc3bfaa8dfec2817d312ec017371e15f93bf8f77e728dc678ce52
+  data.tar.gz: 2b33b8b9209bf4c262ea642684bc2332d326e30fc0cecedf5b72c56b10d6958b52f280a0df37cf22862fdbb971244922e4262ac216ae2a6e671e777add55bdb9

data/README.md

@@ -1,5 +1,4 @@
-Current version 1.0.0
-Latest stable version is 1.0.0
+Current version 1.0.2
 
 ### Matrix reduce memory usage for large Hash.
   Matrix store the hash like this: <br>
@@ -46,16 +45,21 @@ Or install it yourself as:
     EQUIPMENTS.size.should == 2
   # or you can use get\_row instead of []<br>
     EQUIPMENTS.get\_row('20002')<br>
-  # each
-    EQUIPMENTS.each {|k, v| k == '10001', v == {'id' => '10001', 'name' => 'sword', ...} }
-  # all
-    EQUIPMENTS.all.should == { '20002' => {'id' => '10002', 'name' => 'shoe', 'speed' => '5'}, '20003' => {} }
-  # ids
-    EQUIPMENTS.ids.should == ['20002', '20003']
-  # keys
-    EQUIPMENTS.keys.should == ['id', 'name', 'hp']
-  # to\_s for debug
-    puts EQUIPMENTS.to_s
+  # each<br>
+    EQUIPMENTS.each {|k, v| k == '10001', v == {'id' => '10001', 'name' => 'sword', ...} }<br>
+  # all<br>
+    EQUIPMENTS.all.should == { '20002' => {'id' => '10002', 'name' => 'shoe', 'speed' => '5'}, '20003' => {} }<br>
+  # first<br>
+    EQUIPMENTS.first.should == ['20002', {'id' => '10002', 'name' => 'shoe', 'speed' => '5'}]
+  # ids<br>
+    EQUIPMENTS.ids.should == ['20002', '20003']<br>
+  # keys<br>
+    EQUIPMENTS.keys.should == ['id', 'name', 'hp']<br>
+  # find    -- find the first one<br>
+    EQUIPMENTS.find({name: 'shoe'}).should == ['20002', {'id' => '10002', 'name' => 'shoe', 'speed' => '5'}]
+  # to\_s for debug<br>
+    puts EQUIPMENTS.to_s<br>
+
 
 ### todolist
   https://github.com/libinzhangyuan/s\_matrix/blob/master/todolist.txt

data/ext/s_matrix/gmatx.cpp

@@ -5,6 +5,8 @@
 #include "stdio.h"
 
 
+bool GMatx::t_continue = true;
+bool GMatx::t_break = false;
 GMatx::GMatx(void)
 {
 }
@@ -43,7 +45,6 @@ const std::vector<std::string>& GMatx::get_titles(void) const
     return m_titles.get_titles();
 }
 
-// typedef void (*each_call_func)(const std::string& /*key*/, const t_key_value_hash& /*row_content*/, void* args);
 void GMatx::each_call(each_call_func func, void* args) const
 {
     const std::vector<std::string>& titles = m_titles.get_titles();
@@ -52,7 +53,8 @@ void GMatx::each_call(each_call_func func, void* args) const
     {
         const std::string& id = iter->first;
         const MatxRow& row = iter->second;
-        func(id, row.to_key_value_hash(titles), args);
+        if (func(id, row.to_key_value_hash(titles), args) == GMatx::t_break)
+            break;
     }
 }
 
@@ -70,3 +72,19 @@ size_t GMatx::size(void) const
 {
     return m_contents.size();
 }
+
+t_key_value_hash GMatx::first(std::string& id_out) const
+{
+    t_key_value_hash result;
+
+    // empty matx.
+    //
+    std::map<std::string /* id */, MatxRow>::const_iterator iter = m_contents.begin();
+    if (iter == m_contents.end())
+        return result;
+
+    id_out = iter->first;
+    const MatxRow& row = iter->second;
+    const std::vector<std::string>& titles = m_titles.get_titles();
+    return row.to_key_value_hash(titles);
+}

data/ext/s_matrix/gmatx.h

@@ -19,9 +19,14 @@ public:
     std::string to_s(void) const;
     size_t size(void) const;
 
+    t_key_value_hash first(std::string& id_out) const;
+
     // iterator function
     // the args parameter of each_call function will pass to callback function each_call_func.
-    typedef void (*each_call_func)(const std::string& /*key*/, const t_key_value_hash& /*row_content*/, void* args);
+    // the return of each_call_func indicate continue iterator or not. - true means continue. false means break.
+    static bool t_continue;
+    static bool t_break;
+    typedef bool (*each_call_func)(const std::string& /*id*/, const t_key_value_hash& /*row_content*/, void* args);
     void each_call(each_call_func func, void* args) const;
 
 private:

data/ext/s_matrix/matx_hash_util.cpp

@@ -0,0 +1,62 @@
+#include <sstream>
+
+#include "matx_hash_util.h"
+#include "stdio.h"
+#include "matx_row.h"
+
+namespace MatxHashUtil
+{
+
+    VALUE key_value_hash_to_ruby_hash(const t_key_value_hash& row_hash)
+    {
+        VALUE ret_hash = rb_hash_new();
+        for (t_key_value_hash::const_iterator iter = row_hash.begin(); iter != row_hash.end(); ++iter)
+        {
+            const std::string& key = iter->first;
+            const std::string& value = iter->second;
+            if (value == MatxRow::null_string)
+                rb_hash_aset(ret_hash, rb_str_new_cstr(key.c_str()), Qnil);
+            else
+                rb_hash_aset(ret_hash, rb_str_new_cstr(key.c_str()), rb_str_new_cstr(value.c_str()));
+        }
+        return ret_hash;
+    }
+
+    int hash_iter_func(VALUE key, VALUE value, VALUE p_row_hash)
+    {
+        t_key_value_hash* p_hash = (t_key_value_hash*)p_row_hash;
+
+        // key
+        VALUE key_str = rb_funcall(key, rb_intern("to_s"), 0);
+
+        // value
+        std::string str_value;
+        if (TYPE(value) == T_NIL)
+            str_value = MatxRow::null_string;
+        else
+        {
+            VALUE rb_str = rb_funcall(value, rb_intern("to_s"), 0);
+            str_value = StringValueCStr( rb_str );
+        }
+
+        (*p_hash)[StringValueCStr(key_str)] = str_value;
+        return ST_CONTINUE;
+    }
+
+    t_key_value_hash rb_hash_to_key_value_hash(VALUE rb_hash)
+    {
+        t_key_value_hash row_hash;
+        rb_hash_foreach(rb_hash, (int (*)(ANYARGS))hash_iter_func, (VALUE)&row_hash);
+        return row_hash;
+    }
+
+    std::string key_value_hash_to_str(const t_key_value_hash& row_hash)
+    {
+        std::ostringstream ostr;
+        ostr << "--row_hash: size = " << row_hash.size() << std::endl;
+        for (t_key_value_hash::const_iterator iter = row_hash.begin(); iter!= row_hash.end(); ++iter)
+            ostr << iter->first << " -> " << iter->second << std::endl;
+        ostr << std::endl;
+        return ostr.str();
+    }
+}

data/ext/s_matrix/matx_hash_util.h

@@ -0,0 +1,20 @@
+#ifndef _MATX_HASH_UTIL_H_
+#define _MATX_HASH_UTIL_H_
+
+#include <string>
+#include <map>
+#include "matx_type_def.h"
+
+#include "ruby.h"
+
+namespace MatxHashUtil
+{
+    VALUE key_value_hash_to_ruby_hash(const t_key_value_hash& row_hash);
+    t_key_value_hash rb_hash_to_key_value_hash(VALUE rb_hash);
+
+    std::string key_value_hash_to_str(const t_key_value_hash& row_hash);
+}
+
+
+
+#endif // _MATX_HASH_UTIL_H_

data/ext/s_matrix/s_matrix.cpp

@@ -4,6 +4,7 @@
 #include "ruby/util.h"
 
 #include "gmatx.h"
+#include "matx_hash_util.h"
 
 static VALUE t_init(VALUE self);
 static VALUE t_init_copy(VALUE self, VALUE orig);
@@ -51,19 +52,6 @@ static VALUE sm_alloc(VALUE klass)
     return Data_Wrap_Struct(klass, 0, free_matx, pMatx);
 }
 
-static int t_add_row_hash_iter_func(VALUE key, VALUE value, VALUE p_row_hash)
-{
-    t_key_value_hash* p_hash = (t_key_value_hash*)p_row_hash;
-
-    VALUE key_str = rb_funcall(key, rb_intern("to_s"), 0);
-    VALUE value_str = rb_funcall(value, rb_intern("to_s"), 0);
-    //printf("key: %s, value: %s, p_hash size %lu\n", StringValueCStr(key_str), StringValueCStr(value_str), p_hash->size());
-
-    (*p_hash)[StringValueCStr(key_str)] = StringValueCStr(value_str);
-    return ST_CONTINUE;
-}
-
-
 // row： {hp: 23, name: '2332342', 'text' => 'fsdfsd'}
 static VALUE t_add_row(VALUE self, VALUE id, VALUE row)
 {
@@ -80,8 +68,7 @@ static VALUE t_add_row(VALUE self, VALUE id, VALUE row)
 
     // 处理row    deal with row
     //
-    t_key_value_hash row_hash;
-    rb_hash_foreach(row, (int (*)(ANYARGS))t_add_row_hash_iter_func, (VALUE)&row_hash);
+    const t_key_value_hash& row_hash = MatxHashUtil::rb_hash_to_key_value_hash(row);
 
     // 存数据   store data
     //
@@ -93,21 +80,6 @@ static VALUE t_add_row(VALUE self, VALUE id, VALUE row)
     return self;
 }
 
-static VALUE row_hash_to_ruby_hash(const t_key_value_hash& row_hash)
-{
-    VALUE ret_hash = rb_hash_new();
-    for (t_key_value_hash::const_iterator iter = row_hash.begin(); iter != row_hash.end(); ++iter)
-    {
-        const std::string& key = iter->first;
-        const std::string& value = iter->second;
-        if (value == MatxRow::null_string)
-            rb_hash_aset(ret_hash, rb_str_new_cstr(key.c_str()), Qnil);
-        else
-            rb_hash_aset(ret_hash, rb_str_new_cstr(key.c_str()), rb_str_new_cstr(value.c_str()));
-    }
-    return ret_hash;
-}
-
 static VALUE t_get_row(VALUE self, VALUE id)
 {
     // 处理id      deal with id
@@ -123,12 +95,69 @@ static VALUE t_get_row(VALUE self, VALUE id)
     Data_Get_Struct(self, class GMatx, pMatx);
 
     t_key_value_hash row_hash = pMatx->get_row(std::string(p_id_c_str));
-    return row_hash_to_ruby_hash(row_hash);
+    return MatxHashUtil::key_value_hash_to_ruby_hash(row_hash);
+}
+
+struct FindCallbackArgs
+{
+    std::string id;
+    t_key_value_hash row_content;
+
+    t_key_value_hash search_keys;
+};
+static bool callback_func__find(const std::string& id, const t_key_value_hash& row_content, void* args)
+{
+    FindCallbackArgs* pargs = (FindCallbackArgs*)(args);
+    for (t_key_value_hash::const_iterator iter = pargs->search_keys.begin();
+        iter != pargs->search_keys.end(); ++iter)
+    {
+         const std::string& search_key = iter->first;
+         const std::string& search_value = iter->second;
+
+         t_key_value_hash::const_iterator row_content_iter = row_content.find(search_key);
+
+         // compare nil value.    -- s.find({a: '3', b: nil})   when compile b: nil
+         if (search_value == MatxRow::null_string)
+         {
+             if (row_content_iter != row_content.end() && row_content_iter->second != search_value)
+                 return GMatx::t_continue;
+             continue;
+         }
+
+         // compare value not nil
+         if (row_content_iter == row_content.end() || row_content_iter->second != search_value)
+             return GMatx::t_continue;
+    }
+    pargs->id = id;
+    pargs->row_content = row_content;
+    return GMatx::t_break;
 }
 
-static void callback_func__each(const std::string& key, const t_key_value_hash& row_content, void* args)
+static VALUE t_find(VALUE self, VALUE search_keys_ruby_hash)
 {
-    rb_yield_values(2, rb_str_new_cstr(key.c_str()), row_hash_to_ruby_hash(row_content));
+    Check_Type(search_keys_ruby_hash, T_HASH);
+
+    struct FindCallbackArgs args;
+    args.search_keys = MatxHashUtil::rb_hash_to_key_value_hash(search_keys_ruby_hash);
+
+    class GMatx* pMatx = NULL;
+    Data_Get_Struct(self, class GMatx, pMatx);
+    pMatx->each_call(callback_func__find, &args);
+    if (args.id.size() > 0)
+    {
+        VALUE ret_ary = rb_ary_new();
+        rb_ary_push(ret_ary, rb_str_new_cstr(args.id.c_str()));
+        rb_ary_push(ret_ary, MatxHashUtil::key_value_hash_to_ruby_hash(args.row_content));
+        return ret_ary;
+    }
+    return Qnil;
+}
+
+
+static bool callback_func__each(const std::string& key, const t_key_value_hash& row_content, void* args)
+{
+    rb_yield_values(2, rb_str_new_cstr(key.c_str()), MatxHashUtil::key_value_hash_to_ruby_hash(row_content));
+    return GMatx::t_continue;
 }
 
 static VALUE t_each(VALUE self)
@@ -144,10 +173,11 @@ static VALUE t_each(VALUE self)
     return self;
 }
 
-static void callback_func__all(const std::string& key, const t_key_value_hash& row_content, void* args)
+static bool callback_func__all(const std::string& key, const t_key_value_hash& row_content, void* args)
 {
     VALUE* p_ret_hash = (VALUE*)(args);
-    rb_hash_aset(*p_ret_hash, rb_str_new_cstr(key.c_str()), row_hash_to_ruby_hash(row_content));
+    rb_hash_aset(*p_ret_hash, rb_str_new_cstr(key.c_str()), MatxHashUtil::key_value_hash_to_ruby_hash(row_content));
+    return GMatx::t_continue;
 }
 
 static VALUE t_all(VALUE self)
@@ -160,10 +190,11 @@ static VALUE t_all(VALUE self)
     return ret_hash;
 }
 
-static void callback_func__ids(const std::string& key, const t_key_value_hash& row_content, void* args)
+static bool callback_func__ids(const std::string& key, const t_key_value_hash& row_content, void* args)
 {
     VALUE* p_ret_array = (VALUE*)(args);
     rb_ary_push(*p_ret_array, rb_str_new_cstr(key.c_str()));
+    return GMatx::t_continue;
 }
 
 static VALUE t_ids(VALUE self)
@@ -207,6 +238,21 @@ static VALUE t_size(VALUE self)
     return INT2NUM(pMatx->size());
 }
 
+static VALUE t_first(VALUE self)
+{
+    class GMatx* pMatx = NULL;
+    Data_Get_Struct(self, class GMatx, pMatx);
+
+    std::string id;
+    t_key_value_hash row_hash = pMatx->first(id);
+    if (id.empty())
+        return Qnil;
+    VALUE ret_array = rb_ary_new();
+    rb_ary_push(ret_array, rb_str_new_cstr(id.c_str()));
+    rb_ary_push(ret_array, MatxHashUtil::key_value_hash_to_ruby_hash(row_hash));
+
+    return ret_array;
+}
 
 VALUE cSMatrix;
 
@@ -220,7 +266,9 @@ extern "C" void Init_s_matrix()
     rb_define_method(cSMatrix, "to_s", (VALUE(*)(ANYARGS))t_to_s, 0);
     rb_define_method(cSMatrix, "add_row", (VALUE(*)(ANYARGS))t_add_row, 2);
     rb_define_method(cSMatrix, "get_row", (VALUE(*)(ANYARGS))t_get_row, 1);
+    rb_define_method(cSMatrix, "find", (VALUE(*)(ANYARGS))t_find, 1);
     rb_define_method(cSMatrix, "each", (VALUE(*)(ANYARGS))t_each, 0);
+    rb_define_method(cSMatrix, "first", (VALUE(*)(ANYARGS))t_first, 0);
     rb_define_method(cSMatrix, "all", (VALUE(*)(ANYARGS))t_all, 0);
     rb_define_method(cSMatrix, "ids", (VALUE(*)(ANYARGS))t_ids, 0);
     rb_define_method(cSMatrix, "keys", (VALUE(*)(ANYARGS))t_keys, 0);

data/lib/s_matrix/version.rb

@@ -1,5 +1,5 @@
 class SMatrix
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end
 
 require "s_matrix/s_matrix"

data/spec/smatrix_spec.rb

@@ -102,16 +102,19 @@ describe SMatrix do
       expect(a.all).to eq({})
       expect(a.ids).to eq([])
       expect(a.keys).to eq([])
+      expect(a.first).to eq(nil)
 
       a.add_row('2', {a: 2})
       expect(a.all).to eq({'2' => {'a' => '2'}})
       expect(a.ids).to eq(['2'])
       expect(a.keys).to eq(['a'])
+      expect(a.first).to eq(['2', {'a' => '2'}])
 
       a.add_row('2', {b: 3})
       expect(a.all).to eq({'2' => {'a' => nil, 'b' => '3'}})
       expect(a.ids).to eq(['2'])
       expect(a.keys).to eq(['a', 'b'])
+      expect(a.first).to eq(['2', {'a' => nil, 'b' => '3'}])
 
       a.add_row('3', {b: 3})
       expect(a.all).to eq({
@@ -120,6 +123,29 @@ describe SMatrix do
         })
       expect(a.ids).to eq(['2', '3'])
       expect(a.keys).to eq(['a', 'b'])
+      expect(a.first == ['2', {'a' => nil, 'b' => '3'}] || a.first == ['3', {'b' => '3'}]).to eq(true)
+    end
+  end
+
+  describe 'find' do
+    it '' do
+      a = SMatrix.new
+      expect( a.find({a: '2'}) ).to eq nil
+
+      a.add_row('223', {a: 2})
+      expect( a.find({a: '2'}) ).to eq ['223', {'a' => '2'}]
+
+      a.add_row('224', {a: 3})
+      expect( a.find({a: '2'}) ).to eq ['223', {'a' => '2'}]
+      expect( a.find({a: '3'}) ).to eq ['224', {'a' => '3'}]
+      expect( a.find({a: '3', b: nil}) ).to eq ['224', {'a' => '3'}]
+
+      a.add_row('225', {a: 2, b: 3})
+      expect( a.find({a: '2'})[0] == '223' || a.find({a: '2'})[0] == '224' ).to eq true
+      expect( a.find({b: '3'}) ).to eq ['225', {'a' => '2', 'b' => '3'}]
+      expect( a.find({a: '2', b: '3'}) ).to eq ['225', {'a' => '2', 'b' => '3'}]
+      expect( a.find({a: '2', b: '1'}) ).to eq nil
+      expect( a.find({a: nil, b: '3'}) ).to eq nil
     end
   end
 

data/todolist.txt

@@ -1,16 +1,15 @@
 todolist:
 
 1. function with first priority:
--done all
-  -return {'23423' => {'name' => 'haha', 'hp' => '23425'}, '234232' => {} }
--done ids
-  -return ['233423', '234134']
-keys
-  -return ['name', 'hp']
-first
+-done all  -return {'23423' => {'name' => 'haha', 'hp' => '23425'}, '234232' => {} }
+-done ids  -return ['233423', '234134']
+-done keys  -return ['name', 'hp']
+-done first    -return: ['23423', {'name' => 'haha', 'hp' => '23425'}]
+
 empty?
 include? {|k, v| k == '2323232'}
-find_by name: 'haha', hp: '2342'
+-done find name: 'haha', hp: '2342'       -return ['234232', {'name' => 'haha', 'hp' => '23425'}]
+find_all name: 'haha', hp: '2342'   -return [['234232', {'name' => 'haha', 'hp' => '23425'}], [], ...]
 select {|k, v| k == '2232'}
 merge
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: s_matrix
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - zhangyuan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2014-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -102,6 +102,8 @@ files:
 - ext/s_matrix/gmatx.h
 - ext/s_matrix/matx_content.cpp
 - ext/s_matrix/matx_content.h
+- ext/s_matrix/matx_hash_util.cpp
+- ext/s_matrix/matx_hash_util.h
 - ext/s_matrix/matx_row.cpp
 - ext/s_matrix/matx_row.h
 - ext/s_matrix/matx_string.h