# A Software Transactional Memory implementation.
#
#   from Beautiful Code Chapter 24.
#
#   mootoh (mootoh@gmail.com)
#
 
module STM
   $global_mutex = Mutex.new
 
   class TVar
      attr_accessor :shared_value
 
      def initialize(x=0)
         Thread.current[:stm_log] ||= {}
 
         @shared_value = x
         Thread.current[:stm_log][self] = []
      end
 
      def read
         if Thread.current[:stm_log][self].empty?
            Thread.current[:stm_log][self].push @shared_value
         end
 
         Thread.current[:stm_log][self].last
      end
 
      def write(value)
         Thread.current[:stm_log][self].push value
      end
   end # TVar
 
   # action
   def atomically
      Thread.current[:stm_log] ||= {}
 
      yield
 
      $global_mutex.synchronize {
         validate
         commit
      }
   end
 
   def retry
   end
 
   def orElse
   end
 
   # TODO: should check related transactions only
   def validate
      Thread.current[:stm_log].each do |tvar, log|
         if log.first != tvar.shared_value
            # abort the transaction
            raise 'inconsist transaction'
         end
      end
   end
 
   # TODO: should commit related transactions only
   def commit
      Thread.current[:stm_log].each do |tvar, log|
         log.each do |value|
            tvar.shared_value = value
         end
         log.clear
      end
   end
 
   module_function :atomically
   module_function :retry
   module_function :orElse
   module_function :validate
   module_function :commit
 
end # STM