hyperactive 0.2.2 → 0.2.3

data/README

@@ -2,14 +2,21 @@
 
 It uses archipelago for persistence, and is meaningful only in an environment where the server process doesnt restart at each request. This means that cgi environment is not really an option.
 
-== Dependencies:
+== Sub packages:
 
-Hyperactive::Tree:: RBTree: http://raa.ruby-lang.org/project/ruby-rbtree
+Hyperactive::Record:: The base class package itself, providing you with cached selectors and rejectors, along with cached finders for any number of attributes.
+Hyperactive::Hash:: A collection class that contains any number of Hyperactive::Records in a hash like structure.
+Hyperactive::List:: A collection class that contains any number of Hyperactive::Records in a list like structure.
 
-== Sub packages:
+== Usage:
+
+To use Hyperactive in the simplest way, just run the script/services.rb script from the Archipelago 
+distribution to get a few services running, then subclass Hyperactive::Record::Bass and create 
+objects with <b>MyBassSubclass.get_instance</b> (not <b>new</b>!). They will be automagically 
+stored in the network, and fetchable via their <b>instance.record_id</b>.
 
-Hyperactive::Record:: The base class itself, providing you with cached selectors and rejectors, along with cached finders for any number of attributes.
-Hyperactive::Tree:: A collection class that contains any number of Hyperactive::Records in a tree structure. Scales logarithmically, so use with care.
+By loading Hyperactive::Record you will automatically define Hyperactive::Record::CAPTAIN which will
+be an Archipelago::Pirate::Captain that is your interface to the distributed database.
 
 == Examples:
 

data/lib/hyperactive.rb

@@ -19,5 +19,5 @@ $: << File.dirname(__FILE__)
 
 require 'hyperactive/hooker'
 require 'hyperactive/record'
-require 'hyperactive/tree'
+require 'hyperactive/hash'
 require 'hyperactive/list'

data/lib/hyperactive/hash.rb

@@ -0,0 +1,172 @@
+# Archipelago - a distributed computing toolkit for ruby
+# Copyright (C) 2006  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+
+require 'rubygems'
+require 'archipelago'
+require 'digest/sha1'
+
+module Hyperactive
+
+  #
+  # The package containing the Hash class that provides any
+  # kind of index for your Hyperactive classes.
+  #
+  # Is supposed to be constantly scaling, but preliminary benchmarks show some
+  # problems with that assumption?
+  #
+  module Hash
+    
+    #
+    # A wrapper class that knows what key, value and list_element belong together.
+    #
+    class Element < Hyperactive::Record::Bass
+      attr_accessor :key, :value, :list_element
+      #
+      # Initialize a new Hash::Element with given +key+, +value+ and +list_element+.
+      #
+      def initialize(key, value, list_element)
+        self.key = key
+        self.value = value
+        self.list_element = list_element
+      end
+    end
+
+    #
+    # A class suitable for storing large and often-changing datasets in 
+    # an Archipelago environment.
+    #
+    class Head < Hyperactive::Record::Bass
+
+      attr_accessor :list
+
+      include Archipelago::Current::ThreadedCollection
+
+      #
+      # Initialize a Hash::Head.
+      #
+      # NB: Remember to call create on the new instance or use Head.get_instance to get that done automatically.
+      #
+      def initialize
+        self.list = nil
+      end
+
+      #
+      # Return the size of this Hash.
+      #
+      def size
+        self.list.size
+      end
+
+      #
+      # Return the value for +key+.
+      #
+      def [](key)
+        element = Hyperactive::Record::CAPTAIN[my_key_for(key), @transaction]
+        if element
+          return element.value
+        else
+          return nil
+        end
+      end
+
+      #
+      # Returns whether +key+ is included in this Hash.
+      #
+      def include?(key)
+        Hyperactive::Record::CAPTAIN.include?(my_key_for(key), @transaction)
+      end
+
+      #
+      # Insert +value+ under +key+ in this Hash.
+      # 
+      def []=(key, value)
+        self.list = Hyperactive::List::Head.get_instance_with_transaction(@transaction) unless self.list
+
+        if (element = Hyperactive::Record::CAPTAIN[my_key_for(key), @transaction])
+          element.value = value
+        else          
+          element = Element.get_instance_with_transaction(@transaction, key, value, nil)
+          self.list << element
+          element.list_element = self.list.last_element
+          Hyperactive::Record::CAPTAIN[my_key_for(key), @transaction] = element
+        end
+      end
+
+      #
+      # Delete +key+ from this Hash.
+      # 
+      def delete(key)
+        self.list = Hyperactive::List::Head.get_instance_with_transaction(@transaction) unless self.list
+
+        return_value = nil
+
+        element = Hyperactive::Record::CAPTAIN[my_key_for(key), @transaction]
+        if element
+          Hyperactive::Record::CAPTAIN.delete(my_key_for(key), @transaction)
+          self.list.unlink!(element.list_element)
+          return_value = element.value
+          element.destroy!
+        end
+        return return_value
+      end
+
+      #
+      # Will yield to +block+ once for each key/value pair in this Hash.
+      #
+      def each(&block)
+        self.list = Hyperactive::List::Head.get_instance_with_transaction(@transaction) unless self.list
+
+        self.list.each do |element|
+          yield([element.key, element.value])
+        end
+      end
+
+      #
+      # Remove all key/value pairs from this Hash.
+      #
+      def clear!
+        self.list = Hyperactive::List::Head.get_instance_with_transaction(@transaction) unless self.list
+
+        self.list.t_each do |element|
+          element.destroy!
+        end
+        self.list.clear!
+      end
+      
+      #
+      # Clear everything from this Tree and destroy it.
+      #
+      def destroy!
+        self.clear!
+        super
+      end
+
+      private
+
+      #
+      # Get my private key for a given +key+.
+      #
+      def my_key_for(key)
+        Digest::SHA1.hexdigest("#{Marshal.dump(key)}#{self.record_id}")
+      end
+      
+    end
+
+  end
+
+end

data/lib/hyperactive/list.rb

@@ -27,73 +27,148 @@ module Hyperactive
   module List
 
     #
-    # A List element.
+    # A wrapper class that knows its previous and next List::Elements as well as its value and the id of its list.
     #
     class Element < Hyperactive::Record::Bass
-      attr_accessor :previous, :next, :value
+      attr_accessor :previous, :next, :value, :list_id
+
+      include Archipelago::Current::ThreadedCollection
+
+      #
+      # Initialize this List::Element with given +previous_element+, +next_element+, +value+ and +list_id+.
+      #
+      def initialize(previous_element, next_element, value, list_id)
+        self.previous = previous_element
+        self.next = next_element
+        self.value = value
+        self.list_id = list_id
+      end
+
+      #
+      # Yield to +block+ once for this and each following element.
+      #
+      def each(&block)
+        element = self
+        while element
+          yield(element)
+          element = self.next
+        end
+      end
     end
 
     #
     # A List head.
     #
     class Head < Hyperactive::Record::Bass
-      attr_reader :first_element, :last_element, :size
+      attr_accessor :first_element, :last_element, :size
+
+      include Archipelago::Current::ThreadedCollection
 
       #
-      # Create a Head.
+      # Create a List::Head. This is in essence the linked list.
       #
-      # NB: As usual, dont call this. Use Head.get_instance instead.
+      # NB: Remember to call create on the new instance or use Head.get_instance to get that done automatically.
       #
       def initialize
-        @size = 0
-        @first_element = @last_element = nil
+        self.size = 0
+        self.first_element = self.last_element = nil
       end
 
+      #
+      # Unlinks the given +element+ and reconnects the List around it.
+      #
+      def unlink!(element)
+        raise "#{element} is not a part of #{self}" unless element.list_id == @record_id
+
+        if size > 1
+          if element == self.first_element
+            self.first_element = element.next
+            self.first_element.previous = nil
+          elsif element == self.last_element
+            self.last_element = element.previous
+            self.last_element.next = nil
+          else
+            element.previous.next = element.next
+            element.next.previous = element.previous
+          end
+        else
+          if element == self.first_element
+            self.first_element = self.last_element = nil
+          else
+            raise "#{element} is not a part of #{self} even though it claims to be"
+          end
+        end
+        self.size -= 1
+        element.destroy!
+      end
+
+      #
+      # Remove all elements from this List::Head.
+      #
+      def clear!
+        self.first_element.t_each do |element|
+          element.destroy!
+        end
+        self.first_element = self.last_element = nil
+        self.size = 0
+      end
+      
+      #
+      # Destroys this list and all its elements.
+      #
+      def destroy!
+        self.clear!
+        super
+      end
+      
       #
       # Return the first value of the list.
       #
       def first
-        @first_element.value
+        if self.first_element
+          self.first_element.value
+        else
+          nil
+        end
       end
-
+      
       #
       # Return the last value of the list. 
       #
       def last
-        @last_element.value
+        if self.last_element
+          self.last_element.value
+        else
+        end
       end
       
       #
       # Push +v+ onto the end of this list.
       #
       def <<(v)
-        if @first_element
-          new_element = Element.get_instance
-          new_element.value = v
-          new_element.previous = @last_element
-          @last_element.next = new_element
-          @last_element = new_element
+        if self.first_element
+          new_element = Element.get_instance_with_transaction(@transaction, self.last_element, nil, v, @record_id)
+          self.last_element.next = new_element
+          self.last_element = new_element
         else
           start(v)
         end
-        @size += 1
+        self.size += 1
         return v
       end
-
+      
       #
       # Push +v+ onto the beginning of this list.
       #
       def unshift(v)
-        if @first_element
-          new_element = Element.get_instance
-          new_element.value = v
-          new_element.next = @first_element
-          @first_element.previous = new_element
-          @first_element = new_element
+        if self.first_element
+          new_element = Element.get_instance_with_transaction(@transaction, nil, self.first_element, v, @record_id)
+          self.first_element.previous = new_element
+          self.first_element = new_element
         else
           start(v)
         end 
-        @size += 1
+        self.size += 1
         return v
       end
       
@@ -103,37 +178,48 @@ module Hyperactive
       def pop
         v = nil
         if size > 1
-          element = @last_element
-          @last_element = element.previous
-          @last_element.next = nil
+          element = self.last_element
+          self.last_element = element.previous
+          self.last_element.next = nil
           v = element.value
-          element.destroy
+          element.destroy!
         else
-          v = @first_element.value
-          @first_element.destroy
-          @first_element = @last_element = nil
+          v = self.first_element.value
+          self.first_element.destroy!
+          self.first_element = self.last_element = nil
         end
-        @size -= 1
+        self.size -= 1
         return v
       end
 
+      #
+      # Yield to +block+ once for each value in this list.
+      #
+      def each(&block)
+        element = self.first_element
+        while element
+          yield(element.value)
+          element = element.next
+        end
+      end
+
       #
       # Remove the first value from this list and return it. 
       #
       def shift
         v = nil
         if size > 1
-          element = @first_element
-          @first_element = element.next
-          @first_element.previous = nil
+          element = self.first_element
+          self.first_element = element.next
+          self.first_element.previous = nil
           v = element.value
-          element.destroy
+          element.destroy!
         else
-          v = @first_element.value
-          @first_element.destroy
-          @first_element = @last_element = nil
+          v = self.first_element.value
+          self.first_element.destroy!
+          self.first_element = self.last_element = nil
         end
-        @size -= 1
+        self.size -= 1
         return v
       end
       
@@ -143,8 +229,7 @@ module Hyperactive
       # Start this list with +v+ when it has no other values.
       #
       def start(v)
-        @first_element = @last_element = Element.get_instance
-        @first_element.value = v
+        self.first_element = self.last_element = Element.get_instance_with_transaction(@transaction, nil, nil, v, @record_id)
       end
 
     end