logstash-output-scalyr 0.1.4 → 0.1.9

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -1,28 +0,0 @@
-module Concurrent
-
-  # Special "compare and set" handling of numeric values.
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicNumericCompareAndSetWrapper
-
-    # @!macro atomic_reference_method_compare_and_set
-    def compare_and_set(old_value, new_value)
-      if old_value.kind_of? Numeric
-        while true
-          old = get
-
-          return false unless old.kind_of? Numeric
-
-          return false unless old == old_value
-
-          result = _compare_and_set(old, new_value)
-          return result if result
-        end
-      else
-        _compare_and_set(old_value, new_value)
-      end
-    end
-
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/atomics.rb

@@ -1,10 +0,0 @@
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/atomic/atomic_boolean'
-require 'concurrent/atomic/atomic_fixnum'
-require 'concurrent/atomic/cyclic_barrier'
-require 'concurrent/atomic/count_down_latch'
-require 'concurrent/atomic/event'
-require 'concurrent/atomic/read_write_lock'
-require 'concurrent/atomic/reentrant_read_write_lock'
-require 'concurrent/atomic/semaphore'
-require 'concurrent/atomic/thread_local_var'

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb

@@ -1,107 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-  module Collection
-
-    # A thread safe observer set implemented using copy-on-read approach:
-    # observers are added and removed from a thread safe collection; every time
-    # a notification is required the internal data structure is copied to
-    # prevent concurrency issues
-    #
-    # @api private
-    class CopyOnNotifyObserverSet < Synchronization::LockableObject
-
-      def initialize
-        super()
-        synchronize { ns_initialize }
-      end
-
-      # @!macro observable_add_observer
-      def add_observer(observer = nil, func = :update, &block)
-        if observer.nil? && block.nil?
-          raise ArgumentError, 'should pass observer as a first argument or block'
-        elsif observer && block
-          raise ArgumentError.new('cannot provide both an observer and a block')
-        end
-
-        if block
-          observer = block
-          func     = :call
-        end
-
-        synchronize do
-          @observers[observer] = func
-          observer
-        end
-      end
-
-      # @!macro observable_delete_observer
-      def delete_observer(observer)
-        synchronize do
-          @observers.delete(observer)
-          observer
-        end
-      end
-
-      # @!macro observable_delete_observers
-      def delete_observers
-        synchronize do
-          @observers.clear
-          self
-        end
-      end
-
-      # @!macro observable_count_observers
-      def count_observers
-        synchronize { @observers.count }
-      end
-
-      # Notifies all registered observers with optional args
-      # @param [Object] args arguments to be passed to each observer
-      # @return [CopyOnWriteObserverSet] self
-      def notify_observers(*args, &block)
-        observers = duplicate_observers
-        notify_to(observers, *args, &block)
-        self
-      end
-
-      # Notifies all registered observers with optional args and deletes them.
-      #
-      # @param [Object] args arguments to be passed to each observer
-      # @return [CopyOnWriteObserverSet] self
-      def notify_and_delete_observers(*args, &block)
-        observers = duplicate_and_clear_observers
-        notify_to(observers, *args, &block)
-        self
-      end
-
-      protected
-
-      def ns_initialize
-        @observers = {}
-      end
-
-      private
-
-      def duplicate_and_clear_observers
-        synchronize do
-          observers = @observers.dup
-          @observers.clear
-          observers
-        end
-      end
-
-      def duplicate_observers
-        synchronize { @observers.dup }
-      end
-
-      def notify_to(observers, *args)
-        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
-        observers.each do |observer, function|
-          args = yield if block_given?
-          observer.send(function, *args)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb

@@ -1,111 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-  module Collection
-
-    # A thread safe observer set implemented using copy-on-write approach:
-    # every time an observer is added or removed the whole internal data structure is
-    # duplicated and replaced with a new one.
-    #
-    # @api private
-    class CopyOnWriteObserverSet < Synchronization::LockableObject
-
-      def initialize
-        super()
-        synchronize { ns_initialize }
-      end
-
-      # @!macro observable_add_observer
-      def add_observer(observer = nil, func = :update, &block)
-        if observer.nil? && block.nil?
-          raise ArgumentError, 'should pass observer as a first argument or block'
-        elsif observer && block
-          raise ArgumentError.new('cannot provide both an observer and a block')
-        end
-
-        if block
-          observer = block
-          func = :call
-        end
-
-        synchronize do
-          new_observers = @observers.dup
-          new_observers[observer] = func
-          @observers = new_observers
-          observer
-        end
-      end
-
-      # @!macro observable_delete_observer
-      def delete_observer(observer)
-        synchronize do
-          new_observers = @observers.dup
-          new_observers.delete(observer)
-          @observers = new_observers
-          observer
-        end
-      end
-
-      # @!macro observable_delete_observers
-      def delete_observers
-        self.observers = {}
-        self
-      end
-
-      # @!macro observable_count_observers
-      def count_observers
-        observers.count
-      end
-
-      # Notifies all registered observers with optional args
-      # @param [Object] args arguments to be passed to each observer
-      # @return [CopyOnWriteObserverSet] self
-      def notify_observers(*args, &block)
-        notify_to(observers, *args, &block)
-        self
-      end
-
-      # Notifies all registered observers with optional args and deletes them.
-      #
-      # @param [Object] args arguments to be passed to each observer
-      # @return [CopyOnWriteObserverSet] self
-      def notify_and_delete_observers(*args, &block)
-        old = clear_observers_and_return_old
-        notify_to(old, *args, &block)
-        self
-      end
-
-      protected
-
-      def ns_initialize
-        @observers = {}
-      end
-
-      private
-
-      def notify_to(observers, *args)
-        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
-        observers.each do |observer, function|
-          args = yield if block_given?
-          observer.send(function, *args)
-        end
-      end
-
-      def observers
-        synchronize { @observers }
-      end
-
-      def observers=(new_set)
-        synchronize { @observers = new_set }
-      end
-
-      def clear_observers_and_return_old
-        synchronize do
-          old_observers = @observers
-          @observers = {}
-          old_observers
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb

@@ -1,84 +0,0 @@
-if Concurrent.on_jruby?
-
-  module Concurrent
-    module Collection
-
-
-      # @!macro priority_queue
-      # 
-      # @!visibility private
-      # @!macro internal_implementation_note
-      class JavaNonConcurrentPriorityQueue
-
-        # @!macro priority_queue_method_initialize
-        def initialize(opts = {})
-          order = opts.fetch(:order, :max)
-          if [:min, :low].include?(order)
-            @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
-          else
-            @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
-          end
-        end
-
-        # @!macro priority_queue_method_clear
-        def clear
-          @queue.clear
-          true
-        end
-
-        # @!macro priority_queue_method_delete
-        def delete(item)
-          found = false
-          while @queue.remove(item) do
-            found = true
-          end
-          found
-        end
-
-        # @!macro priority_queue_method_empty
-        def empty?
-          @queue.size == 0
-        end
-
-        # @!macro priority_queue_method_include
-        def include?(item)
-          @queue.contains(item)
-        end
-        alias_method :has_priority?, :include?
-
-        # @!macro priority_queue_method_length
-        def length
-          @queue.size
-        end
-        alias_method :size, :length
-
-        # @!macro priority_queue_method_peek
-        def peek
-          @queue.peek
-        end
-
-        # @!macro priority_queue_method_pop
-        def pop
-          @queue.poll
-        end
-        alias_method :deq, :pop
-        alias_method :shift, :pop
-
-        # @!macro priority_queue_method_push
-        def push(item)
-          raise ArgumentError.new('cannot enqueue nil') if item.nil?
-          @queue.add(item)
-        end
-        alias_method :<<, :push
-        alias_method :enq, :push
-
-        # @!macro priority_queue_method_from_list
-        def self.from_list(list, opts = {})
-          queue = new(opts)
-          list.each{|item| queue << item }
-          queue
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb

@@ -1,158 +0,0 @@
-module Concurrent
-
-  # @!macro warn.edge
-  class LockFreeStack < Synchronization::Object
-
-    safe_initialization!
-
-    class Node
-      # TODO (pitr-ch 20-Dec-2016): Could be unified with Stack class?
-
-      # @return [Node]
-      attr_reader :next_node
-
-      # @return [Object]
-      attr_reader :value
-
-      # @!visibility private
-      # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
-      attr_writer :value
-
-      def initialize(value, next_node)
-        @value     = value
-        @next_node = next_node
-      end
-
-      singleton_class.send :alias_method, :[], :new
-    end
-
-    # The singleton for empty node
-    EMPTY = Node[nil, nil]
-    def EMPTY.next_node
-      self
-    end
-
-    attr_atomic(:head)
-    private :head, :head=, :swap_head, :compare_and_set_head, :update_head
-
-    # @!visibility private
-    def self.of1(value)
-      new Node[value, EMPTY]
-    end
-
-    # @!visibility private
-    def self.of2(value1, value2)
-      new Node[value1, Node[value2, EMPTY]]
-    end
-
-    # @param [Node] head
-    def initialize(head = EMPTY)
-      super()
-      self.head = head
-    end
-
-    # @param [Node] head
-    # @return [true, false]
-    def empty?(head = head())
-      head.equal? EMPTY
-    end
-
-    # @param [Node] head
-    # @param [Object] value
-    # @return [true, false]
-    def compare_and_push(head, value)
-      compare_and_set_head head, Node[value, head]
-    end
-
-    # @param [Object] value
-    # @return [self]
-    def push(value)
-      while true
-        current_head = head
-        return self if compare_and_set_head current_head, Node[value, current_head]
-      end
-    end
-
-    # @return [Node]
-    def peek
-      head
-    end
-
-    # @param [Node] head
-    # @return [true, false]
-    def compare_and_pop(head)
-      compare_and_set_head head, head.next_node
-    end
-
-    # @return [Object]
-    def pop
-      while true
-        current_head = head
-        return current_head.value if compare_and_set_head current_head, current_head.next_node
-      end
-    end
-
-    # @param [Node] head
-    # @return [true, false]
-    def compare_and_clear(head)
-      compare_and_set_head head, EMPTY
-    end
-
-    include Enumerable
-
-    # @param [Node] head
-    # @return [self]
-    def each(head = nil)
-      return to_enum(:each, head) unless block_given?
-      it = head || peek
-      until it.equal?(EMPTY)
-        yield it.value
-        it = it.next_node
-      end
-      self
-    end
-
-    # @return [true, false]
-    def clear
-      while true
-        current_head = head
-        return false if current_head == EMPTY
-        return true if compare_and_set_head current_head, EMPTY
-      end
-    end
-
-    # @param [Node] head
-    # @return [true, false]
-    def clear_if(head)
-      compare_and_set_head head, EMPTY
-    end
-
-    # @param [Node] head
-    # @param [Node] new_head
-    # @return [true, false]
-    def replace_if(head, new_head)
-      compare_and_set_head head, new_head
-    end
-
-    # @return [self]
-    # @yield over the cleared stack
-    # @yieldparam [Object] value
-    def clear_each(&block)
-      while true
-        current_head = head
-        return self if current_head == EMPTY
-        if compare_and_set_head current_head, EMPTY
-          each current_head, &block
-          return self
-        end
-      end
-    end
-
-    # @return [String] Short string representation.
-    def to_s
-      format '%s %s>', super[0..-2], to_a.to_s
-    end
-
-    alias_method :inspect, :to_s
-  end
-end