RubyObjectSpace.java

  1. /***** BEGIN LICENSE BLOCK *****
  2.  * Version: EPL 1.0/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Eclipse Public
  5.  * License Version 1.0 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.eclipse.org/legal/epl-v10.html
  8.  *
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  *
  14.  * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
  15.  * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  16.  * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  17.  * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>
  18.  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the terms of
  21.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  22.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  23.  * in which case the provisions of the GPL or the LGPL are applicable instead
  24.  * of those above. If you wish to allow use of your version of this file only
  25.  * under the terms of either the GPL or the LGPL, and not to allow others to
  26.  * use your version of this file under the terms of the EPL, indicate your
  27.  * decision by deleting the provisions above and replace them with the notice
  28.  * and other provisions required by the GPL or the LGPL. If you do not delete
  29.  * the provisions above, a recipient may use your version of this file under
  30.  * the terms of any one of the EPL, the GPL or the LGPL.
  31.  ***** END LICENSE BLOCK *****/
  32. package org.jruby;

  34. import java.util.ArrayList;
  35. import java.util.Collection;
  36. import static org.jruby.RubyEnumerator.enumeratorize;

  38. import java.util.Iterator;

  40. import org.jruby.anno.JRubyMethod;
  41. import org.jruby.anno.JRubyModule;
  42. import org.jruby.runtime.Block;
  43. import org.jruby.runtime.ObjectAllocator;
  44. import org.jruby.runtime.ThreadContext;
  45. import static org.jruby.runtime.Visibility.*;
  46. import org.jruby.runtime.builtin.IRubyObject;
  47. import org.jruby.util.collections.WeakValuedIdentityMap;
  48. import org.jruby.util.func.Function1;

  50. @JRubyModule(name="ObjectSpace")
  51. public class RubyObjectSpace {

  53.     /** Create the ObjectSpace module and add it to the Ruby runtime.
  54.      * 
  55.      */
  56.     public static RubyModule createObjectSpaceModule(Ruby runtime) {
  57.         RubyModule objectSpaceModule = runtime.defineModule("ObjectSpace");
  58.         runtime.setObjectSpaceModule(objectSpaceModule);
  59.         
  60.         objectSpaceModule.defineAnnotatedMethods(RubyObjectSpace.class);

  62.         WeakMap.createWeakMap(runtime);

  64.         return objectSpaceModule;
  65.     }

  67.     @JRubyMethod(required = 1, optional = 1, module = true, visibility = PRIVATE)
  68.     public static IRubyObject define_finalizer(IRubyObject recv, IRubyObject[] args, Block block) {
  69.         Ruby runtime = recv.getRuntime();
  70.         IRubyObject finalizer = null;
  71.         if (args.length == 2) {
  72.             finalizer = args[1];
  73.             if (!finalizer.respondsTo("call")) {
  74.                 throw runtime.newArgumentError("wrong type argument "
  75.                         + finalizer.getType() + " (should be callable)");
  76.             }
  77.         } else {
  78.             finalizer = runtime.newProc(Block.Type.PROC, block);
  79.         }
  80.         IRubyObject obj = args[0];
  81.         runtime.getObjectSpace().addFinalizer(obj, finalizer);
  82.         return runtime.newArray(RubyFixnum.zero(runtime), finalizer);
  83.     }

  85.     @JRubyMethod(required = 1, module = true, visibility = PRIVATE)
  86.     public static IRubyObject undefine_finalizer(IRubyObject recv, IRubyObject arg1, Block block) {
  87.         recv.getRuntime().getObjectSpace().removeFinalizers(RubyNumeric.fix2long(arg1.id()));
  88.         return recv;
  89.     }

  91.     @JRubyMethod(name = "_id2ref", required = 1, module = true, visibility = PRIVATE)
  92.     public static IRubyObject id2ref(IRubyObject recv, IRubyObject id) {
  93.         Ruby runtime = id.getRuntime();
  94.         if (!(id instanceof RubyFixnum)) {
  95.             throw recv.getRuntime().newTypeError(id, recv.getRuntime().getFixnum());
  96.         }
  97.         RubyFixnum idFixnum = (RubyFixnum) id;
  98.         long longId = idFixnum.getLongValue();
  99.         if (longId == 0) {
  100.             return runtime.getFalse();
  101.         } else if (longId == 20) {
  102.             return runtime.getTrue();
  103.         } else if (longId == 8) {
  104.             return runtime.getNil();
  105.         } else if (longId % 2 != 0) {
  106.             // odd
  107.             return runtime.newFixnum((longId - 1) / 2);
  108.         } else {
  109.             if (runtime.isObjectSpaceEnabled()) {
  110.                 IRubyObject object = runtime.getObjectSpace().id2ref(longId);
  111.                 if (object == null) {
  112.                     return runtime.getNil();
  113.                 }
  114.                 return object;
  115.             } else {
  116.                 runtime.getWarnings().warn("ObjectSpace is disabled; _id2ref only supports immediates, pass -X+O to enable");
  117.                 return runtime.getNil();
  118.             }
  119.         }
  120.     }
  121.     
  122.     public static IRubyObject each_objectInternal(final ThreadContext context, IRubyObject recv, IRubyObject[] args, final Block block) {
  123.         RubyModule tmpClass;
  124.         if (args.length == 0) {
  125.             tmpClass = recv.getRuntime().getObject();
  126.         } else {
  127.             if (!(args[0] instanceof RubyModule)) throw recv.getRuntime().newTypeError("class or module required");
  128.             tmpClass = (RubyModule) args[0];
  129.         }
  130.         final RubyModule rubyClass = tmpClass;
  131.         Ruby runtime = recv.getRuntime();
  132.         final int[] count = {0};
  133.         if (rubyClass == runtime.getClassClass() ||
  134.                 rubyClass == runtime.getModule()) {
  135.             final Collection<IRubyObject> modules = new ArrayList<IRubyObject>();
  136.             runtime.eachModule(new Function1<Object, IRubyObject>() {
  137.                 public Object apply(IRubyObject arg1) {
  138.                     if (rubyClass.isInstance(arg1)) {
  139.                         if (arg1 instanceof IncludedModule ||
  140.                                 (arg1 instanceof RubyClass && ((RubyClass)arg1).isSingleton())) {
  141.                             // do nothing for included wrappers or singleton classes
  142.                         } else {
  143.                             count[0]++;
  144.                             modules.add(arg1); // store the module to avoid concurrent modification exceptions
  145.                         }
  146.                     }
  147.                     return null;
  148.                 }
  149.             });

  151.             for (IRubyObject arg : modules) {
  152.                 block.yield(context, arg);
  153.             }
  154.         } else {
  155.             if (!runtime.isObjectSpaceEnabled()) {
  156.                 throw runtime.newRuntimeError("ObjectSpace is disabled; each_object will only work with Class, pass -X+O to enable");
  157.             }
  158.             Iterator iter = recv.getRuntime().getObjectSpace().iterator(rubyClass);

  160.             IRubyObject obj = null;
  161.             while ((obj = (IRubyObject)iter.next()) != null) {
  162.                 count[0]++;
  163.                 block.yield(context, obj);
  164.             }
  165.         }
  166.         return recv.getRuntime().newFixnum(count[0]);
  167.     }

  169.     @JRubyMethod(name = "each_object", optional = 1, module = true, visibility = PRIVATE)
  170.     public static IRubyObject each_object(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
  171.         return block.isGiven() ? each_objectInternal(context, recv, args, block) : enumeratorize(context.runtime, recv, "each_object", args);
  172.     }

  174.     @JRubyMethod(name = "garbage_collect", module = true, visibility = PRIVATE)
  175.     public static IRubyObject garbage_collect(ThreadContext context, IRubyObject recv) {
  176.         return RubyGC.start(context, recv);
  177.     }

  179.     public static class WeakMap extends RubyObject {
  180.         static void createWeakMap(Ruby runtime) {
  181.             RubyClass weakMap = runtime.getObjectSpaceModule().defineClassUnder("WeakMap", runtime.getObject(), new ObjectAllocator() {
  182.                 public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
  183.                     return new WeakMap(runtime, klazz);
  184.                 }
  185.             });

  187.             weakMap.defineAnnotatedMethods(WeakMap.class);
  188.         }

  190.         public WeakMap(Ruby runtime, RubyClass cls) {
  191.             super(runtime, cls);
  192.         }

  194.         @JRubyMethod(name = "[]")
  195.         public IRubyObject op_aref(ThreadContext context, IRubyObject key) {
  196.             IRubyObject value = map.get(key);
  197.             if (value != null) return value;
  198.             return context.nil;
  199.         }

  201.         @JRubyMethod(name = "[]=")
  202.         public IRubyObject op_aref(ThreadContext context, IRubyObject key, IRubyObject value) {
  203.             map.put(key, value);
  204.             return context.runtime.newFixnum(System.identityHashCode(value));
  205.         }

  207.         private final WeakValuedIdentityMap<IRubyObject, IRubyObject> map = new WeakValuedIdentityMap<IRubyObject, IRubyObject>();
  208.     }
  209. }
Created with JaCoCo 0.7.3.201501050207