s11n-cvs Mailing List for s11n: easy object serialization in C++ (Page 3)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Revision: 270
          http://s11n.svn.sourceforge.net/s11n/?rev=270&view=rev
Author:   sgbeal
Date:     2009-04-13 18:56:42 +0000 (Mon, 13 Apr 2009)

Log Message:
-----------
Added experimental s11n::node_query class.

Modified Paths:
--------------
    trunk/src/client/sample/experimental.cpp
    trunk/src/s11n/Makefile

Added Paths:
-----------
    trunk/src/s11n/s11n_node_query.hpp

Modified: trunk/src/client/sample/experimental.cpp
===================================================================

--- trunk/src/client/sample/experimental.cpp	2009-04-13 18:55:33 UTC (rev 269)
+++ trunk/src/client/sample/experimental.cpp	2009-04-13 18:56:42 UTC (rev 270)
@@ -27,12 +27,16 @@
 #include <s11n.net/s11n/proxy/pod/string.hpp>
 #include <s11n.net/s11n/proxy/std/vector.hpp>
 
+#if 0
 #define S11N_MAP_TYPE_PROXY ::s11n::map::serialize_streamable_map_f
 #define S11N_MAP_TYPE_DESER_PROXY ::s11n::map::deserialize_streamable_map_f
 #include <s11n.net/s11n/proxy/std/map.hpp>
 // ^^^^ those #defines are consumed and undefined by the map reg supermacro
+#else
+#include <s11n.net/s11n/proxy/std/map.hpp>
+#include <s11n.net/s11n/proxy/std/list.hpp>
+#endif
 
-
 ////////////////////////////////////////////////////////////////////////
 // misc util stuff
 #include <s11n.net/s11n/s11n_debuggering_macros.hpp> // CERR
@@ -906,6 +910,91 @@
     bindata_deser::deallocate( debin );
 }
 
+#include <s11n.net/s11n/s11n_node_query.hpp>
+void do_query()
+{
+#if 1
+    using namespace s11nlite;
+    typedef s11nlite::node_type NT;
+    typedef s11nlite::node_traits NTR;
+    
+    NT n;
+
+    typedef std::list<double> ListT;
+    typedef std::map<int,ListT> MapT;
+
+    MapT map;
+    for( int i = 0; i < 3; ++i )
+    {
+        ListT & l = map['a'+i];
+        for( int x = 0; x < 3; ++x )
+        {
+            l.push_back( x * i );
+        }
+    }
+    s11nlite::serialize( n, map );
+    s11nlite::save( n, std::cout );
+    typedef s11n::node_query<NT> QT;
+    QT q(&n);
+
+#if 0
+    q = q.copy()
+        .children()
+        .where( s11n::nq_name_is("pair") )
+        .children()
+        .where( s11n::nq_name_is("first") )
+        //.where( s11n::nq_has_prop("second") )
+        ;
+#else
+    q.children()
+        .where( s11n::nq_name_is("pair") )
+        .children()
+        .where( s11n::nq_name_is("first") )
+        //.where( s11n::nq_has_prop("second") )
+        ;
+
+#endif
+    QT q2 = QT(&n)
+        .children()
+        .where( s11n::nq_name_is("pair") )
+        .children()
+        //.where( s11n::nq_not( s11n::nq_name_is("first") ) )
+        //.where( s11n::nq_name_is("second") )
+        //.where( s11n::nq_class_name_is("list" ) )
+        //.where( s11n::nq_class_name_is( (ListT const *)0 ) )
+        //.where( s11n::nq_class_name_is::class_name<ListT>() )
+        .where( s11n::nq_or(
+                            //s11n::nq_class_name_is::class_name<ListT>(),
+                            s11n::nq_name_is("second"),
+                            s11n::nq_class_name_is::class_name<int>()
+                            ) )
+        //.copy()
+        //.children()
+        .append(q)
+        //.sort()
+        //.where( s11n::nq_has_prop("v") )
+        ;
+    //q.intersect( q2 );
+    q.onion( q2 );
+    //q.append( q2 )
+    //q = q2;
+    //q.sort();
+    q.unique();
+    QT::iterator it = q.results().begin();
+    QT::iterator et = q.results().end();
+    size_t count = 1;
+    COUT << "Matches:\n";
+    for( ; et != it; ++it, ++count )
+    {
+        NT const * N = *it;
+        COUT << "matching node #"<<count
+             << ": @"<< N
+             <<": " << NTR::name(*N)
+             << ':'<<NTR::class_name(*N)<< '\n';
+    }
+#endif
+}
+
 int
 main( int argc, char **argv )
 {
@@ -914,12 +1003,13 @@
         s11nlite::serializer_class( "parens" );
 	try
 	{
-	    if(1) and_yet_MORE_TESTS();
+	    if(0) and_yet_MORE_TESTS();
 	    if(0) do_some_tests();
 	    if(0) do_some_more_tests();
 	    if(0) do_even_more_tests();
 	    if(0) do_version();
-	    if(1) do_bindata();
+	    if(0) do_bindata();
+	    if(1) do_query();
 	}
 	catch( const std::exception & ex )
 	{

Modified: trunk/src/s11n/Makefile
===================================================================
--- trunk/src/s11n/Makefile	2009-04-13 18:55:33 UTC (rev 269)
+++ trunk/src/s11n/Makefile	2009-04-13 18:56:42 UTC (rev 270)
@@ -37,6 +37,7 @@
 	s11n_debuggering_macros.hpp \
 	s11n.hpp \
 	s11n_node.hpp \
+	s11n_node_query.hpp \
 	serialize.hpp \
 	serialize.tpp \
 	tags.hpp \

Added: trunk/src/s11n/s11n_node_query.hpp
===================================================================
--- trunk/src/s11n/s11n_node_query.hpp	                        (rev 0)
+++ trunk/src/s11n/s11n_node_query.hpp	2009-04-13 18:56:42 UTC (rev 270)
@@ -0,0 +1,481 @@
+#ifndef s11n_S11N_NODE_QUERY_HPP_INCLUDED
+#define s11n_S11N_NODE_QUERY_HPP_INCLUDED
+
+////////////////////////////////////////////////////////////////////////
+// s11n_node_query.hpp
+// Experimental. Don't use.
+//
+// License: Public Domain
+// Author: st...@s1...
+////////////////////////////////////////////////////////////////////////
+#include <string>
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <iterator>
+#include <s11n.net/s11n/export.hpp>
+#include <s11n.net/s11n/exception.hpp>
+#include <s11n.net/s11n/s11n_node.hpp>
+#include <s11n.net/s11n/traits.hpp>
+
+namespace s11n {
+
+    /**
+       EXPERIMENTAL - do not use!
+
+       This class is for fetching s11n nodes matching certain
+       criteria. It is somewhat like using an SQL query builder, but
+       is much more limited in what it can do.
+
+       Notable limitations:
+
+       - Can only work on const nodes. It would seem to be impossible
+       to consolidate const- and non-const nodes in one API here,
+       partly because of the "inherited" constness of child nodes.
+
+       - It does a lot of list copying, and it is conceivable that it
+       may use quite a lot of memory. We could use reference counting
+       of the internal result sets to reduce this, and may do so if
+       this class gets any appreciable use.
+
+
+       Added in versions 1.3.2/1.2.10.
+    */
+    template <typename NodeType>
+    class node_query
+    {
+    public:
+        /** The templatized S11nNode type. */
+        typedef NodeType node_t; 
+        /**
+           s11n node traits type.
+        */
+        typedef node_traits<NodeType> traits;
+
+        /**
+           We cannot re-use traits::child_list_type here b/c we can
+           only work with const NodeType objects from here.
+           Additionally, some list operations require sorted lists and
+           the associated standard routines require random-access
+           iterators.
+        */
+        typedef std::vector<NodeType const *> node_list;
+
+        /** Internal convenience typedef. */
+        typedef std::less<NodeType const *> compare_func;
+
+        /**
+           Result set iterator type.
+        */
+        typedef typename node_list::const_iterator iterator;
+
+        /**
+           Creates a new query object which uses src for its
+           searching. If src is null then it acts like the no-arg
+           ctor.
+        */
+        explicit node_query( node_t const * src )
+            : m_li()
+        {
+            if( src ) m_li.push_back(src);
+        }
+
+        /**
+           Creates an empty query object, useful only as the target
+           of assignment.
+        */
+        node_query()
+            : m_li()
+        {
+        }
+
+        /**
+           The current result list.
+        */
+        node_list const & results() const { return m_li; }
+
+        /**
+           The current result list. This non-const form
+           can be used by non-member algorithms to
+           manipulate a result set.
+        */
+        node_list & results() { return m_li; }
+
+        /**
+           Modifies this result set in place to contain all results()
+           items for which clause(item) returns true.
+        */
+        template <typename Ftor>
+        node_query & where( Ftor clause )
+        {
+            node_query res;
+            iterator it( m_li.begin() );
+            typename node_list::const_iterator et( m_li.end() );
+            for( ; et != it; ++it )
+            {
+                if( clause( *it ) )
+                {
+                    res.results().push_back(*it);
+                }
+            }
+            m_li.swap( res.m_li );
+            return *this;
+        }
+
+        template <typename Ftor>
+        node_query where( Ftor clause ) const
+        {
+            node_query res;
+            iterator it( m_li.begin() );
+            typename node_list::const_iterator et( m_li.end() );
+            for( ; et != it; ++it )
+            {
+                if( clause( *it ) )
+                {
+                    res.results().push_back(*it);
+                }
+            }
+            return res;
+        }
+
+        /**
+           Modifies this result set in place to contain all child
+           nodes of all items in in the current result set.
+        */
+        node_query & children()
+        {
+            node_query res;
+            iterator it( m_li.begin() );
+            iterator et( m_li.end() );
+            node_list & rli( res.results() );
+            typedef typename traits::child_list_type NCL;
+            for( ; et != it; ++it )
+            {
+                node_t const * n = *it; 
+                NCL const & childs( traits::children( *n ) );
+                typename NCL::const_iterator cit( childs.begin() );
+                typename NCL::const_iterator cet( childs.end() );
+                for( ; cit != cet; ++cit )
+                {
+                    rli.push_back(*cit);
+                }
+            }
+            m_li.swap( res.m_li );
+            return *this;
+        }
+
+        /**
+           Creates returns a copy of this object. This may be useful
+           in certain call-chaining contexts where we don't want to
+           edit a given query object in-place.
+        */
+        node_query copy() const
+        {
+            return *this;
+        }
+
+        /**
+           Assigns this object's results to be those from rhs. This
+           may be useful in certain complex call-chaining contexts.
+        */
+        node_query & assign( node_query const & rhs )
+        {
+            if( this != &rhs ) *this = rhs;
+            return *this;
+        }
+
+        /**
+           Appends rhs.results() to the end of this result set.
+        */
+        node_query & append( node_query const & rhs )
+        {
+            std::copy( rhs.m_li.begin(), rhs.m_li.end(),
+                       std::back_inserter( this->m_li )
+                       );
+            return *this;
+        }
+
+        /**
+           Sorts results() in-place using the given comparison
+           operator, which must follow the conventions required by
+           std::sort().
+        */
+        template <typename Compare>
+        node_query & sort( Compare cmp )
+        {
+            std::sort( this->m_li.begin(), this->m_li.end(), cmp );
+            return *this;
+        }
+
+        /**
+           Sorts results() in-place using the default comparison
+           algorithm (which simply compares nodes by their pointer
+           values).
+        */
+        node_query & sort()
+        {
+             return this->sort( compare_func() );
+        }
+
+        /**
+           Sorts this list in-place and removes any duplicate
+           entries. See sort() for the requirements of the Compare
+           functor.
+        */
+        template <typename Compare>
+        node_query & unique( Compare cmp )
+        {
+            this->sort( cmp );
+            typedef typename node_list::iterator IT;
+            IT it = std::unique( this->m_li.begin(), this->m_li.end() );
+            if( m_li.end() != it ) m_li.erase( it, m_li.end() );
+            return *this;
+        }
+
+        /**
+           Equivalent to unique(compre_func()).
+        */
+        node_query & unique()
+        {
+            return this->unique( compare_func() );
+        }
+
+
+        /**
+           Modifies this result set to include only items which are
+           both in this set and in rhs, using cmp to do the comparison
+           (which must conform to the requirements of std::sort()
+           comparison functions). This set gets sorted as a
+           side-effect.
+        */
+        template <typename CompFunc>
+        node_query & intersect( node_query const & rhs, CompFunc cmp )
+        {
+            if( &rhs == this ) return *this;
+            node_list l1( this->m_li );
+            this->m_li.clear();
+            std::sort( l1.begin(), l1.end(), cmp );
+            node_list l2( rhs.m_li );
+            std::sort( l2.begin(), l2.end(), cmp );
+            std::set_intersection( l1.begin(), l1.end(),
+                                   l2.begin(), l2.end(),
+                                   std::back_inserter( this->m_li ),
+                                   cmp );
+            return *this;
+        }
+
+        /**
+           Equivalent to intersect( rhs, compare_func() ).
+        */
+        node_query & intersect( node_query const & rhs )
+        {
+            return this->intersect( rhs, compare_func() );
+        }
+
+        /**
+           Modifies this result set to include any items which are
+           either in this set or rhs (a union). It uses cmp to do the
+           comparison (which must conform to the requirements of
+           std::sort() comparison functions). This set gets sorted as
+           a side-effect.
+
+           The result set may have duplicate entries.
+
+           It is called onion() instead of union() because union()
+           is a reserved word in C++.
+        */
+        template <typename CompFunc>
+        node_query & onion( node_query const & rhs, CompFunc cmp )
+        {
+            if( &rhs == this ) return *this;
+            node_list l1( this->m_li );
+            this->m_li.clear();
+            std::sort( l1.begin(), l1.end(), cmp );
+            node_list l2( rhs.m_li );
+            std::sort( l2.begin(), l2.end(), cmp );
+            std::set_union( l1.begin(), l1.end(),
+                            l2.begin(), l2.end(),
+                            std::back_inserter( this->m_li ),
+                            cmp );
+            return *this;
+        }
+
+        /**
+           Equivalent to union(rhs,compare_func()).
+        */
+        node_query & onion( node_query const & rhs )
+        {
+            return this->onion( rhs, compare_func() );
+        }
+
+    private:
+        /** Result set. */
+        node_list m_li;
+    };
+
+    /**
+       A Concept class which exists only to document the query
+       interface required by node_query.
+    */
+    struct nq_concept
+    {
+        /**
+           Must determine whether n conforms to specific criteria
+           and return true on success, else false.
+        */
+        template <typename NodeType>
+        bool operator()( NodeType const * n ) const;
+    };
+
+    /**
+       An nq_concept implementation for querying nodes
+       which have a specific node name.
+    */
+    struct nq_name_is
+    {
+        std::string name;
+        explicit nq_name_is( std::string const & n ) :name(n)
+        {}
+        template <typename NodeType>
+        bool operator()( NodeType const * n ) const
+        {
+            typedef node_traits<NodeType> NTR;
+            return n
+                ? (this->name == NTR::name(*n))
+                : false;
+        }
+    };
+
+    /**
+       An nq_concept implementation for querying nodes
+       which have a specific property.
+    */
+    struct nq_has_prop
+    {
+        std::string key;
+        explicit nq_has_prop( std::string const & n ) : key(n)
+        {}
+        template <typename NodeType>
+        bool operator()( NodeType const * n ) const
+        {
+            typedef node_traits<NodeType> NTR;
+            return n
+                ? (NTR::is_set( *n, this->key ))
+                : false;
+        }
+    };
+
+    /**
+       An nq_concept implementation for querying nodes
+       which have a specific s11n class name.
+    */
+    struct nq_class_name_is
+    {
+        std::string name;
+        explicit nq_class_name_is( std::string const & n ) :name(n)
+        {}
+#if 0 // awkward to use
+        template <typename SerT>
+        nq_class_name_is( SerT const * ) : name(s11n_traits<SerT>::class_name(0))
+        {
+        }
+#endif
+        template <typename NodeType>
+        bool operator()( NodeType const * n ) const
+        {
+            typedef node_traits<NodeType> NTR;
+            return n
+                ? (this->name == NTR::class_name(*n))
+                : false;
+        }
+
+        /**
+           Convenience routine. It is 
+        */
+        template <typename SerT>
+        static nq_class_name_is class_name()
+        {
+            return nq_class_name_is( s11n_traits<SerT>::class_name(0) );
+        }
+    };
+
+
+    /**
+       Negates another node query functor. Ftor must conform to
+    */
+    template <typename Ftor>
+    struct nq_negate_ftor
+    {
+        Ftor func;
+        nq_negate_ftor( Ftor f ) : func(f)
+        {}
+        template <typename NodeType>
+        bool operator()( NodeType const * n ) const
+        {
+            typedef node_traits<NodeType> NTR;
+            //if( ! n ) throw s11n_exception( S11N_SOURCEINFO, "ng_negate_ftor cannot sensibly react to null nodes!");
+            return !func(n);
+        }
+    };
+
+    /**
+       Convenience routine to create an ng_negate_ftor object.
+    */
+    template <typename Ftor>
+    nq_negate_ftor<Ftor> nq_not( Ftor f )
+    {
+        typedef nq_negate_ftor<Ftor> x;
+        return x(f);
+    }
+
+    /**
+       A node_query search functor which performs a logical
+       OR or AND of two nc_concept-compatible functors.
+    */
+    template <typename Ftor1,typename Ftor2,bool IsAnd>
+    struct nq_andor_ftor
+    {
+        Ftor1 func1;
+        Ftor2 func2;
+        nq_andor_ftor( Ftor1 f, Ftor2 f2 ) : func1(f),func2(f2)
+        {}
+        /**
+           If IsAnd then returns (func1(n) && func2(n))
+           else it returns (func1(n) || func2(n)).
+        */
+        template <typename NodeType>
+        bool operator()( NodeType const * n ) const
+        {
+            return IsAnd
+                ? (func1(n) && func2(n))
+                : (func1(n) || func2(n));
+        }
+    };
+
+    /**
+       Convenience function to return a functor for performing
+       OR-style searches on node_query objects.
+    */
+    template <typename Ftor1, typename Ftor2>
+    nq_andor_ftor<Ftor1,Ftor2,false> nq_or( Ftor1 f, Ftor2 f2 )
+    {
+        typedef nq_andor_ftor<Ftor1,Ftor2,false> x;
+        return x(f,f2);
+    }
+
+
+    /**
+       Convenience function to return a functor for performing
+       AND-style searches on node_query objects.
+    */
+    template <typename Ftor1, typename Ftor2>
+    nq_andor_ftor<Ftor1,Ftor2,true> nq_and( Ftor1 f, Ftor2 f2 )
+    {
+        typedef nq_andor_ftor<Ftor1,Ftor2,true> x;
+        return x(f,f2);
+    }
+
+} // namespace s11n
+
+#endif // s11n_S11N_NODE_QUERY_HPP_INCLUDED


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2004	Jan	Feb	Mar (95)	Apr (43)	May (47)	Jun (81)	Jul (33)	Aug (241)	Sep (121)	Oct (65)	Nov (32)	Dec (77)
2005	Jan (2)	Feb (28)	Mar (95)	Apr (1)	May (38)	Jun (112)	Jul (89)	Aug (23)	Sep (28)	Oct (7)	Nov (66)	Dec (112)
2006	Jan (1)	Feb (2)	Mar (64)	Apr	May (9)	Jun (5)	Jul (2)	Aug (16)	Sep (20)	Oct	Nov	Dec (9)
2007	Jan (41)	Feb (227)	Mar (12)	Apr (3)	May (3)	Jun (63)	Jul (14)	Aug (1)	Sep (3)	Oct (9)	Nov	Dec
2008	Jan (8)	Feb	Mar	Apr (42)	May (65)	Jun (20)	Jul	Aug (16)	Sep (6)	Oct (8)	Nov (38)	Dec
2009	Jan	Feb (18)	Mar (1)	Apr (4)	May	Jun (7)	Jul (6)	Aug	Sep	Oct	Nov (10)	Dec (1)
2010	Jan	Feb	Mar (5)	Apr (8)	May (3)	Jun (5)	Jul	Aug	Sep	Oct	Nov	Dec (2)
2011	Jan	Feb	Mar	Apr	May	Jun	Jul (1)	Aug	Sep (1)	Oct	Nov	Dec
2012	Jan	Feb (1)	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

s11n-cvs Mailing List for s11n: easy object serialization in C++ (Page 3)

s11n-cvs — automated mails from cvs (high traffic)