Class: Object

Inherits:
BasicObject
Includes:
Redwood::LogsStuff
Defined in:
lib/sup.rb,
lib/sup/util.rb,
lib/sup/logger/singleton.rb

Instance Method Summary collapse

Instance Method Details

#ancestors ⇒ Object 



170
171
172
173
174
175
176
177
178
179
 
# File 'lib/sup/util.rb', line 170

def ancestors
  ret = []
  klass = self.class

  until klass == Object
    ret << klass
    klass = klass.superclass
  end
  ret
end

#benchmark(s, &b) ⇒ Object 



228
229
230
231
232
233
 
# File 'lib/sup/util.rb', line 228

def benchmark s, &b
  ret = nil
  times = Benchmark.measure { ret = b.call }
  debug "benchmark #{s}: #{times}"
  ret
end

#id ⇒ Object

this is for debugging purposes because i keep calling #id on the wrong object and i want it to throw an exception



23
24
25
 
# File 'lib/sup.rb', line 23

def id
  raise "wrong id called on #{self.inspect}"
end

#ignore_concurrent_calls(*methods) ⇒ Object 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/sup/util.rb', line 202

def ignore_concurrent_calls *methods
  methods.each do |meth|
    mutex = "@__concurrent_protector_#{meth}"
    flag = "@__concurrent_flag_#{meth}"
    oldmeth = "__unprotected_#{meth}"
    class_eval <<-EOF
      alias #{oldmeth} #{meth}
      def #{meth}(*a, &b)
        #{mutex} = Mutex.new unless defined? #{mutex}
        #{flag} = true unless defined? #{flag}
        run = #{mutex}.synchronize do
          if #{flag}
            #{flag} = false
            true
          end
        end
        if run
          ret = #{oldmeth}(*a, &b)
          #{mutex}.synchronize { #{flag} = true }
          ret
        end
      end
    EOF
  end
end

#returning(x) {|x| ... } ⇒ Object

“k combinator”

Yields:

  • (x) 


182
 
# File 'lib/sup/util.rb', line 182

def returning x; yield x; x; end

#synchronized(*methods) ⇒ Object

clone of java-style whole-method synchronization assumes a @mutex variable TODO: clean up, try harder to avoid namespace collisions



191
192
193
194
195
196
197
198
199
200
 
# File 'lib/sup/util.rb', line 191

def synchronized *methods
  methods.each do |meth|
    class_eval <<-EOF
      alias unsynchronized_#{meth} #{meth}
      def #{meth}(*a, &b)
        @mutex.synchronize { unsynchronized_#{meth}(*a, &b) }
      end
    EOF
  end
end

#tap {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:

  • _self (Object) —

    the object that the method was called on



185
 
# File 'lib/sup/util.rb', line 185

def tap; yield self; self; end