logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/ext/concurrent-ruby/com/concurrent_ruby/ext/JRubyMapBackendLibrary.java

@@ -1,248 +0,0 @@
-package com.concurrent_ruby.ext;
-
-import org.jruby.*;
-import org.jruby.anno.JRubyClass;
-import org.jruby.anno.JRubyMethod;
-import com.concurrent_ruby.ext.jsr166e.ConcurrentHashMap;
-import com.concurrent_ruby.ext.jsr166e.ConcurrentHashMapV8;
-import com.concurrent_ruby.ext.jsr166e.nounsafe.*;
-import org.jruby.runtime.Block;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.load.Library;
-
-import java.io.IOException;
-import java.util.Map;
-
-import static org.jruby.runtime.Visibility.PRIVATE;
-
-/**
- * Native Java implementation to avoid the JI overhead.
- *
- * @author thedarkone
- */
-public class JRubyMapBackendLibrary implements Library {
-  public void load(Ruby runtime, boolean wrap) throws IOException {
-
-    RubyModule concurrentMod = runtime.defineModule("Concurrent");
-    RubyModule thread_safeMod = concurrentMod.defineModuleUnder("Collection");
-    RubyClass jrubyRefClass = thread_safeMod.defineClassUnder("JRubyMapBackend", runtime.getObject(), BACKEND_ALLOCATOR);
-    jrubyRefClass.setAllocator(BACKEND_ALLOCATOR);
-    jrubyRefClass.defineAnnotatedMethods(JRubyMapBackend.class);
-  }
-
-  private static final ObjectAllocator BACKEND_ALLOCATOR = new ObjectAllocator() {
-    public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-      return new JRubyMapBackend(runtime, klazz);
-    }
-  };
-
-  @JRubyClass(name="JRubyMapBackend", parent="Object")
-    public static class JRubyMapBackend extends RubyObject {
-      // Defaults used by the CHM
-      static final int DEFAULT_INITIAL_CAPACITY = 16;
-      static final float DEFAULT_LOAD_FACTOR = 0.75f;
-
-      public static final boolean CAN_USE_UNSAFE_CHM = canUseUnsafeCHM();
-
-      private ConcurrentHashMap<IRubyObject, IRubyObject> map;
-
-      private static ConcurrentHashMap<IRubyObject, IRubyObject> newCHM(int initialCapacity, float loadFactor) {
-        if (CAN_USE_UNSAFE_CHM) {
-          return new ConcurrentHashMapV8<IRubyObject, IRubyObject>(initialCapacity, loadFactor);
-        } else {
-          return new com.concurrent_ruby.ext.jsr166e.nounsafe.ConcurrentHashMapV8<IRubyObject, IRubyObject>(initialCapacity, loadFactor);
-        }
-      }
-
-      private static ConcurrentHashMap<IRubyObject, IRubyObject> newCHM() {
-        return newCHM(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
-      }
-
-      private static boolean canUseUnsafeCHM() {
-        try {
-          new com.concurrent_ruby.ext.jsr166e.ConcurrentHashMapV8(); // force class load and initialization
-          return true;
-        } catch (Throwable t) { // ensuring we really do catch everything
-          // Doug's Unsafe setup errors always have this "Could not ini.." message
-          if (isCausedBySecurityException(t)) {
-            return false;
-          }
-          throw (t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t));
-        }
-      }
-
-      private static boolean isCausedBySecurityException(Throwable t) {
-        while (t != null) {
-          if ((t.getMessage() != null && t.getMessage().contains("Could not initialize intrinsics")) || t instanceof SecurityException) {
-            return true;
-          }
-          t = t.getCause();
-        }
-        return false;
-      }
-
-      public JRubyMapBackend(Ruby runtime, RubyClass klass) {
-        super(runtime, klass);
-      }
-
-      @JRubyMethod
-      public IRubyObject initialize(ThreadContext context) {
-        map = newCHM();
-        return context.getRuntime().getNil();
-      }
-
-      @JRubyMethod
-      public IRubyObject initialize(ThreadContext context, IRubyObject options) {
-        map = toCHM(context, options);
-        return context.getRuntime().getNil();
-      }
-
-      private ConcurrentHashMap<IRubyObject, IRubyObject> toCHM(ThreadContext context, IRubyObject options) {
-        Ruby runtime = context.getRuntime();
-        if (!options.isNil() && options.respondsTo("[]")) {
-          IRubyObject rInitialCapacity = options.callMethod(context, "[]", runtime.newSymbol("initial_capacity"));
-          IRubyObject rLoadFactor      = options.callMethod(context, "[]", runtime.newSymbol("load_factor"));
-          int initialCapacity = !rInitialCapacity.isNil() ? RubyNumeric.num2int(rInitialCapacity.convertToInteger()) : DEFAULT_INITIAL_CAPACITY;
-          float loadFactor    = !rLoadFactor.isNil() ?      (float)RubyNumeric.num2dbl(rLoadFactor.convertToFloat()) : DEFAULT_LOAD_FACTOR;
-          return newCHM(initialCapacity, loadFactor);
-        } else {
-          return newCHM();
-        }
-      }
-
-      @JRubyMethod(name = "[]", required = 1)
-        public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
-          IRubyObject value;
-          return ((value = map.get(key)) == null) ? context.getRuntime().getNil() : value;
-        }
-
-      @JRubyMethod(name = {"[]="}, required = 2)
-        public IRubyObject op_aset(IRubyObject key, IRubyObject value) {
-          map.put(key, value);
-          return value;
-        }
-
-      @JRubyMethod
-      public IRubyObject put_if_absent(IRubyObject key, IRubyObject value) {
-        IRubyObject result = map.putIfAbsent(key, value);
-        return result == null ? getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public IRubyObject compute_if_absent(final ThreadContext context, final IRubyObject key, final Block block) {
-        return map.computeIfAbsent(key, new ConcurrentHashMap.Fun<IRubyObject, IRubyObject>() {
-          @Override
-          public IRubyObject apply(IRubyObject key) {
-            return block.yieldSpecific(context);
-          }
-        });
-      }
-
-      @JRubyMethod
-      public IRubyObject compute_if_present(final ThreadContext context, final IRubyObject key, final Block block) {
-        IRubyObject result = map.computeIfPresent(key, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
-          @Override
-          public IRubyObject apply(IRubyObject key, IRubyObject oldValue) {
-            IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
-            return result.isNil() ? null : result;
-          }
-        });
-        return result == null ? context.getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public IRubyObject compute(final ThreadContext context, final IRubyObject key, final Block block) {
-        IRubyObject result = map.compute(key, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
-          @Override
-          public IRubyObject apply(IRubyObject key, IRubyObject oldValue) {
-            IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
-            return result.isNil() ? null : result;
-          }
-        });
-        return result == null ? context.getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public IRubyObject merge_pair(final ThreadContext context, final IRubyObject key, final IRubyObject value, final Block block) {
-        IRubyObject result = map.merge(key, value, new ConcurrentHashMap.BiFun<IRubyObject, IRubyObject, IRubyObject>() {
-          @Override
-          public IRubyObject apply(IRubyObject oldValue, IRubyObject newValue) {
-            IRubyObject result = block.yieldSpecific(context, oldValue == null ? context.getRuntime().getNil() : oldValue);
-            return result.isNil() ? null : result;
-          }
-        });
-        return result == null ? context.getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public RubyBoolean replace_pair(IRubyObject key, IRubyObject oldValue, IRubyObject newValue) {
-        return getRuntime().newBoolean(map.replace(key, oldValue, newValue));
-      }
-
-      @JRubyMethod(name = "key?", required = 1)
-        public RubyBoolean has_key_p(IRubyObject key) {
-          return map.containsKey(key) ? getRuntime().getTrue() : getRuntime().getFalse();
-        }
-
-      @JRubyMethod
-      public IRubyObject key(IRubyObject value) {
-        final IRubyObject key = map.findKey(value);
-        return key == null ? getRuntime().getNil() : key;
-      }
-
-      @JRubyMethod
-      public IRubyObject replace_if_exists(IRubyObject key, IRubyObject value) {
-        IRubyObject result = map.replace(key, value);
-        return result == null ? getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public IRubyObject get_and_set(IRubyObject key, IRubyObject value) {
-        IRubyObject result = map.put(key, value);
-        return result == null ? getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public IRubyObject delete(IRubyObject key) {
-        IRubyObject result = map.remove(key);
-        return result == null ? getRuntime().getNil() : result;
-      }
-
-      @JRubyMethod
-      public RubyBoolean delete_pair(IRubyObject key, IRubyObject value) {
-        return getRuntime().newBoolean(map.remove(key, value));
-      }
-
-      @JRubyMethod
-      public IRubyObject clear() {
-        map.clear();
-        return this;
-      }
-
-      @JRubyMethod
-      public IRubyObject each_pair(ThreadContext context, Block block) {
-        for (Map.Entry<IRubyObject,IRubyObject> entry : map.entrySet()) {
-          block.yieldSpecific(context, entry.getKey(), entry.getValue());
-        }
-        return this;
-      }
-
-      @JRubyMethod
-      public RubyFixnum size(ThreadContext context) {
-        return context.getRuntime().newFixnum(map.size());
-      }
-
-      @JRubyMethod
-      public IRubyObject get_or_default(IRubyObject key, IRubyObject defaultValue) {
-        return map.getValueOrDefault(key, defaultValue);
-      }
-
-      @JRubyMethod(visibility = PRIVATE)
-        public JRubyMapBackend initialize_copy(ThreadContext context, IRubyObject other) {
-          map = newCHM();
-          return this;
-        }
-    }
-}

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicBooleanLibrary.java

@@ -1,93 +0,0 @@
-package com.concurrent_ruby.ext;
-
-import org.jruby.Ruby;
-import org.jruby.RubyBoolean;
-import org.jruby.RubyClass;
-import org.jruby.RubyModule;
-import org.jruby.RubyNil;
-import org.jruby.RubyObject;
-import org.jruby.anno.JRubyClass;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.load.Library;
-
-import java.io.IOException;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class JavaAtomicBooleanLibrary implements Library {
-
-    public void load(Ruby runtime, boolean wrap) throws IOException {
-        RubyModule concurrentMod = runtime.defineModule("Concurrent");
-        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicBoolean", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
-        atomicCls.defineAnnotatedMethods(JavaAtomicBoolean.class);
-    }
-
-    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new JavaAtomicBoolean(runtime, klazz);
-        }
-    };
-
-    @JRubyClass(name = "JavaAtomicBoolean", parent = "Object")
-    public static class JavaAtomicBoolean extends RubyObject {
-
-        private AtomicBoolean atomicBoolean;
-
-        public JavaAtomicBoolean(Ruby runtime, RubyClass metaClass) {
-            super(runtime, metaClass);
-        }
-
-        @JRubyMethod
-        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
-            atomicBoolean = new AtomicBoolean(convertRubyBooleanToJavaBoolean(value));
-            return context.nil;
-        }
-
-        @JRubyMethod
-        public IRubyObject initialize(ThreadContext context) {
-            atomicBoolean = new AtomicBoolean();
-            return context.nil;
-        }
-
-        @JRubyMethod(name = "value")
-        public IRubyObject value() {
-            return getRuntime().newBoolean(atomicBoolean.get());
-        }
-
-        @JRubyMethod(name = "true?")
-        public IRubyObject isAtomicTrue() {
-            return getRuntime().newBoolean(atomicBoolean.get());
-        }
-
-        @JRubyMethod(name = "false?")
-        public IRubyObject isAtomicFalse() {
-            return getRuntime().newBoolean((atomicBoolean.get() == false));
-        }
-
-        @JRubyMethod(name = "value=")
-        public IRubyObject setAtomic(ThreadContext context, IRubyObject newValue) {
-            atomicBoolean.set(convertRubyBooleanToJavaBoolean(newValue));
-            return context.nil;
-        }
-
-        @JRubyMethod(name = "make_true")
-        public IRubyObject makeTrue() {
-            return getRuntime().newBoolean(atomicBoolean.compareAndSet(false, true));
-        }
-
-        @JRubyMethod(name = "make_false")
-        public IRubyObject makeFalse() {
-            return getRuntime().newBoolean(atomicBoolean.compareAndSet(true, false));
-        }
-
-        private boolean convertRubyBooleanToJavaBoolean(IRubyObject newValue) {
-            if (newValue instanceof RubyBoolean.False || newValue instanceof RubyNil) {
-                return false;
-            } else {
-                return true;
-            }
-        }
-    }
-}

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/ext/concurrent-ruby/com/concurrent_ruby/ext/JavaAtomicFixnumLibrary.java

@@ -1,113 +0,0 @@
-package com.concurrent_ruby.ext;
-
-import java.io.IOException;
-import java.util.concurrent.atomic.AtomicLong;
-import org.jruby.Ruby;
-import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyModule;
-import org.jruby.RubyObject;
-import org.jruby.anno.JRubyClass;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.load.Library;
-import org.jruby.runtime.Block;
-
-public class JavaAtomicFixnumLibrary implements Library {
-
-    public void load(Ruby runtime, boolean wrap) throws IOException {
-        RubyModule concurrentMod = runtime.defineModule("Concurrent");
-        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicFixnum", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
-
-        atomicCls.defineAnnotatedMethods(JavaAtomicFixnum.class);
-    }
-
-    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new JavaAtomicFixnum(runtime, klazz);
-        }
-    };
-
-    @JRubyClass(name = "JavaAtomicFixnum", parent = "Object")
-    public static class JavaAtomicFixnum extends RubyObject {
-
-        private AtomicLong atomicLong;
-
-        public JavaAtomicFixnum(Ruby runtime, RubyClass metaClass) {
-            super(runtime, metaClass);
-        }
-
-        @JRubyMethod
-        public IRubyObject initialize(ThreadContext context) {
-            this.atomicLong = new AtomicLong(0);
-            return context.nil;
-        }
-
-        @JRubyMethod
-        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
-            this.atomicLong = new AtomicLong(rubyFixnumToLong(value));
-            return context.nil;
-        }
-
-        @JRubyMethod(name = "value")
-        public IRubyObject getValue() {
-            return getRuntime().newFixnum(atomicLong.get());
-        }
-
-        @JRubyMethod(name = "value=")
-        public IRubyObject setValue(ThreadContext context, IRubyObject newValue) {
-            atomicLong.set(rubyFixnumToLong(newValue));
-            return context.nil;
-        }
-
-        @JRubyMethod(name = {"increment", "up"})
-        public IRubyObject increment() {
-            return getRuntime().newFixnum(atomicLong.incrementAndGet());
-        }
-
-        @JRubyMethod(name = {"increment", "up"})
-        public IRubyObject increment(IRubyObject value) {
-            long delta = rubyFixnumToLong(value);
-            return getRuntime().newFixnum(atomicLong.addAndGet(delta));
-        }
-
-        @JRubyMethod(name = {"decrement", "down"})
-        public IRubyObject decrement() {
-            return getRuntime().newFixnum(atomicLong.decrementAndGet());
-        }
-
-        @JRubyMethod(name = {"decrement", "down"})
-        public IRubyObject decrement(IRubyObject value) {
-            long delta = rubyFixnumToLong(value);
-            return getRuntime().newFixnum(atomicLong.addAndGet(-delta));
-        }
-
-        @JRubyMethod(name = "compare_and_set")
-        public IRubyObject compareAndSet(ThreadContext context, IRubyObject expect, IRubyObject update) {
-            return getRuntime().newBoolean(atomicLong.compareAndSet(rubyFixnumToLong(expect), rubyFixnumToLong(update)));
-        }
-
-        @JRubyMethod
-        public IRubyObject update(ThreadContext context, Block block) {
-            for (;;) {
-                long _oldValue       = atomicLong.get();
-                IRubyObject oldValue = getRuntime().newFixnum(_oldValue);
-                IRubyObject newValue = block.yield(context, oldValue);
-                if (atomicLong.compareAndSet(_oldValue, rubyFixnumToLong(newValue))) {
-                    return newValue;
-                }
-            }
-        }
-
-        private long rubyFixnumToLong(IRubyObject value) {
-            if (value instanceof RubyFixnum) {
-                RubyFixnum fixNum = (RubyFixnum) value;
-                return fixNum.getLongValue();
-            } else {
-                throw getRuntime().newArgumentError("value must be a Fixnum");
-            }
-        }
-    }
-}