Enum.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) 2010, 2011 Wayne Meissner
  15.  *
  16.  * Alternatively, the contents of this file may be used under the terms of
  17.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  18.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  19.  * in which case the provisions of the GPL or the LGPL are applicable instead
  20.  * of those above. If you wish to allow use of your version of this file only
  21.  * under the terms of either the GPL or the LGPL, and not to allow others to
  22.  * use your version of this file under the terms of the EPL, indicate your
  23.  * decision by deleting the provisions above and replace them with the notice
  24.  * and other provisions required by the GPL or the LGPL. If you do not delete
  25.  * the provisions above, a recipient may use your version of this file under
  26.  * the terms of any one of the EPL, the GPL or the LGPL.
  27.  ***** END LICENSE BLOCK *****/

  29. package org.jruby.ext.ffi;

  31. import java.util.IdentityHashMap;
  32. import java.util.Map;
  33. import java.util.concurrent.ConcurrentHashMap;
  34. import org.jruby.anno.JRubyClass;
  35. import org.jruby.anno.JRubyMethod;
  36. import org.jruby.Ruby;
  37. import org.jruby.RubyArray;
  38. import org.jruby.RubyClass;
  39. import org.jruby.RubyFixnum;
  40. import org.jruby.RubyHash;
  41. import org.jruby.RubyInteger;
  42. import org.jruby.RubyModule;
  43. import org.jruby.RubyObject;
  44. import org.jruby.RubySymbol;
  45. import org.jruby.runtime.builtin.IRubyObject;
  46. import org.jruby.runtime.ObjectAllocator;
  47. import org.jruby.runtime.ThreadContext;
  48. import org.jruby.runtime.Visibility;

  50. /**
  51.  * Represents a C enum
  52.  */
  53. @JRubyClass(name="FFI::Enum", parent="Object")
  54. public final class Enum extends RubyObject {
  55.     private IRubyObject nativeType;
  56.     private final RubyHash kv_map;
  57.     private volatile IRubyObject tag;

  59.     private volatile Map<RubySymbol, RubyInteger> symbolToValue = new IdentityHashMap<RubySymbol, RubyInteger>();
  60.     private volatile ConcurrentHashMap<Long, RubySymbol> valueToSymbol = new ConcurrentHashMap<Long, RubySymbol>();

  62.     public static RubyClass createEnumClass(Ruby runtime, RubyModule ffiModule) {
  63.         RubyClass enumClass = ffiModule.defineClassUnder("Enum", runtime.getObject(),
  64.                 Allocator.INSTANCE);
  65.         enumClass.defineAnnotatedMethods(Enum.class);
  66.         enumClass.defineAnnotatedConstants(Enum.class);
  67.         enumClass.includeModule(ffiModule.getConstant("DataConverter"));
  68.         
  69.         return enumClass;
  70.     }

  72.     private static final class Allocator implements ObjectAllocator {
  73.         private static final ObjectAllocator INSTANCE = new Allocator();

  75.         public final IRubyObject allocate(Ruby runtime, RubyClass klass) {
  76.             return new Enum(runtime, klass);
  77.         }
  78.     }

  80.     private Enum(Ruby runtime, RubyClass klass) {
  81.         super(runtime, klass);
  82.         kv_map = RubyHash.newHash(runtime);
  83.         tag = runtime.getNil();
  84.     }

  86.     @JRubyMethod(name = "initialize", visibility = Visibility.PRIVATE)
  87.     public final IRubyObject initialize(ThreadContext context, IRubyObject arg) {
  88.         return initialize(context, null, null, arg);
  89.     }

  91.     @JRubyMethod(name = "initialize", visibility = Visibility.PRIVATE)
  92.     public final IRubyObject initialize(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
  93.         if (arg0 instanceof org.jruby.ext.ffi.Type)
  94.             return initialize(context, arg0, arg1, null);

  96.         if (arg1.isNil())
  97.             return initialize(context, null, arg0, null);

  99.         // Handles bad args and tag, values case.
  100.         return initialize(context, null, arg0, arg1);
  101.     }

  103.     @JRubyMethod(name = "initialize", visibility = Visibility.PRIVATE)
  104.     public final IRubyObject initialize(ThreadContext context, IRubyObject type, IRubyObject values, IRubyObject tag) {
  105.         int offset = 0;
  106.         if (type instanceof org.jruby.ext.ffi.Type) {
  107.             nativeType = type;
  108.         } else {
  109.             if (!(type == null || type.isNil()))
  110.                 throw context.runtime.newTypeError(type, context.runtime.getModule("FFI").getClass("Type"));

  112.             nativeType = context.runtime.getModule("FFI").getClass("Type").getConstant("INT");
  113.         }

  115.         if (!(tag == null || tag.isNil() || tag instanceof RubySymbol))
  116.             throw context.runtime.newTypeError(tag, context.runtime.getSymbol());

  118.         this.tag = tag;

  120.         if (!(values instanceof RubyArray)) {
  121.             throw context.runtime.newTypeError(values, context.runtime.getArray());
  122.         }

  124.         RubyArray ary = (RubyArray) values;

  126.         Map<RubySymbol, RubyInteger> s2v = new IdentityHashMap<RubySymbol, RubyInteger>();
  127.         IRubyObject prevConstant = null;
  128.         long nextValue = 0;

  130.         for (int i = 0; i < ary.size(); i++) {
  131.             IRubyObject v = ary.entry(i);

  133.             if (v instanceof RubySymbol) {
  134.                 s2v.put((RubySymbol) v, RubyFixnum.newFixnum(context.runtime, nextValue));
  135.                 prevConstant = v;
  136.                 nextValue++;

  138.             } else if (v instanceof RubyInteger) {
  139.                 if (prevConstant == null) {
  140.                     throw context.runtime.newArgumentError("invalid enum sequence - no symbol for value "
  141.                             + v);
  142.                 }
  143.                 s2v.put((RubySymbol) prevConstant, (RubyFixnum) v);
  144.                 nextValue = ((RubyInteger) v).getLongValue() + 1;

  146.             } else {
  147.                 throw context.runtime.newTypeError(v, context.runtime.getSymbol());
  148.             }
  149.         }

  151.         symbolToValue = new IdentityHashMap<RubySymbol, RubyInteger>(s2v);
  152.         valueToSymbol = new ConcurrentHashMap<Long, RubySymbol>(symbolToValue.size());
  153.         for (Map.Entry<RubySymbol, RubyInteger> e : symbolToValue.entrySet()) {
  154.             kv_map.fastASet(e.getKey(), e.getValue());
  155.             valueToSymbol.put(e.getValue().getLongValue(), e.getKey());
  156.         }

  158.         return this;
  159.     }

  161.     @JRubyMethod(name = { "[]", "find" })
  162.     public final IRubyObject find(ThreadContext context, IRubyObject query) {
  163.         if (query instanceof RubySymbol) {
  164.             IRubyObject value = kv_map.fastARef(query);
  165.             return value != null ? value : context.runtime.getNil();

  167.         } else if (query instanceof RubyInteger) {
  168.             RubySymbol symbol = valueToSymbol.get((Long)((RubyInteger) query).getLongValue());
  169.             return symbol != null ? symbol : context.runtime.getNil();

  171.         } else {
  172.             return context.runtime.getNil();
  173.         }
  174.     }

  176.     @JRubyMethod(name = { "symbol_map", "to_h", "to_hash" })
  177.     public final IRubyObject symbol_map(ThreadContext context) {
  178.         return kv_map.dup(context);
  179.     }

  181.     @JRubyMethod(name = { "symbols" })
  182.     public final IRubyObject symbols(ThreadContext context) {
  183.         return kv_map.keys();
  184.     }

  186.     @JRubyMethod(name = { "tag" })
  187.     public final IRubyObject tag(ThreadContext context) {
  188.         return tag;
  189.     }

  191.     @JRubyMethod(name = "native_type")
  192.     public final IRubyObject native_type(ThreadContext context) {
  193.         return nativeType;
  194.     }

  196.     @JRubyMethod(name = "to_native")
  197.     public final IRubyObject to_native(ThreadContext context, IRubyObject name, IRubyObject ctx) {
  198.         RubyInteger value;

  200.         if (name instanceof RubyFixnum) {
  201.             return name;

  203.         } else if (name instanceof RubySymbol && (value = symbolToValue.get(name)) != null) {
  204.             return value;

  206.         } else if (name instanceof RubyInteger) {
  207.             return name;

  209.         } else if (name.respondsTo("to_int")) {

  211.             return name.convertToInteger();

  213.         } else {
  214.             throw name.getRuntime().newArgumentError("invalid enum value, " + name.inspect());
  215.         }
  216.     }

  218.     @JRubyMethod(name = "from_native")
  219.     public final IRubyObject from_native(ThreadContext context, IRubyObject value, IRubyObject ctx) {

  221.         RubySymbol sym;

  223.         if (value instanceof RubyInteger && (sym = valueToSymbol.get((Long)((RubyInteger) value).getLongValue())) != null) {
  224.             return sym;
  225.         }

  227.         return value;
  228.     }

  230.     @JRubyMethod(name = "reference_required?")
  231.     public IRubyObject reference_required_p(ThreadContext context) {
  232.         return context.runtime.getFalse();
  233.     }
  234. }
Created with JaCoCo 0.7.3.201501050207