props: began work on vector converters

5 files changed, 153 insertions, 81 deletions

diff --git a/PMC b/PMC
-Subproject 663f235c5321b7c326feb6feea2d938a2b7cd57
+Subproject 69492abfcc79b37db611c04533dd699809c4494
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 38377dd..b5ed2d5 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -67,6 +67,7 @@ list(APPEND GRAS_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/top_block.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/top_block_query.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/json_parser.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/pmc_to_ptree.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/register_messages.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/weak_container.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/serialize_types.cpp
diff --git a/lib/pmc_to_ptree.cpp b/lib/pmc_to_ptree.cpp
new file mode 100644
index 0000000..677b6ce
--- /dev/null
+++ b/lib/pmc_to_ptree.cpp
@@ -0,0 +1,100 @@
+// Copyright (C) by Josh Blum. See LICENSE.txt for licensing information.
+
+#include "gras_impl/debug.hpp"
+#include <PMC/PMC.hpp>
+#include <PMC/Containers.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/foreach.hpp>
+
+using namespace boost::property_tree;
+
+PMCC ptree_to_pmc(const ptree &value, const std::type_info &hint)
+{
+    //if the type is PMCC - educated guess and recursively call
+    if (hint == typeid(PMCC) or hint == typeid(PMC))
+    {
+        //single child
+        if (value.size() == 0)
+        {
+            //can we cast to number?
+            try{return ptree_to_pmc(value, typeid(long));}
+            catch(...){}
+            //TODO complex
+            //then string
+            return ptree_to_pmc(value, typeid(std::string));
+        }
+        //array
+        else
+        {
+            //TODO more if statements - w/ define
+            return ptree_to_pmc(value, typeid(std::vector<long>));
+        }
+    }
+
+    #define ptree_to_pmc_try(type) \
+    if (hint == typeid(type)) return PMC_M(value.get_value<type>());
+
+    //determine number
+    ptree_to_pmc_try(char);
+    ptree_to_pmc_try(signed char);
+    ptree_to_pmc_try(unsigned char);
+    ptree_to_pmc_try(signed short);
+    ptree_to_pmc_try(unsigned short);
+    ptree_to_pmc_try(signed int);
+    ptree_to_pmc_try(unsigned int);
+    ptree_to_pmc_try(signed long);
+    ptree_to_pmc_try(unsigned long);
+    ptree_to_pmc_try(signed long long);
+    ptree_to_pmc_try(unsigned long long);
+    //complex number TODO
+
+    //string
+    ptree_to_pmc_try(std::string);
+
+    //determine number vector
+    std::vector<long> vec;
+    BOOST_FOREACH(const ptree::value_type &elem, value)
+    {
+        vec.push_back(elem.second.get_value<long>());
+        VAR(vec.back());
+    }
+    return PMC_M(vec);
+
+    //otherwise null -- will crap out
+    return PMC();
+}
+
+ptree pmc_to_ptree(const PMCC &value)
+{
+    ptree v;
+    #define pmc_to_ptree_try(type) \
+    if (value.is<type>()) {v.put_value(value.as<type>()); return v;}
+
+    //determine number
+    pmc_to_ptree_try(char);
+    pmc_to_ptree_try(signed char);
+    pmc_to_ptree_try(unsigned char);
+    pmc_to_ptree_try(signed short);
+    pmc_to_ptree_try(unsigned short);
+    pmc_to_ptree_try(signed int);
+    pmc_to_ptree_try(unsigned int);
+    pmc_to_ptree_try(signed long);
+    pmc_to_ptree_try(unsigned long);
+    pmc_to_ptree_try(signed long long);
+    pmc_to_ptree_try(unsigned long long);
+
+    //determine string
+    pmc_to_ptree_try(std::string);
+
+    //try numeric vector
+            //TODO more if statements - w/ define
+    if (value.is<std::vector<long> >())
+    {
+        BOOST_FOREACH(const long &elem, value.as<std::vector<long> >())
+        {
+            
+        }
+    }
+
+    return v;
+}
diff --git a/lib/top_block_query.cpp b/lib/top_block_query.cpp
index 205f965..8a9261c 100644
--- a/lib/top_block_query.cpp
+++ b/lib/top_block_query.cpp
@@ -70,7 +70,7 @@ static ptree query_stats(ElementImpl *self, const ptree &query)
     {
         BOOST_FOREACH(const ptree::value_type &v, query.get_child("blocks"))
         {
-            block_ids.push_back(v.second.get<std::string>(""));
+            block_ids.push_back(v.second.get_value<std::string>());
         }
     }
 
@@ -160,65 +160,8 @@ static ptree query_stats(ElementImpl *self, const ptree &query)
     return root;
 }
 
-static PMCC ptree_to_pmc(const ptree &value, const std::type_info &info)
-{
-    //if the type is PMCC - educated guess and recursively call
-    if (info == typeid(PMCC) or info == typeid(PMC))
-    {
-        //single child or array?
-        //can we cast to number?
-        //TODO be lazy and do number for initial tests
-        return ptree_to_pmc(value, typeid(long));
-    }
-
-    #define ptree_to_pmc_try(type) \
-    if (info == typeid(type)) return PMC_M(value.get_value<type>());
-
-    //determine number
-    ptree_to_pmc_try(char);
-    ptree_to_pmc_try(signed char);
-    ptree_to_pmc_try(unsigned char);
-    ptree_to_pmc_try(signed short);
-    ptree_to_pmc_try(unsigned short);
-    ptree_to_pmc_try(signed int);
-    ptree_to_pmc_try(unsigned int);
-    ptree_to_pmc_try(signed long);
-    ptree_to_pmc_try(unsigned long);
-    ptree_to_pmc_try(signed long long);
-    ptree_to_pmc_try(unsigned long long);
-    //complex number
-    //string
-    ptree_to_pmc_try(std::string);
-    //determine number vector
-
-    //otherwise null -- will crap out
-    return PMC();
-}
-
-static ptree pmc_to_ptree(const PMCC &value)
-{
-    ptree v;
-    #define pmc_to_ptree_try(type) \
-    if (value.is<type>()) {v.put_value(value.as<type>()); return v;}
-
-    //determine number
-    pmc_to_ptree_try(char);
-    pmc_to_ptree_try(signed char);
-    pmc_to_ptree_try(unsigned char);
-    pmc_to_ptree_try(signed short);
-    pmc_to_ptree_try(unsigned short);
-    pmc_to_ptree_try(signed int);
-    pmc_to_ptree_try(unsigned int);
-    pmc_to_ptree_try(signed long);
-    pmc_to_ptree_try(unsigned long);
-    pmc_to_ptree_try(signed long long);
-    pmc_to_ptree_try(unsigned long long);
-
-    //determine string
-    pmc_to_ptree_try(std::string);
-
-    return v;
-}
+PMCC ptree_to_pmc(const ptree &value, const std::type_info &hint);
+ptree pmc_to_ptree(const PMCC &value);
 
 static ptree query_props(ElementImpl *self, const ptree &query)
 {
diff --git a/tests/query_test.py b/tests/query_test.py
index a61d4db..039888c 100644
--- a/tests/query_test.py
+++ b/tests/query_test.py
@@ -8,23 +8,32 @@ from demo_blocks import *
 class MyBlock(gras.Block):
     def __init__(self):
         gras.Block.__init__(self, "MyBlock", out_sig=[numpy.uint32], in_sig=[numpy.uint32])
-        self.foo = 0
-        self.register_getter("foo", self.get_foo)
-        self.register_setter("foo", self.set_foo)
+        self.integer_value = 0
+        self.register_getter("integer_value", self.get_integer_value)
+        self.register_setter("integer_value", self.set_integer_value)
+        self.vector_value = [0]
+        self.register_getter("vector_value", self.get_vector_value)
+        self.register_setter("vector_value", self.set_vector_value)
 
     def work(self, ins, outs):
         n = min(len(ins[0]), len(outs[0]))
-        outs[0][:n] = ins[0][:n] + self.foo
+        outs[0][:n] = ins[0][:n] + self.integer_value
         self.consume(n)
         self.produce(n)
 
-    def get_foo(self):
-        return self.foo
+    def get_integer_value(self):
+        return self.integer_value
 
-    def set_foo(self, new_foo):
-        print "new_foo", new_foo
-        new_foo + 0 #throws if its not a number
-        self.foo = new_foo
+    def set_integer_value(self, new_integer_value):
+        print "new_integer_value", new_integer_value
+        self.integer_value = new_integer_value
+
+    def get_vector_value(self):
+        return self.vector_value
+
+    def set_vector_value(self, new_vector_value):
+        print "new_vector_value", new_vector_value
+        self.vector_value = numpy.copy(new_vector_value)
 
 class QueryTest(unittest.TestCase):
 
@@ -61,38 +70,57 @@ class QueryTest(unittest.TestCase):
         #found the block we asked for
         self.assertTrue(block_id in stats_result['blocks'])
 
-    def test_props(self):
+    def test_integer_query(self):
         vec_source = VectorSource(numpy.uint32, [0, 9, 8, 7, 6])
         vec_sink = VectorSink(numpy.uint32)
         block = MyBlock()
-        block.set_uid("my_block_uid")
+        block.set_uid("test_integer_query")
         self.tb.connect(vec_source, block, vec_sink)
         self.tb.run()
 
         #query the block list
         blocks_result = self.tb.query(dict(path="/blocks.json"))
         self.assertEqual(len(blocks_result['blocks']), 3)
-        self.assertTrue('my_block_uid' in blocks_result['blocks'])
+        self.assertTrue('test_integer_query' in blocks_result['blocks'])
 
-        #set the property
+        #set the integer property
         self.tb.query(dict(
             path="/props.json",
-            block='my_block_uid',
-            key='foo',
+            block='test_integer_query',
+            key='integer_value',
             action='set',
             value=42,
         ))
-        self.assertEqual(block.foo, 42)
+        self.assertEqual(block.integer_value, 42)
 
-        #get the property
-        block.set('foo', 21)
+        #get the integer property
+        block.set('integer_value', 21)
         result = self.tb.query(dict(
             path="/props.json",
-            block='my_block_uid',
-            key='foo',
+            block='test_integer_query',
+            key='integer_value',
             action='get'
         ))
         self.assertEqual(result['value'], 21)
 
+    def test_vector_query(self):
+        vec_source = VectorSource(numpy.uint32, [0, 9, 8, 7, 6])
+        vec_sink = VectorSink(numpy.uint32)
+        block = MyBlock()
+        block.set_uid("test_vector_query")
+        self.tb.connect(vec_source, block, vec_sink)
+        self.tb.run()
+
+        #set the vector property
+        self.tb.query(dict(
+            path="/props.json",
+            block='test_vector_query',
+            key='vector_value',
+            action='set',
+            value=[1, 2, 3, 4, 5],
+        ))
+        print block.vector_value
+        self.assertEqual(list(block.vector_value), [1, 2, 3, 4, 5])
+
 if __name__ == '__main__':
     unittest.main()