Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse Public
   * License Version 1.0 (the "License"); you may not use this file
   * except in compliance with the License. You may obtain a copy of
   * the License at http://www.eclipse.org/legal/epl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  * 
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the EPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby.runtime;
 
 import java.util.Map;
 import org.jruby.Ruby;
The arity of a method is the number of arguments it takes.
 
 public final class Arity implements Serializable {
     private static final long serialVersionUID = 1L;
     private static final Map<IntegerArityarities = new HashMap<IntegerArity>();
     private final int value;
     
     public final static Arity NO_ARGUMENTS = newArity(0);
     public final static Arity ONE_ARGUMENT = newArity(1);
     public final static Arity TWO_ARGUMENTS = newArity(2);
     public final static Arity THREE_ARGUMENTS = newArity(3);
     public final static Arity OPTIONAL = newArity(-1);
     public final static Arity ONE_REQUIRED = newArity(-2);
     public final static Arity TWO_REQUIRED = newArity(-3);
     public final static Arity THREE_REQUIRED = newArity(-4);
 
     private Arity(int value) {
         this. = value;
     }
     
     private static Arity createArity(int requiredint optionalboolean rest) {
         return createArity((optional > 0 || rest) ? -(required + 1) : required);
     }
 
     public static Arity createArity(int value) {
         switch (value) {
         case -4:
             return ;
         case -3:
             return ;
         case -2:
             return ;
         case -1:
             return ;
         case 0:
             return ;
         case 1:
             return ;
         case 2:
             return ;
         case 3:
             return ;
         }
         return newArity(value);
     }
     
     public static Arity fromAnnotation(JRubyMethod anno) {
         return createArity(anno.required(), anno.optional(), anno.rest());
     }
     
     public static Arity fromAnnotation(JRubyMethod annoint required) {
         return createArity(requiredanno.optional(), anno.rest());
     }
    
    public static Arity fromAnnotation(JRubyMethod annoClass[] parameterTypesboolean isStatic) {
        int required;
        if (anno.optional() == 0 && !anno.rest() && anno.required() == 0) {
            // try count specific args to determine required
            int i = parameterTypes.length;
            if (isStatici--;
            if (parameterTypes.length > 0) {
                if (parameterTypes[0] == ThreadContext.classi--;
                if (parameterTypes[parameterTypes.length - 1] == Block.classi--;
            }
            required = i;
        } else {
            required = anno.required();
        }
        
        return createArity(requiredanno.optional(), anno.rest());
    }
    
    private static Arity newArity(int value) {
        Arity result;
        synchronized () {
            result = .get(value);
            if (result == null) {
                result = new Arity(value);
                .put(valueresult);
            }
        }
        return result;
    }
    public static Arity fixed(int arity) {
        assert arity >= 0;
        return createArity(arity);
    }
    public static Arity optional() {
        return ;
    }
    public static Arity required(int minimum) {
        assert minimum >= 0;
        return createArity(-(1 + minimum));
    }
    public static Arity noArguments() {
        return ;
    }
    public static Arity singleArgument() {
        return ;
    }
    public static Arity twoArguments() {
        return ;
    }
    
    public static Arity procArityOf(Node node) {
        if (node instanceof AttrAssignNode && node != null) {
            node = ((AttrAssignNodenode).getArgsNode();
        }
        if (node == null) {
            return Arity.optional();
        } else if (node instanceof IArityNode) {
            return ((IArityNodenode).getArity();
        } else if (node instanceof CallNode) {
            return Arity.singleArgument();
        } else if (node instanceof ArrayNode) {
            return Arity.singleArgument();
        } else if (node instanceof ArgsNode) {
            return ((ArgsNode)node).getArity();
        }
        throw new Error("unexpected type " + node.getClass() + " at " + node.getPosition());
    }
    public int getValue() {
        return ;
    }
    public void checkArity(Ruby runtimeIRubyObject[] args) {
		  checkArity(runtimeargs.length);
    }
    public void checkArity(Ruby runtimeint length) {
        if (isFixed()) {
            if (length != required()) {
                throw runtime.newArgumentError("wrong number of arguments (" + length + " for " + required() + ")");
            }
        } else {
            if (length < required()) {
                throw runtime.newArgumentError("wrong number of arguments (" + length + " for " + required() + ")");
            }
        }
    }
    public boolean isFixed() {
        return  >= 0;
    }
    public int required() {
        return  < 0 ? -(1 + ) : ;
    }
    @Override
    public boolean equals(Object other) {
        return this == other;
    }
    @Override
    public int hashCode() {
        return ;
    }
    @Override
    public String toString() {
        return isFixed() ? "Fixed" + required() : "Opt";
    }
    // Some helper functions:
    public static int checkArgumentCount(Ruby runtimeIRubyObject[] argsint minint max) {
        return checkArgumentCount(runtimeargs.lengthminmax);
    }
    public static int checkArgumentCount(ThreadContext contextIRubyObject[] argsint minint max) {
        return checkArgumentCount(contextargs.lengthminmax);
    }
    public static int checkArgumentCount(Ruby runtimeString nameIRubyObject[] argsint minint max) {
        return checkArgumentCount(runtimenameargs.lengthminmax);
    }
    public static int checkArgumentCount(Ruby runtimeint lengthint minint max) {
        raiseArgumentError(runtimelengthminmax);
        return length;
    }
    public static int checkArgumentCount(ThreadContext contextint lengthint minint max) {
        raiseArgumentError(contextlengthminmax);
        return length;
    }
    public static int checkArgumentCount(Ruby runtimeint lengthint minint maxboolean hasKwargs) {
        raiseArgumentError(runtimelengthminmaxhasKwargs);
        return length;
    }
    public static int checkArgumentCount(Ruby runtimeString nameint lengthint minint max) {
        raiseArgumentError(runtimenamelengthminmax);
        return length;
    }
    public static int checkArgumentCount(Ruby runtimeString nameint lengthint minint maxboolean hasKwargs) {
        raiseArgumentError(runtimenamelengthminmaxhasKwargs);
        return length;
    }
    
    // FIXME: JRuby 2/next should change this name since it only sometimes raises an error    
    public static void raiseArgumentError(Ruby runtimeIRubyObject[] argsint minint max) {
        raiseArgumentError(runtimeargs.lengthminmax);
    }
    // FIXME: JRuby 2/next should change this name since it only sometimes raises an error
    public static void raiseArgumentError(Ruby runtimeint lengthint minint max) {
        if (length < minthrow runtime.newArgumentError(lengthmin);
        if (max > -1 && length > maxthrow runtime.newArgumentError(lengthmax);
    }
    // FIXME: JRuby 2/next should change this name since it only sometimes raises an error
    public static void raiseArgumentError(ThreadContext contextint lengthint minint max) {
        if (length < minthrow context.runtime.newArgumentError(lengthmin);
        if (max > -1 && length > maxthrow context.runtime.newArgumentError(lengthmax);
    }
    // FIXME: JRuby 2/next should change this name since it only sometimes raises an error
    public static void raiseArgumentError(Ruby runtimeint lengthint minint maxboolean hasKwargs) {
        if (length < minthrow runtime.newArgumentError(lengthmin);
        if (max > -1 && length > max) {
            if (hasKwargs  && length == max + 1) {
                // we have an extra arg, but kwargs active; let it fall through to assignment
                return;
            }
            throw runtime.newArgumentError(lengthmax);
        }
    }
    // FIXME: JRuby 2/next should change this name since it only sometimes raises an error
    public static void raiseArgumentError(Ruby runtimeString nameint lengthint minint max) {
        if (length < minthrow runtime.newArgumentError(namelengthmin);
        if (max > -1 && length > maxthrow runtime.newArgumentError(namelengthmax);
    }
    // FIXME: JRuby 2/next should change this name since it only sometimes raises an error
    public static void raiseArgumentError(Ruby runtimeString nameint lengthint minint maxboolean hasKwargs) {
        if (length < minthrow runtime.newArgumentError(namelengthmin);
        if (max > -1 && length > max) {
            if (hasKwargs  && length == max + 1) {
                // we have an extra arg, but kwargs active; let it fall through to assignment
                return;
            }
            throw runtime.newArgumentError(namelengthmax);
        }
    }

    
    public static IRubyObject[] scanArgs(Ruby runtimeIRubyObject[] argsint requiredint optional) {
        int total = required+optional;
        int real = checkArgumentCount(runtimeargs,required,total);
        IRubyObject[] narr = new IRubyObject[total];
        System.arraycopy(args,0,narr,0,real);
        for(int i=reali<totali++) {
            narr[i] = runtime.getNil();
        }
        return narr;
    }
New to GrepCode? Check out our FAQ X