formatting, removed exception, minor tweaks

1. In case of a error, corresponding callaback is called.
2. added reservation for internally used stream id (0) to
   avoid (unlikely) situation when there is no ids left for internal calls.

Author: dimitry42

include/libcql/cql.hpp

@@ -123,15 +123,5 @@ namespace cql {
         CQL_EVENT_TOPOLOGY_REMOVE_NODE = 0x02,
     };
 
-    class cql_exception : public std::exception {
-    public:
-        cql_exception() : std::exception() {}
-        cql_exception(const std::string& message) : _message(message) {}
-	virtual ~cql_exception() throw() {}
-
-        virtual const char* what() const throw() { return _message.c_str(); }
-    private:
-        std::string _message;
-    };
 } // namespace cql
 #endif // __CQL_H_INCLUDED__

include/libcql/internal/cql_callback_storage.hpp

@@ -27,10 +27,10 @@
 namespace cql {
     // this template class stores up to 128 values no more
     template<typename value_t>
-    class indexed_storage {
+    class small_indexed_storage {
     private:
         template <typename _value_t>
-        struct entry_t {
+        class entry_t {
             struct {
                 struct {
                     // -1 - there is no next free index
@@ -41,37 +41,87 @@ namespace cql {
                 _value_t value;
             } e;
 
-            _value_t& value() { return e.value; }
-            int8_t next_free_index() const { return e.next_free.index; }
+        public:
+            _value_t&
+            value()
+            {
+                return e.value;
+            }
+
+            const _value_t&
+            value() const
+            {
+                return e.value;
+            }
+
+            int8_t
+            next_free_index() const
+            {
+                return e.next_free.index;
+            }
+
             // not counting this (so 0 means there are no free blocks behind this one)
-            int8_t next_free_cnt() const { return e.next_free.count; }
+            int8_t
+            next_free_cnt() const
+            {
+                return e.next_free.count;
+            }
 
             // count does not include this (so 0 means there are no free blocks behind this one)
             // you won't need to set cnt in any case except initial allocation
-            void set_next_free(int32_t index, int32_t cnt = 0) { e.next_free.index = index; e.next_free.count = cnt;}
-            void set_value(const _value_t& val) { e.value = val; }
-            bool is_allocated() { return e.next_free.index == -2; }
-            void set_allocated() { e.next_free.index = -2; }
+            void
+            set_next_free(int32_t index,
+                          int32_t cnt = 0)
+            {
+                e.next_free.index = index;
+                e.next_free.count = cnt;
+            }
+
+            void
+            set_value(const _value_t& val)
+            {
+                e.value = val;
+            }
+
+            bool
+            is_allocated()
+            {
+                return e.next_free.index == -2;
+            }
+
+            void
+            set_allocated()
+            {
+                e.next_free.index = -2;
+            }
         };
 
         typedef entry_t<value_t> array_entry_t;
         array_entry_t* array;
         int32_t next_free_index;
     public:
-        explicit indexed_storage(uint32_t size) : next_free_index(0) {
-            if (size > 1u + static_cast<uint32_t>(INT32_MAX)) throw std::bad_alloc();
+        explicit
+        small_indexed_storage(uint16_t size) :
+                next_free_index(0)
+        {
             array = new array_entry_t[size];
             array[0].set_next_free(-1, size-1);
         }
 
-        ~indexed_storage() { delete [] array; }
+        ~small_indexed_storage()
+        {
+            delete [] array;
+        }
 
-        int32_t allocate_index() {
+        int32_t
+        allocate()
+        {
             int32_t result;
             if ( (result = next_free_index) >= 0) {
                 if (array[next_free_index].next_free_cnt() > 0) {
                     array[++next_free_index].set_next_free(array[result].next_free_index(), array[result].next_free_cnt()-1);
-                } else {
+                }
+                else {
                     next_free_index = array[next_free_index].next_free_index();
                 }
                 // mark it allocated
@@ -81,23 +131,35 @@ namespace cql {
             return result;
         }
 
-        // do not even thing about passing negative value here
-        // there are no checks... none.
-        void deallocate_index(int32_t index) {
-            // we are good.
+        void
+        release(int32_t index)
+        {
             array[index].set_next_free(next_free_index);
             next_free_index = index;
         }
 
-        bool has(int32_t index) const {
+        bool
+        has(int32_t index) const
+        {
             return array[index].is_allocated();
         }
 
-        value_t& get(int32_t index) const {
+        value_t&
+        get(int32_t index)
+        {
+            return array[index].value();
+        }
+
+        const value_t&
+        get(int32_t index) const
+        {
             return array[index].value();
         }
 
-        void put(int32_t index, const value_t& val) {
+        void
+        put(int32_t index,
+            const value_t& val)
+        {
             array[index].set_value(val);
         }