Minimal implementaion - still lots to do but getting there.

Author: tedmiddleton

mainframe/expression.hpp

@@ -132,27 +132,30 @@ struct is_expression<T &, void>
 {};
 
 template< typename T >
-struct expr_column
+struct column_name
 {
-    expr_column() 
+    column_name() 
         : m_colnum( std::numeric_limits<decltype(m_colnum)>::max )
     {
     }
 
-    bool bind_column( const std::string& name, size_t num )
+    void set_column_name( size_t col, std::string name )
     {
-        if ( m_name == name ) {
-            m_colnum = num;
-            return true;
+        if ( name == m_name ) {
+            m_colnum = col;
         }
-        return false;
     }
 
     template< typename ... Ts >
     const T& get_value( const frame_iterator< Ts... >& fi ) const
     {
-        T& val = fi.template get<m_colnum>();
-        return val;
+        return fi.get( m_colnum );
+    }
+
+    template< typename ... Ts >
+    T& get_value( frame_iterator< Ts... >& fi ) const
+    {
+        return fi.get( m_colnum );
     }
 
     std::string m_name;
@@ -167,13 +170,18 @@ struct terminal
 
     terminal( T _t ) : t( _t ) {}
 
-    bool bind_column( const std::string&, size_t )
+    void set_column_name( size_t, std::string )
+    {
+    }
+
+    template< typename ... Ts >
+    const T& get_value( const frame_iterator<Ts...>& )
     {
-        return false;
+        return t;
     }
 
     template< typename ... Ts >
-    const T& get_value( const frame_iterator< Ts... >& ) const
+    T& get_value( const frame_iterator<Ts...>& )
     {
         return t;
     }
@@ -182,16 +190,16 @@ struct terminal
 };
 
 template< typename T >
-struct terminal< expr_column<T> >
+struct terminal< column_name<T> >
 {
     using is_expr = void;
     using return_type = T;
 
-    terminal( expr_column<T> _t ) : t( _t ) {}
+    terminal( column_name<T> _t ) : t( _t ) {}
 
-    bool bind_column( const std::string& name, size_t num )
+    void set_column_name( size_t colind, std::string colname )
     {
-        return t.bind_column( name, num );
+        t.set_column_name( colind, colname );
     }
 
     template< typename ... Ts >
@@ -200,29 +208,40 @@ struct terminal< expr_column<T> >
         return t.get_value( fi );
     }
 
-    expr_column<T> t;
+    template< typename ... Ts >
+    T& get_value( frame_iterator< Ts... >& fi )
+    {
+        return t.get_value( fi );
+    }
+
+    column_name<T> t;
 };
 
-template< template <typename, typename> typename Op, typename L, typename R >
+template< template <typename, typename> class Op, typename L, typename R >
 struct binary_expr
 {
     using is_expr = void;
     using op = Op<typename L::return_type, typename R::return_type>;
     using return_type = typename op::return_type;
-    static_assert( is_expression<L>::value );
-    static_assert( is_expression<R>::value );
+    static_assert( is_expression<L>::value , "binary expression left must be expression" );
+    static_assert( is_expression<R>::value , "binary expression right must be expression" );
 
     binary_expr( L _l, R _r ) : l( _l ), r( _r ) {}
 
-    bool bind_column( const std::string& name, size_t num )
+    void set_column_name( size_t colind, std::string colname )
     {
-        auto lb = l.bind_column( name, num );
-        auto rb = r.bind_column( name, num );
-        return lb || rb;
+        l.set_column_name( colind, colname );
+        r.set_column_name( colind, colname );
     }
 
     template< typename ... Ts >
-    return_type get_value( const frame_iterator< Ts... >& fi ) const
+    const return_type& get_value( const frame_iterator< Ts... >& fi ) const
+    {
+        return op::exec( l.get_value( fi ), r.get_value( fi ) );
+    }
+
+    template< typename ... Ts >
+    return_type& get_value( frame_iterator< Ts... >& fi )
     {
         return op::exec( l.get_value( fi ), r.get_value( fi ) );
     }
@@ -234,23 +253,29 @@ struct binary_expr
 // Op is a member type in expr_op
 // T must be either terminal<>, unary_expr<>, or binary_expr<> (no 
 // unwrapped types - that's why make_unary_expr exists)
-template< template <typename> typename Op, typename T >
+template< template <typename> class Op, typename T >
 struct unary_expr
 {
     using is_expr = void;
     using op = Op<typename T::return_type>;
     using return_type = typename op::return_type;
-    static_assert( is_expression<T>::value );
+    static_assert( is_expression<T>::value , "unary expression must contain expression");
 
     unary_expr( T _t ) : t( _t ) {}
 
-    bool bind_column( const std::string& name, size_t num )
+    void set_column_name( size_t colind, std::string colname )
     {
-        return t.bind_expr_column( name, num );
+        t.set_column_name( colind, colname );
     }
 
     template< typename ... Ts >
-    return_type get_value( const frame_iterator< Ts... >& fi ) const
+    const return_type& get_value( const frame_iterator< Ts... >& fi ) const
+    {
+        return op::exec( t.get_value( fi ) );
+    }
+
+    template< typename ... Ts >
+    return_type& get_value( frame_iterator< Ts... >& fi )
     {
         return op::exec( t.get_value( fi ) );
     }
@@ -283,7 +308,7 @@ struct maybe_wrap<terminal<T>>
     }
 };
 
-template<template <typename> typename Op, typename T>
+template<template <typename> class Op, typename T>
 struct maybe_wrap<unary_expr<Op, T>>
 {
     maybe_wrap() = delete;
@@ -294,7 +319,7 @@ struct maybe_wrap<unary_expr<Op, T>>
     }
 };
 
-template<template <typename, typename> typename Op, typename L, typename R>
+template<template <typename, typename> class Op, typename L, typename R>
 struct maybe_wrap<binary_expr<Op, L, R>>
 {
     maybe_wrap() = delete;
@@ -305,7 +330,7 @@ struct maybe_wrap<binary_expr<Op, L, R>>
     }
 };
 
-template< template <typename> typename Op, typename T >
+template< template <typename> class Op, typename T >
 struct make_unary_expr
 {
     make_unary_expr() = delete;
@@ -318,7 +343,7 @@ struct make_unary_expr
     }
 };
 
-template< template <typename, typename> typename Op, typename L, typename R >
+template< template <typename, typename> class Op, typename L, typename R >
 struct make_binary_expr
 {
     make_binary_expr() = delete;
@@ -332,11 +357,11 @@ struct make_binary_expr
 };
 
 template< typename T >
-terminal<expr_column<T>> col( const char * colname )
+terminal<column_name<T>> col( const char * colname )
 {
-    expr_column<T> c;
+    column_name<T> c;
     c.name = colname;
-    return maybe_wrap<expr_column<T>>::wrap( c );
+    return maybe_wrap<column_name<T>>::wrap( c );
 }
 
 template< typename L, typename R >
@@ -429,10 +454,11 @@ typename std::enable_if<is_expression<T>::value, typename make_unary_expr<expr_o
     return make_unary_expr<expr_op::NOT, T>::create( t );
 }
 
-//terminal<expr_column_name> col( std::string colname )
-//{
-//    return terminal<expr_column_name>{ expr_column_name{ colname } };
-//}
+template< typename T >
+terminal< column_name<T> > col( const std::string & colname )
+{
+    return terminal< column_name<T> >{ column_name<T>{ colname } };
+}
 
 
 } // namespace mf