# Sync_m (Module)

In: | sync.rb

## Methods

append_features define_aliases extend_object new sync_exclusive? sync_extended sync_lock sync_locked? sync_shared? sync_synchronize sync_try_lock sync_unlock

## Constants

RCS_ID | = |
UN | = | :UN
| lock mode
SH | = | :SH
EX | = | :EX

## Attributes

sync_ex_count | [RW] |
sync_ex_locker | [RW] |
sync_mode | [RW] |
sync_sh_locker | [RW] |
sync_upgrade_waiting | [RW] |
sync_waiting | [RW] |

## Classes and Modules

Class Sync_m::Err
::Class Sync_m::Err::LockModeFailer
::Class Sync_m::Err::UnknownLocker

## Public Class methods

define_aliases(cl)

[Source]

    # File sync.rb, line 78
      def Sync_m.define_aliases(cl)
        cl.module_eval %{
          alias locked? sync_locked?
          alias shared? sync_shared?
          alias exclusive? sync_exclusive?
          alias lock sync_lock
          alias unlock sync_unlock
          alias try_lock sync_try_lock
          alias synchronize sync_synchronize
        }
      end

append_features(cl)

[Source]

    # File sync.rb, line 90
      def Sync_m.append_features(cl)
        super
        unless cl.instance_of?(Module)
          # do nothing for Modules

          # make aliases and include the proper module.

          define_aliases(cl)
        end
      end

extend_object(obj)

[Source]

    # File sync.rb, line 99
      def Sync_m.extend_object(obj)
        super
        obj.sync_extended
      end

new(*args)

[Source]

    # File sync.rb, line 254
      def initialize(*args)
        sync_initialize
        super
      end

## Public Instance methods

sync_extended()

[Source]

    # File sync.rb, line 104
      def sync_extended
        unless (defined? locked? and
                defined? shared? and
                defined? exclusive? and
                defined? lock and
                defined? unlock and
                defined? try_lock and
                defined? synchronize)
          Sync_m.define_aliases(class<<self;self;end)
        end
        sync_initialize
      end

sync_locked?()

accessing

[Source]

    # File sync.rb, line 118
      def sync_locked?
        sync_mode != UN
      end

sync_shared?()

[Source]

    # File sync.rb, line 122
      def sync_shared?
        sync_mode == SH
      end

sync_exclusive?()

[Source]

    # File sync.rb, line 126
      def sync_exclusive?
        sync_mode == EX
      end

sync_try_lock(mode = EX)

locking methods.

[Source]

    # File sync.rb, line 131
      def sync_try_lock(mode = EX)
        return unlock if sync_mode == UN

        Thread.critical = true
        ret = sync_try_lock_sub(sync_mode)
        Thread.critical = false
        ret
      end

sync_lock(m = EX)

[Source]

    # File sync.rb, line 140
      def sync_lock(m = EX)
        return unlock if m == UN

        until (Thread.critical = true; sync_try_lock_sub(m))
          if sync_sh_locker[Thread.current]
            sync_upgrade_waiting.push [Thread.current, sync_sh_locker[Thread.current]]
            sync_sh_locker.delete(Thread.current)
          else
            sync_waiting.push Thread.current
          end
          Thread.stop
        end
        Thread.critical = false
        self
      end

sync_unlock(m = EX)

[Source]

    # File sync.rb, line 156
      def sync_unlock(m = EX)
        Thread.critical = true
        if sync_mode == UN
          Thread.critical = false
          Err::UnknownLocker.Fail(Thread.current)
        end

        m = sync_mode if m == EX and sync_mode == SH

        runnable = false
        case m
        when UN
          Thread.critical = false
          Err::UnknownLocker.Fail(Thread.current)

        when EX
          if sync_ex_locker == Thread.current
            if (self.sync_ex_count = sync_ex_count - 1) == 0
              self.sync_ex_locker = nil
              if sync_sh_locker.include?(Thread.current)
                self.sync_mode = SH
              else
                self.sync_mode = UN
              end
              runnable = true
            end
          else
            Err::UnknownLocker.Fail(Thread.current)
          end

        when SH
          if (count = sync_sh_locker[Thread.current]).nil?
            Err::UnknownLocker.Fail(Thread.current)
          else
            if (sync_sh_locker[Thread.current] = count - 1) == 0
              sync_sh_locker.delete(Thread.current)
              if sync_sh_locker.empty? and sync_ex_count == 0
                self.sync_mode = UN
                runnable = true
              end
            end
          end
        end

        if runnable
          if sync_upgrade_waiting.size > 0
            for k, v in sync_upgrade_waiting
              sync_sh_locker[k] = v
            end
            wait = sync_upgrade_waiting
            self.sync_upgrade_waiting = []
            Thread.critical = false

            for w, v in wait
              w.run
            end
          else
            wait = sync_waiting
            self.sync_waiting = []
            Thread.critical = false
            for w in wait
              w.run
            end
          end
        end

        Thread.critical = false
        self
      end

sync_synchronize(mode = EX) {|| ...}

[Source]

    # File sync.rb, line 226
      def sync_synchronize(mode = EX)
        begin
          sync_lock(mode)
          yield
        ensure
          sync_unlock
        end
      end

[Validate]