oinky 0.1.0

data/ext/include/oinky/nky_log.hpp

@@ -0,0 +1,15 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+namespace Oinky
+{
+namespace Internal
+{
+using namespace Oinky::Errors;
+using namespace Oinky::Utils;
+
+
+} //namespace Internal
+} //namespace Oinky

data/ext/include/oinky/nky_merge_itr.hpp

@@ -0,0 +1,403 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+namespace Oinky
+{
+namespace Utils
+{
+using namespace Oinky::Errors;
+
+//
+//  The merge iterator is bidirectional.  We need a concept of a range, where 
+//  the iterator can be valid, or at end(), or additionally, before the 
+//  beginning of the sequence.  In general, we cannot safely decrement an 
+//  iterator from begin().
+//
+
+template<typename ITR>
+class symmetric_iterator
+{
+    typedef ITR iterator;
+    
+    iterator _i;
+    iterator _begin;
+    iterator _end;
+    bool _sub_begin;
+    
+    iterator begin() const { return _begin; }
+    iterator end() const { return _end; }
+    
+public:
+    symmetric_iterator(
+        const iterator &__i,
+        const iterator &__begin,
+        const iterator &__end) :
+    _i(__i),
+        _begin(__begin),
+        _end(__end),
+        _sub_begin(false)
+    {}
+    
+    symmetric_iterator() : _sub_begin(false) {}
+        
+    //  This need not return iterator &.  It merely must return whatever
+    //  the comparer expects.
+    const iterator &i() const { return _i; }
+    
+    bool before_begin() const { return _sub_begin; }
+    bool at_end() const { return _i == _end; }
+    bool is_valid() const { return !before_begin() && !at_end(); }
+    
+    void increment() {
+        OINKY_ASSERT( _sub_begin || (_i != _end) );
+        if (_sub_begin) {
+            _sub_begin = false;
+        } else {
+            ++_i;
+        }
+    }
+    void decrement() {
+        OINKY_ASSERT( !_sub_begin );
+        if (_i == _begin) {
+            _sub_begin = true;
+        } else {
+            --_i;
+        }
+    }
+};
+
+template<typename DERIVED, typename VALUE_TYPE, typename RANGE1, typename RANGE2, typename COMPARE>
+class merge_iterator_template : public 
+    boost::iterator_facade<
+        DERIVED,
+        VALUE_TYPE,
+        boost::bidirectional_traversal_tag,
+        VALUE_TYPE 
+        >
+{
+    typedef merge_iterator_template<DERIVED,VALUE_TYPE,RANGE1,RANGE2,COMPARE> this_t;
+    typedef boost::iterator_facade<
+        DERIVED,
+        VALUE_TYPE,
+        boost::bidirectional_traversal_tag,
+        VALUE_TYPE 
+        > base_t;
+
+    friend class boost::iterator_core_access;
+
+public:
+    //  base iterators should all have good defaults.
+    merge_iterator_template() {}
+
+    merge_iterator_template(
+        const RANGE1 &_l,
+        const RANGE2 &_r) :
+    l(_l),
+        r(_r)
+    {
+        set_fwd_state();
+    }
+
+private:
+    RANGE1 l;
+    RANGE2 r;
+
+    //  -1: *this == *l
+    //  0: *this == *l, *this == *r
+    //  1: *this == *r
+    int active;
+    //  -1: *l < *r
+    //  0: *l == *r
+    //  1: *l > r
+    int lsubr;
+    
+    void set_fwd_state()
+    {
+        lsubr = 0;
+        bool compare = true;
+        if (l.before_begin()) {
+            lsubr -= 1;
+            compare = false;
+        } else if (l.at_end()) {
+            lsubr += 1;
+            compare = false;
+        }
+        if (r.before_begin()) {
+            lsubr += 1;
+            compare = false;
+        } else if (r.at_end()) {
+            lsubr -= 1;
+            compare = false;
+        }
+        if (compare) {
+            //  Compute l-r
+            COMPARE c;
+            lsubr = c(l.i(), r.i());
+        }
+        //  current position is the smaller of the two.  -1 if left
+        //  is smaller, 1 if right is smaller, 0 if equal.
+        active = lsubr;
+    }
+    void set_reverse_state()
+    {
+        set_fwd_state();
+        active = -active;
+    }
+protected:
+    void increment()
+    {
+        //  Advance the iterator.
+        COMPARE c;
+        (void) c;
+        
+        //  Left is active.
+        if (active < 0) {
+            //  If right < left, then this is a change of direction.
+            if (lsubr > 0) {
+                //  Grow right.
+                r.increment();
+                //  The invariant is that left and right are always less than
+                //  one step apart.  Stepping either toward the other changes
+                //  sign of lsubr, or makes it nonzero.
+                OINKY_ASSERT((r.at_end()) || (c(l.i(),r.i()) < 0));
+            }
+            l.increment();
+        } else if (active > 0) {
+            //  If right > left, then this is a change of direction.
+            if (lsubr < 0) {
+                //  Grow left to beyond right.
+                l.increment();
+                OINKY_ASSERT((l.at_end()) || (c(l.i(),r.i()) > 0));
+            }
+            r.increment();
+        } else {
+            //  Increment both.
+            l.increment();
+            r.increment();
+        }
+        //  Make the smallest iterator active.
+        set_fwd_state();
+    }
+    void advance(int n) {
+        while (n>0) {
+            increment();
+            --n;
+        }
+        while (n<0) {
+            decrement();
+            ++n;
+        }
+    }
+    
+    void decrement()
+    {
+        COMPARE c;
+        (void) c;
+        
+        //  Left is active.
+        if (active < 0) {
+            //  If right > left, then this is a change of direction.
+            if (lsubr < 0) {
+                //  Decrement right until it's less than left;
+                r.decrement();
+                //  Having decremented, we know r.i != r.end or r.sub_begin.
+                //  Also, if the iterators were separated by less than one 
+                //  position, then right should now be < left.
+                OINKY_ASSERT(r.before_begin() || (c(l.i(),r.i()) > 0));
+            }
+            //  Now decrement left.
+            l.decrement();
+        } else if (active > 0) {
+            //  If right < left, then this is a change of direction.
+            if (lsubr > 0) {
+                //  Decrement left until it's less than right.
+                l.decrement();
+                OINKY_ASSERT(l.before_begin() || (c(l.i(),r.i()) < 0));
+            }
+            //  Now decrement right.
+            r.decrement();
+        } else {
+            //  Decrement both.
+            l.decrement();
+            r.decrement();
+        }
+        //  Make the largest iterator active.
+        set_reverse_state();
+    }
+    
+    //  This is nontrivial, since the iterators may be traveling different 
+    //  directions.  They may thus be equal (referring to the same element)
+    //  but have one of the the component iterators being different.
+    bool equal(const this_t &other) const { return compare_to(_equal(), other); }
+
+public: 
+    const RANGE1 &left() const { return l; }
+    const RANGE2 &right() const { return r; }
+
+    //  Remember, it's possible that BOTH left and right will be simultaneously active.
+    bool left_active() const { return (active <= 0) && l.is_valid(); }
+    bool right_active() const { return (active >= 0) && r.is_valid(); }
+
+    bool at_end() const { return l.at_end() && r.at_end(); }
+    bool before_begin() const { return l.before_begin() && r.before_begin(); }
+
+    template<typename FN>
+    bool compare_to(const FN &fn, const this_t &other) const {
+        int x = compare_to(other);
+        return fn(x,0);
+    }
+    
+    int compare_to(const this_t &other) const {
+        COMPARE c;
+        
+        int stat = 
+            (left_active() ? 8 : 0) |
+            (right_active() ? 4 : 0) |
+            (other.left_active() ? 2 : 0) |
+            (other.right_active() ? 1 : 0);
+        switch (stat) {
+            case 0x0 + 0x0 :
+                //  Both at end.
+                return 0;
+            case 0x8 + 0x0:
+            case 0x4 + 0x0:
+            case 0xc + 0x0:
+                //  other at end.  This not.
+                return -1;
+            case 0x0 + 0x2:
+            case 0x0 + 0x1:
+            case 0x0 + 0x3:
+                //  this at end.  Other not.
+                return 1;
+            case 0x8 + 0x2:
+            case 0xc + 0x2:
+            case 0x8 + 0x3:
+            case 0xc + 0x3:
+                //  Left active on both.
+                return c(l.i(), other.l.i());
+            case 0x4 + 0x1:
+            case 0xc + 0x1:
+            case 0x4 + 0x3:
+            //case 0xc + 0x3:       dup
+                //  Right active on both.
+                return c(r.i(), other.r.i());
+            case 0x8 + 0x1:
+                //  This left.  Other right.
+                return c(l.i(), other.r.i());
+            case 0x4 + 0x2:
+                //  This right.  Other left.
+                return c(r.i(), other.l.i());
+        }
+        OINKY_ASSERT(false);
+        throw_error(implementation_bug());
+        return 0;
+    }
+
+/*      This is slow, and not required of bidirectional iterators, so we don't
+        implement it.
+    int distance_to(const this_t &other) const {
+        //  This works, but is not efficient, and should not be used.
+        OINKY_ASSERT(false);
+        throw_error(unsupported_operation());
+        
+        if (other < *this) {
+            return -other.distance_to(*this);
+        }
+        
+        this_t tmp = *this;
+        int count = 0;
+        while (tmp < other) {
+            ++tmp;
+            ++count;
+        }
+        return count;
+    }*/
+    
+private:    
+    struct _equal {template<typename T> bool operator()(const T&l, const T&r) const {return l == r;}};
+
+    struct _less {template<typename T> bool operator()(const T&l, const T&r) const {return l < r;}};
+    struct _gt {template<typename T> bool operator()(const T&l, const T&r) const {return l > r;}};
+    struct _leq {template<typename T> bool operator()(const T&l, const T&r) const {return l <= r;}};
+    struct _geq {template<typename T> bool operator()(const T&l, const T&r) const {return l >= r;}};
+    
+public:
+    bool operator<(const this_t &other) const {
+        return compare_to(_less(), other);
+    }
+    bool operator>(const this_t &other) const {
+        return compare_to(_gt(), other);
+    }
+    bool operator<=(const this_t &other) const {
+        return compare_to(_leq(), other);
+    }
+    bool operator>=(const this_t &other) const {
+        return compare_to(_geq(), other);
+    }
+};
+
+
+template<typename ITR1, typename ITR2, typename COMPARE>
+class merge_iterator : public merge_iterator_template<
+    merge_iterator<ITR1, ITR2, COMPARE>,
+    typename boost::iterator_value<ITR1>::type,
+    symmetric_iterator<ITR1>,
+    symmetric_iterator<ITR2>,
+    COMPARE
+    >
+{
+    typedef symmetric_iterator<ITR1> range1_t;
+    typedef symmetric_iterator<ITR2> range2_t;
+
+    typedef merge_iterator_template<
+        merge_iterator<ITR1, ITR2, COMPARE>,
+        typename boost::iterator_value<ITR1>::type,
+        range1_t,
+        range2_t,
+        COMPARE
+        > base_t;
+public:
+    merge_iterator() {}
+    
+    merge_iterator(
+        const range1_t &_l,
+        const range2_t &_r) :
+    base_t(_l,_r)
+    {}
+
+    merge_iterator(
+        const ITR1 &_li, const ITR1 &_lb, const ITR1 &_le,
+        const ITR2 &_ri, const ITR2 &_rb, const ITR2 &_re) :
+    base_t(range1_t(_li, _lb, _le),range2_t(_ri, _rb, _re))
+    {}
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        typename boost::iterator_value<ITR1>::type,
+        typename boost::iterator_value<ITR2>::type>::value));
+        
+    typedef typename boost::iterator_value<ITR1>::type value_type;
+
+    const ITR1 &left() const { return base_t::left().i(); }
+    const ITR2 &right() const { return base_t::right().i(); }
+
+private:
+    value_type dereference() const {
+        if (base_t::left_active()) {
+            return *left();
+        } else if (base_t::right_active()) {
+            return *right();
+        }
+        
+        //  Dereferencing an iterator at the end.
+        OINKY_ASSERT(false);
+        return value_type();
+    }
+
+    friend class boost::iterator_core_access;
+};
+
+} //namespace Utils
+} //namespace Oinky
+

data/ext/include/oinky/nky_model.hpp

@@ -0,0 +1,110 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+//  These are some support classes for the code generated by the model compiler,
+//  which is still experimental.
+//
+//  Everything in this file is subject to change.
+
+namespace Oinky
+{
+namespace Model
+{
+    typedef db_t::column_selector_t column_selector_t;
+    typedef db_t::index_handle index_handle;
+    typedef db_t::table_handle table_handle;
+
+class TableBase
+{
+public:
+    static void create_column_if(
+        table_handle &th, 
+        const char *colname, 
+        column_type_code_t coltype, 
+        const variant_cv_t &default_value) 
+    {
+        db_t::column_itr i = th.columns().find(colname);
+        if (i == th.columns().end()) {
+            i = th.columns().create(colname, coltype, default_value);
+        }
+    }
+
+    static void create_index_if(
+        table_handle &th, 
+        const db_string &ixname,
+        bool is_unique,
+        const index_column_def *cols_begin, 
+        const index_column_def *cols_end) 
+    {
+        db_t::index_itr i = th.indices().find(ixname);
+        if (i == th.indices().end()) {
+            i = th.indices().create(ixname, is_unique ? Oinky::Unique : Oinky::NonUnique, cols_begin, cols_end);
+        }
+    }
+
+    static index_handle get_index_handle(table_handle &th, const char *indexname) {
+        return th.indices()[indexname];
+    }
+
+protected:
+    table_handle th;
+    db_t &__db;
+
+public:
+    db_t &db() const { return __db; }
+    
+    void check_init_row_accessor(column_selector_t &cs, const char **cn_begin, const char **cn_end)
+    {
+        //  Column count will be zero if we haven't initialized yet.  But
+        //  we must also account for the fact that selectors are invalidated
+        //  by schema changes to the table.
+        if ((cs.column_count() == 0) || 
+            (th.last_colset_change() != cs.last_colset_change())) 
+        {
+            //  This will raise an exception if one of our columns has been
+            //  deleted since we mounted.
+            cs = th.make_selector(cn_begin, cn_end);
+        }
+    }
+    
+    TableBase(const table_handle &_th, db_t &_db) : th(_th), __db(_db)
+    {}
+};
+
+class SchemaBase
+{
+    db_t &db;
+    
+public:
+    static table_handle get_table_handle(db_t &db, const char *tablename) {
+        return *db.tables().create_if(tablename).first;
+    }
+
+    //  Variable part of table-schema update.  We invoke the callback when we 
+    //  detect something wrong, which is a defensive tactic.
+    typedef void (*schema_cb_fn)(db_t &db);
+    
+protected:
+    void up_schema(schema_cb_fn schema_cb)
+    {
+        //  Ensure the schema migration is atomic.
+        sp_marker_t lkg = db.new_sp();
+        try {
+            (*schema_cb)(db);
+        } catch (...) {
+            db.sp_rollback(lkg);
+            //  Re-throw.
+            throw;
+        }
+    }
+
+public:
+    SchemaBase(db_t &_db, schema_cb_fn update_schema) : db(_db) {
+        (*update_schema)(db);
+    }
+};
+
+} //namespace Model
+} //namespace Oinky