mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/multipliers.rb

@@ -0,0 +1,109 @@
+# = Multipliers
+#
+# WARNING: Use Rich Units package for future compatibilty!
+#
+# == Synopsis
+#
+# Adds methods to Numeric to make working with
+# magnitudes (kilo, mega, giga, milli, micro, etc.)
+# as well as bits and bytes easier.
+#
+#   1.kilo               #=> 1000
+#   1.milli              #=> 0.001
+#   1.kibi               #=> 1024
+#
+# To display a value in a certain denomination, simply
+# perform the inverse operation by placing the
+# multiplier called on unit (1) in the denominator.
+#
+#   1000 / 1.kilo        #=> 1
+#   1024 / 1.kibi        #=> 1
+#
+# == History
+#
+#   Thanks to Rich Kilmer and bytes.rb which inspired this library.
+#
+# == Notes
+#
+# * This library is not compatible with STICK's units.rb (an spin-off
+#   of Facets old units.rb library). Do not attempt to use both at the same time.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2005 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# 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.
+
+
+# = Multipliers
+#
+# Adds methods to Numeric to make working with
+# magnitudes (kilo, mega, giga, milli, micro, etc.)
+# as well as bits and bytes easier.
+#
+#   1.kilo               #=> 1000
+#   1.milli              #=> 0.001
+#   1.kibi               #=> 1024
+#
+# To display a value in a certain denomination, simply
+# perform the inverse operation by placing the
+# multiplier called on unit (1) in the denominator.
+#
+#   1000 / 1.kilo        #=> 1
+#   1024 / 1.kibi        #=> 1
+#
+
+#
+class Numeric
+
+  # SI Multipliers
+
+  def deka  ; self * 10 ; end
+  def hecto ; self * 100 ; end
+  def kilo  ; self * 1000 ; end
+  def mega  ; self * 1000000 ; end
+  def giga  ; self * 1000000000 ; end
+  def tera  ; self * 1000000000000 ; end
+  def peta  ; self * 1000000000000000 ; end
+  def exa   ; self * 1000000000000000000 ; end
+
+  # SI Fractional
+
+  def deci  ; self.to_f / 10 ; end
+  def centi ; self.to_f / 100 ; end
+  def milli ; self.to_f / 1000 ; end
+  def micro ; self.to_f / 1000000 ; end
+  def nano  ; self.to_f / 1000000000 ; end
+  def pico  ; self.to_f / 1000000000000 ; end
+  def femto ; self.to_f / 1000000000000000 ; end
+  def atto  ; self.to_f / 1000000000000000000 ; end
+
+  # SI Binary
+
+  def kibi ; self * 1024 ; end
+  def mebi ; self * 1024**2 ; end
+  def gibi ; self * 1024**3 ; end
+  def tebi ; self * 1024**4 ; end
+  def pebi ; self * 1024**5 ; end
+  def exbi ; self * 1024**6 ; end
+
+  # Bits and Bytes
+
+  #def bit   ; self ; end
+  #def bits  ; self ; end
+  #def byte  ; self * 8 ; end
+  #def bytes ; self * 8 ; end
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/multiton.rb

@@ -0,0 +1,386 @@
+# = Multiton
+#
+# == Synopsis
+#
+# Multiton design pattern ensures only one object is allocated for a given state.
+#
+# The 'multiton' pattern is similar to a singleton, but instead of only one
+# instance, there are several similar instances.  It is useful when you want to
+# avoid constructing objects many times because of some huge expense (connecting
+# to a database for example), require a set of similar but not identical
+# objects, and cannot easily control how many times a contructor may be called.
+#
+#   class SomeMultitonClass
+#     include Multiton
+#     attr :arg
+#     def initialize(arg)
+#       @arg = arg
+#     end
+#   end
+#
+#   a = SomeMultitonClass.new(4)
+#   b = SomeMultitonClass.new(4)   # a and b are same object
+#   c = SomeMultitonClass.new(2)   # c is a different object
+#
+# == Previous Behavior
+#
+# In previous versions of Multiton the #new method was made
+# private and #instance had to be used in its stay --just like Singleton.
+# But this is less desirable for Multiton since Multitions can
+# have multiple instances, not just one.
+#
+# So instead Multiton now defines #create as a private alias of
+# the original #new method (just in case it is needed) and then
+# defines #new to handle the multiton; #instance is provided
+# as an alias for it.
+#
+#--
+# So if you must have the old behavior, all you need do is re-alias
+# #new to #create and privatize it.
+#
+#   class SomeMultitonClass
+#     include Multiton
+#     alias_method :new, :create
+#     private :new
+#     ...
+#   end
+#
+# Then only #instance will be available for creating the Multiton.
+#++
+#
+# == How It Works
+#
+# A pool of objects is searched for a previously cached object,
+# if one is not found we construct one and cache it in the pool
+# based on class and the args given to the contructor.
+#
+# A limitation of this approach is that it is impossible to
+# detect if different blocks were given to a contructor (if it takes a
+# block).  So it is the constructor arguments _only_ which determine
+# the uniqueness of an object. To workaround this, define the _class_
+# method ::multiton_id.
+#
+#   def Klass.multiton_id(*args, &block)
+#     # ...
+#   end
+#
+# Which should return a hash key used to identify the object being
+# constructed as (not) unique.
+#
+# == Authors
+#
+# * Christoph Rippel
+# * Thomas Sawyer
+#
+# = Copying
+#
+# Copyright (c) 2007 Christoph Rippel, Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# 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.
+
+require 'thread'
+
+# = Multiton
+#
+# Multiton design pattern ensures only one object is allocated for a given state.
+#
+# The 'multiton' pattern is similar to a singleton, but instead of only one
+# instance, there are several similar instances.  It is useful when you want to
+# avoid constructing objects many times because of some huge expense (connecting
+# to a database for example), require a set of similar but not identical
+# objects, and cannot easily control how many times a contructor may be called.
+#
+#   class SomeMultitonClass
+#     include Multiton
+#     attr :arg
+#     def initialize(arg)
+#       @arg = arg
+#     end
+#   end
+#
+#   a = SomeMultitonClass.new(4)
+#   b = SomeMultitonClass.new(4)   # a and b are same object
+#   c = SomeMultitonClass.new(2)   # c is a different object
+#
+# == How It Works
+#
+# A pool of objects is searched for a previously cached object,
+# if one is not found we construct one and cache it in the pool
+# based on class and the args given to the contructor.
+#
+# A limitation of this approach is that it is impossible to
+# detect if different blocks were given to a contructor (if it takes a
+# block).  So it is the constructor arguments _only_ which determine
+# the uniqueness of an object. To workaround this, define the _class_
+# method ::multiton_id.
+#
+#   def Klass.multiton_id(*args, &block)
+#     # ...
+#   end
+#
+# Which should return a hash key used to identify the object being
+# constructed as (not) unique.
+
+module Multiton
+
+  #  disable build-in copying methods
+
+  def clone
+    raise TypeError, "can't clone Multiton #{self}"
+    #self
+  end
+
+  def dup
+    raise TypeError, "can't dup Multiton #{self}"
+    #self
+  end
+
+  # default marshalling strategy
+
+  protected
+
+  def _dump(depth=-1)
+    Marshal.dump(@multiton_initializer)
+  end
+
+  # Mutex to safely store multiton instances.
+
+  class InstanceMutex < Hash  #:nodoc:
+    def initialize
+      @global = Mutex.new
+    end
+
+    def initialized(arg)
+      store(arg, DummyMutex)
+    end
+
+    def (DummyMutex = Object.new).synchronize
+      yield
+    end
+
+    def default(arg)
+      @global.synchronize{ fetch(arg){ store(arg, Mutex.new) } }
+    end
+  end
+
+  # Multiton can be included in another module, in which case that module effectively becomes
+  # a multiton behavior distributor too. This is why we propogate #included to the base module.
+  # by putting it in another module.
+  #
+  #--
+  #    def append_features(mod)
+  #      #  help out people counting on transitive mixins
+  #      unless mod.instance_of?(Class)
+  #        raise TypeError, "Inclusion of Multiton in module #{mod}"
+  #      end
+  #      super
+  #    end
+  #++
+
+  module Inclusive
+    private
+    def included(base)
+      class << base
+        #alias_method(:new!, :new) unless method_defined?(:new!)
+        # gracefully handle multiple inclusions of Multiton
+        unless include?(Multiton::MetaMethods)
+          alias_method :new!, :new
+          private :allocate #, :new
+          include Multiton::MetaMethods
+
+          if method_defined?(:marshal_dump)
+            undef_method :marshal_dump
+            warn "warning: marshal_dump was undefined since it is incompatible with the Multiton pattern"
+          end
+        end
+      end
+    end
+  end
+
+  extend Inclusive
+
+  #
+
+  module MetaMethods
+
+    include Inclusive
+
+    def instance(*e, &b)
+      arg = multiton_id(*e, &b)
+      multiton_instance.fetch(arg) do
+        multiton_mutex[arg].synchronize do
+          multiton_instance.fetch(arg) do
+            val = multiton_instance[arg] = new!(*e, &b) #new(*e, &b)
+            val.instance_variable_set(:@multiton_initializer, e, &b)
+            multiton_mutex.initialized(arg)
+            val
+          end
+        end
+      end
+    end
+    alias_method :new, :instance
+
+    def initialized?(*e, &b)
+      multiton_instance.key?(multiton_id(*e, &b))
+    end
+
+    protected
+
+    def multiton_instance
+      @multiton_instance ||= Hash.new
+    end
+
+    def multiton_mutex
+      @multiton_mutex ||= InstanceMutex.new
+    end
+
+    def reinitialize
+      multiton_instance.clear
+      multiton_mutex.clear
+    end
+
+    def _load(str)
+      instance(*Marshal.load(str))
+    end
+
+    private
+
+    # Default method to to create a key to cache already constructed
+    # instances. In the use case MultitonClass.new(e), MultiClass.new(f)
+    # must be semantically equal if multiton_id(e).eql?(multiton_id(f))
+    # evaluates to true.
+    def multiton_id(*e, &b)
+      e
+    end
+
+    def singleton_method_added(sym)
+      super
+      if (sym == :marshal_dump) & singleton_methods.include?('marshal_dump')
+        raise TypeError, "Don't use marshal_dump - rely on _dump and _load instead"
+      end
+    end
+
+  end
+
+end
+
+
+
+
+=begin
+# TODO Convert this into a real test and/or benchmark.
+
+if $0 == __FILE__
+
+  ### Simple marshalling test #######
+  class A
+    def initialize(a,*e)
+      @e = a
+    end
+
+    include Multiton
+    begin
+      def self.marshal_dump(depth = -1)
+      end
+    rescue => mes
+      p mes
+      class << self; undef marshal_dump end
+    end
+  end
+
+  C = Class.new(A.clone)
+  s = C.instance('a','b')
+
+  raise unless Marshal.load(Marshal.dump(s)) == s
+
+
+  ### Interdependent initialization example and threading benchmark ###
+
+  class Regular_SymPlane
+    def self.multiton_id(*e)
+        a,b = e
+        (a+b - 1)*(a+b )/2  + (a > b ? a : b)
+    end
+
+    def initialize(a,b)
+      klass = self.class
+      if a < b
+        @l =  b > 0 ?  klass.instance(a,b-1) : nil
+        @r =  a > 0 ?  klass.instance(a-1,b) : nil
+      else
+        @l =  a > 0 ?  klass.instance(a-1,b) : nil
+        @r =  b > 0 ?  klass.instance(a,b-1) : nil
+      end
+    end
+
+    include Multiton
+  end
+
+
+
+  def nap
+  # Thread.pass
+  sleep(rand(0.01))
+  end
+
+  class SymPlane < Regular_SymPlane
+    @m = Mutex.new
+    @count = 0
+  end
+
+  class << SymPlane
+    attr_reader :count
+    def reinitialize
+      super
+      @m = Mutex.new
+      @count = 0
+    end
+    def inherited(sub_class)
+      super
+      sub_class.instance_eval { @m = Mutex.new; @count = 0 }
+    end
+
+    def multiton_id(*e)
+      nap()
+      super
+    end
+
+    def new!(*e)  # NOTICE!!!
+      super
+    ensure
+      nap()
+      @m.synchronize { p @count if (@count += 1) % 15 == 0 }
+    end
+
+    def run(k)
+      threads = 0
+      max = k * (k+1) / 2
+      puts ""
+      while count() < max
+        Thread.new { threads+= 1; instance(rand(30),rand(30)) }
+      end
+      puts "\nThe simulation created #{threads} threads"
+    end
+  end
+
+
+  require 'benchmark'
+  include Benchmark
+
+  bmbm do |x|
+    x.report('Initialize 465 SymPlane instances') { SymPlane.run(30) }
+    x.report('Reinitialize ') do
+      sleep 3
+      SymPlane.reinitialize
+    end
+  end
+
+end
+=end