Performs conversions on argument types if needed and
invokes the underlying Java method or constructor.
<p>
Implements Function.call.

@see org.mozilla.javascript.Function#call(
Context, Scriptable, Scriptable, Object[])
554850
@Override
    public Object call(Context cx, Scriptable scope, Scriptable thisObj,
                       Object[] args)
    {
        Object result;
        boolean checkMethodResult = false;
        int argsLength = args.length;

        for (int i = 0; i < argsLength; i++) {
            // flatten cons-strings before passing them as arguments
            if (args[i] instanceof ConsString) {
                args[i] = args[i].toString();
            }
        }

        if (parmsLength < 0) {
            if (parmsLength == VARARGS_METHOD) {
                Object[] invokeArgs = { cx, thisObj, args, this };
                result = member.invoke(null, invokeArgs);
                checkMethodResult = true;
            } else {
                boolean inNewExpr = (thisObj == null);
                Boolean b = inNewExpr ? Boolean.TRUE : Boolean.FALSE;
                Object[] invokeArgs = { cx, args, this, b };
                result = (member.isCtor())
                         ? member.newInstance(invokeArgs)
                         : member.invoke(null, invokeArgs);
            }

        } else {
            if (!isStatic) {
                Class<?> clazz = member.getDeclaringClass();
                if (!clazz.isInstance(thisObj)) {
                    boolean compatible = false;
                    if (thisObj == scope) {
                        Scriptable parentScope = getParentScope();
                        if (scope != parentScope) {
                            // Call with dynamic scope for standalone function,
                            // use parentScope as thisObj
                            compatible = clazz.isInstance(parentScope);
                            if (compatible) {
                                thisObj = parentScope;
                            }
                        }
                    }
                    if (!compatible) {
                        // Couldn't find an object to call this on.
                        throw ScriptRuntime.typeError1("msg.incompat.call",
                                                       functionName);
                    }
                }
            }

            Object[] invokeArgs;
            if (parmsLength == argsLength) {
                // Do not allocate new argument array if java arguments are
                // the same as the original js ones.
                invokeArgs = args;
                for (int i = 0; i != parmsLength; ++i) {
                    Object arg = args[i];
                    Object converted = convertArg(cx, scope, arg, typeTags[i]);
                    if (arg != converted) {
                        if (invokeArgs == args) {
                            invokeArgs = args.clone();
                        }
                        invokeArgs[i] = converted;
                    }
                }
            } else if (parmsLength == 0) {
                invokeArgs = ScriptRuntime.emptyArgs;
            } else {
                invokeArgs = new Object[parmsLength];
                for (int i = 0; i != parmsLength; ++i) {
                    Object arg = (i < argsLength)
                                 ? args[i]
                                 : Undefined.instance;
                    invokeArgs[i] = convertArg(cx, scope, arg, typeTags[i]);
                }
            }

            if (member.isMethod()) {
                result = member.invoke(thisObj, invokeArgs);
                checkMethodResult = true;
            } else {
                result = member.newInstance(invokeArgs);
            }

        }

        if (checkMethodResult) {
            if (hasVoidReturn) {
                result = Undefined.instance;
            } else if (returnTypeTag == JAVA_UNSUPPORTED_TYPE) {
                result = cx.getWrapFactory().wrap(cx, scope, result, null);
            }
            // XXX: the code assumes that if returnTypeTag == JAVA_OBJECT_TYPE
            // then the Java method did a proper job of converting the
            // result to JS primitive or Scriptable to avoid
            // potentially costly Context.javaToJS call.
        }

        return result;
    }
886860
public Object call(Map<String, ?> params) throws Throwable {
    return AnnotatedExtensions.exec(getCallMethod(), getParameterNames(), params, this);
  }
1060489
@Override
    public Void call() throws Exception {
        OutputStream out = null;
        InputStream in = null;
        try {
            out = new FileOutputStream(destination);
            in = new FileInputStream(source);
            JasperCompileManager.compileReportToStream(in, out);
            if (verbose) {
                log.info("Compiling " + source.getName());
            }
        } catch (Exception e) {
            cleanUpAndThrowError(destination, e);
        } finally {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                in.close();
            }
        }
        return null;
    }
993199
public static void addArgument(MethodCallExpr call, Expression arg) {
        List<Expression> args = call.getArgs();
        if (args == null) {
            args = new ArrayList<Expression>();
            call.setArgs(args);
        }
        args.add(arg);
    }
1173891
def call(object, method, *args, &block)
      options = args.last.is_a?(Hash) ? args.pop : {}
      options = {:method_name => method}.merge(options)
      state = machine.states.match!(object)

      if state == self && object.respond_to?(method)
        object.send(method, *args, &block)
      elsif method_missing = options[:method_missing]
        # Dispatch to the superclass since the object either isn't in this state
        # or this state doesn't handle the method
        begin
          method_missing.call
        rescue NoMethodError => ex
          if ex.name.to_s == options[:method_name].to_s && ex.args == args
            # No valid context for this method
            raise InvalidContext.new(object, "State #{state.name.inspect} for #{machine.name.inspect} is not a valid context for calling ##{options[:method_name]}")
          else
            raise
          end
        end
      end
    end
856224
def call(event, *args)
      return unless @listeners[event]
      @listeners[event].each do |callback|
        callback.call(*args)
      end
    end
62764
public <V> V call(Callable<V> callable) throws Exception {
		initStartTotal();
		long startInvokation = System.currentTimeMillis();
		V result = callable.call();
		invoked(System.currentTimeMillis() - startInvokation);
		return result;
	}
992444
public static <T> T call(Callable<T> c)
   {
      if (c == null)
      {
         return null;
      }
      try
      {
         return c.call();
      }
      catch (RuntimeException e)
      {
         throw e;
      }
      catch (Exception e)
      {
         throw new RuntimeException("Error invoking Callable [c]", e);
      }
   }
367576
public static void main(String[] args)
    {
        Context cx = Context.enter();
        try {
            // Set version to JavaScript1.2 so that we get object-literal style
            // printing instead of "[object Object]"
            cx.setLanguageVersion(Context.VERSION_1_2);

            // Initialize the standard objects (Object, Function, etc.)
            // This must be done before scripts can be executed.
            Scriptable scope = cx.initStandardObjects();

            // Now we can evaluate a script. Let's create a new object
            // using the object literal notation.
            Object result = cx.evaluateString(scope, "obj = {a:1, b:['x','y']}",
                                              "MySource", 1, null);

            Scriptable obj = (Scriptable) scope.get("obj", scope);

            // Should print "obj == result" (Since the result of an assignment
            // expression is the value that was assigned)
            System.out.println("obj " + (obj == result ? "==" : "!=") +
                               " result");

            // Should print "obj.a == 1"
            System.out.println("obj.a == " + obj.get("a", obj));

            Scriptable b = (Scriptable) obj.get("b", obj);

            // Should print "obj.b[0] == x"
            System.out.println("obj.b[0] == " + b.get(0, b));

            // Should print "obj.b[1] == y"
            System.out.println("obj.b[1] == " + b.get(1, b));

            // Should print {a:1, b:["x", "y"]}
            Function fn = (Function) ScriptableObject.getProperty(obj, "toString");
            System.out.println(fn.call(cx, scope, obj, new Object[0]));
        } finally {
            Context.exit();
        }
    }
9697
function MethodCallExpression(name, args) {
    /**
     * Gets or sets the name of this method
     * @type {String}
     */
    this.name = name;
    /**
     * Gets or sets an array that represents the method arguments
     * @type {Array}
     */
    this.args = [];
    if (_.isArray(args))
        this.args = args;
}
305201
function callExitHandlers(context) {
    var i, n;
    for (i = 0, n = this.exits.length; i < n; i++) {
      this.exits[i].call(this, context);
    }
  }
894861
Callable<?> invokeMethod(MethodHandler methodHandler, Object[] arguments) {
    return () -> {
      try {
        return methodHandler.invoke(arguments);
      } catch (Throwable th) {
        if (th instanceof FeignException) {
          throw (FeignException) th;
        }
        throw new RuntimeException(th);
      }
    };
  }
315879
public Object call( Object object, String name, Object[] args )
        throws BSFException
    {
        /*
            If object is null use the interpreter's global scope.
        */
        if ( object == null )
            try {
                object = interpreter.get("global");
            } catch ( EvalError e ) {
                throw new BSFException(BSFException.REASON_OTHER_ERROR, "bsh internal error: "+e, e);
            }

        if ( object instanceof bsh.This )
            try
            {
                Object value = ((bsh.This)object).invokeMethod( name, args );
                return Primitive.unwrap( value );
            } catch ( InterpreterError e )
            {
                throw new BSFException(BSFException.REASON_UNKNOWN_LANGUAGE,
                    "BeanShell interpreter internal error: "+e, e);
            } catch ( TargetError e2 )
            {
                throw new BSFException(BSFException.REASON_EXECUTION_ERROR,
                    "The application script threw an exception: "
                    + e2.getTarget(), e2 );
            } catch ( EvalError e3 )
            {
                throw new BSFException(BSFException.REASON_OTHER_ERROR, "BeanShell script error: "+e3, e3);
            }
        else
            throw new BSFException(
                "Cannot invoke method: "+name
                +". Object: "+object +" is not a BeanShell scripted object.");
    }
1336802
function invoke(methodName) {
  var args = slice.call(arguments, 1)
  return function (object) {
    return object[methodName].apply(object, args)
  }
}
1087195
@Override public Object invokeMethod(final String name, final Object arguments) {
    if (GantState.dryRun) {
      if (GantState.verbosity > GantState.SILENT) {
        final StringBuilder sb = new StringBuilder();
        int padding = 9 - name.length();
        if (padding < 0) { padding = 0; }
        sb.append("         ".substring(0, padding) + '[' + name + "] ");
        final Object[] args = (Object[]) arguments;
        if (args[0] instanceof Map<?,?>) {
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Eclipse and IntelliJ IDEA warn that (Map) is not a proper cast but using the
          // cast (Map<?,?>) causes a type check error due to the capture algorithm.
          //
          //  TODO : Fix this rather than use a SuppressWarnings.
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          @SuppressWarnings({ "unchecked", "rawtypes" } ) final Iterator<Map.Entry<?,?>> i =((Map) args[0]).entrySet().iterator();
          while (i.hasNext()) {
            final Map.Entry<?,?> e = i.next();
            sb.append(e.getKey() + " : '" + e.getValue() + '\'');
            if (i.hasNext()) { sb.append(", "); }
          }
          sb.append('\n');
          getProject().log(sb.toString());
          if (args.length == 2) {((Closure<?>) args[1]).call(); }
        }
        else if (args[0] instanceof Closure) { ((Closure<?>) args[0]).call(); }
        else { throw new RuntimeException("Unexpected type of parameter to method " + name); }
      }
      return null;
    }
    return super.invokeMethod(name, arguments);
  }
652131
public void call(String method, Object[] args)
        throws IOException
    {
        startCall(method);

        if (args != null) {
            for (int i = 0; i < args.length; i++)
                writeObject(args[i]);
        }

        completeCall();
    }

    /**
     * Writes the method call:
     *
     * <code><pre>
     * &lt;burlap:request>
     *   &lt;method>add&lt;/method>
     * </pre></code>
     *
     * @param method the method name to call.
     */
    public void startCall(String method)
        throws IOException
    {
        print("<burlap:call><method>");
        print(method);
        print("</method>");
    }

    /**
     * Writes the method call:
     *
     * <code><pre>
     * &lt;/burlap:request>
     * </pre></code>
     */
    public void completeCall()
        throws IOException
    {
        print("</burlap:call>");
    }

    /**
     * Writes a boolean value to the stream.  The boolean will be written
     * with the following syntax:
     *
     * <code><pre>
     * &lt;boolean>1&lt;/boolean>
     * </pre></code>
     *
     * @param value the boolean value to write.
     */
    public void writeBoolean(boolean value)
        throws IOException
    {
        print("<boolean>");
        printInt(value ? 1 : 0);
        print("</boolean>");
    }

    /**
     * Writes an integer value to the stream.  The integer will be written
     * with the following syntax:
     *
     * <code><pre>
     * &lt;int>123&lt;/int>
     * </pre></code>
     *
     * @param value the integer value to write.
     */
    public void writeInt(int value)
        throws IOException
    {
        print("<int>");
        printInt(value);
        print("</int>");
    }

    /**
     * Writes a long value to the stream.  The long will be written
     * with the following syntax:
     *
     * <code><pre>
     * &lt;long>123&lt;/long>
     * </pre></code>
     *
     * @param value the long value to write.
     */
    public void writeLong(long value)
        throws IOException
    {
        print("<long>");
        printLong(value);
        print("</long>");
    }

    /**
     * Writes a null value to the stream.
     * The null will be written with the following syntax
     *
     * <code><pre>
     * &lt;null>&lt;/null>
     * </pre></code>
     *
     * @param value the string value to write.
     */
    public void writeNull()
        throws IOException
    {
        print("<null></null>");
    }

    /**
     * Writes a string value to the stream using UTF-8 encoding.
     * The string will be written with the following syntax:
     *
     * <code><pre>
     * &lt;string>12.3e10&lt;/string>
     * </pre></code>
     *
     * If the value is null, it will be written as
     *
     * <code><pre>
     * &lt;null>&lt;/null>
     * </pre></code>
     *
     * @param value the string value to write.
     */
    public void writeString(String value)
        throws IOException
    {
        if (value == null) {
            print("<null></null>");
        }
        else {
            print("<string>");
            printString(value);
            print("</string>");
        }
    }

    /**
     * Writes a byte array to the stream using base64 encoding.
     * The array will be written with the following syntax:
     *
     * <code><pre>
     * &lt;base64>dJmO==&lt;/base64>
     * </pre></code>
     *
     * If the value is null, it will be written as
     *
     * <code><pre>
     * &lt;null>&lt;/null>
     * </pre></code>
     *
     * @param value the string value to write.
     */
    public void writeBytes(byte[] buffer, int offset, int length)
        throws IOException
    {
        if (buffer == null) {
            print("<null></null>");
        }
        else {
            print("<base64>");
            printBytes(buffer, offset, length);
            print("</base64>");
        }
    }

    /**
     * Writes a date to the stream using ISO8609.
     *
     * <code><pre>
     * &lt;date>19980508T095131Z&lt;/date>
     * </pre></code>
     *
     * @param value the date in milliseconds from the epoch in UTC
     */
    public void writeUTCDate(long time)
        throws IOException
    {
        print("<date>");
        if (utcCalendar == null) {
            utcCalendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
            date = new Date();
        }

        date.setTime(time);
        utcCalendar.setTime(date);

        printDate(utcCalendar);
        print("</date>");
    }

    /**
     * Writes a date to the stream using ISO8609.
     *
     * <code><pre>
     * &lt;date>19980508T095131Z&lt;/date>
     * </pre></code>
     *
     * @param value the date in milliseconds from the epoch in local timezone
     */
    public void writeLocalDate(long time)
        throws IOException
    {
        print("<date>");
        if (localCalendar == null) {
            localCalendar = Calendar.getInstance();
            date = new Date();
        }

        date.setTime(time);
        localCalendar.setTime(date);

        printDate(localCalendar);
        print("</date>");
    }

    /**
     * Writes a reference.
     *
     * <code><pre>
     * &lt;ref>123&lt;/ref>
     * </pre></code>
     *
     * @param value the integer value to write.
     */
    public void writeRef(int value)
        throws IOException
    {
        print("<ref>");
        printInt(value);
        print("</ref>");
    }

    /**
     * Writes a generic object.  writeObject understands the following types:
     *
     * <ul>
     * <li>null
     * <li>java.lang.String
     * <li>java.lang.Boolean
     * <li>java.lang.Integer
     * <li>java.lang.Long
     * <li>java.util.Date
     * <li>byte[]
     * <li>java.util.Vector
     * <li>java.util.Hashtable
     * </ul>
     *
     * Unknown objects will call <code>writeCustomObject</code>.
     */
    public void writeObject(Object object)
        throws IOException
    {
        if (object == null)
            writeNull();
        else if (object instanceof String)
            writeString((String) object);
        else if (object instanceof Boolean)
            writeBoolean(((Boolean) object).booleanValue());
        else if (object instanceof Integer)
            writeInt(((Integer) object).intValue());
        else if (object instanceof Long)
            writeLong(((Long) object).longValue());
        else if (object instanceof Date)
            writeUTCDate(((Date) object).getTime());
        else if (object instanceof byte[]) {
            byte[] data = (byte[]) object;
            writeBytes(data, 0, data.length);
        }
        else if (object instanceof Vector) {
            Vector vector = (Vector) object;

            int size = vector.size();
            writeListBegin(size, null);
            for (int i = 0; i < size; i++)
                writeObject(vector.elementAt(i));

            writeListEnd();
        }
        else if (object instanceof Hashtable) {
            Hashtable hashtable = (Hashtable) object;

            writeMapBegin(null);
            Enumeration e = hashtable.keys();
            while (e.hasMoreElements()) {
                Object key = e.nextElement();
                Object value = hashtable.get(key);

                writeObject(key);
                writeObject(value);
            }
            writeMapEnd();
        }
        else
            writeCustomObject(object);
    }

    /**
     * Applications which override this can do custom serialization.
     *
     * @param object the object to write.
     */
    public void writeCustomObject(Object object)
        throws IOException
    {
        throw new IOException("unexpected object: " + object);
    }

    /**
     * Writes the list header to the stream.  List writers will call
     * <code>writeListBegin</code> followed by the list contents and then
     * call <code>writeListEnd</code>.
     *
     * <code><pre>
     * &lt;list>
     *   &lt;type>java.util.ArrayList&lt;/type>
     *   &lt;length>3&lt;/length>
     *   &lt;int>1&lt;/int>
     *   &lt;int>2&lt;/int>
     *   &lt;int>3&lt;/int>
     * &lt;/list>
     * </pre></code>
     */
    public void writeListBegin(int length, String type)
        throws IOException
    {
        print("<list><type>");
        if (type != null)
            print(type);
        print("</type><length>");
        printInt(length);
        print("</length>");
    }

    /**
     * Writes the tail of the list to the stream.
     */
    public void writeListEnd()
        throws IOException
    {
        print("</list>");
    }

    /**
     * Writes the map header to the stream.  Map writers will call
     * <code>writeMapBegin</code> followed by the map contents and then
     * call <code>writeMapEnd</code>.
     *
     * <code><pre>
     * &lt;map>
     *   &lt;type>java.util.Hashtable&lt;/type>
     *   &lt;string>a&lt;/string;&lt;int>1&lt;/int>
     *   &lt;string>b&lt;/string;&lt;int>2&lt;/int>
     *   &lt;string>c&lt;/string;&lt;int>3&lt;/int>
     * &lt;/map>
     * </pre></code>
     */
    public void writeMapBegin(String type)
        throws IOException
    {
        print("<map><type>");
        if (type != null)
            print(type);
        print("</type>");
    }

    /**
     * Writes the tail of the map to the stream.
     */
    public void writeMapEnd()
        throws IOException
    {
        print("</map>");
    }

    /**
     * Writes a remote object reference to the stream.  The type is the
     * type of the remote interface.
     *
     * <code><pre>
     * &lt;remote>
     *   &lt;type>test.account.Account&lt;/type>
     *   &lt;string>http://caucho.com/foo;ejbid=bar&lt;/string>
     * &lt;/remote>
     * </pre></code>
     */
    public void writeRemote(String type, String url)
        throws IOException
    {
        print("<remote><type>");
        if (type != null)
            print(type);
        print("</type><string>");
        print(url);
        print("</string></remote>");
    }

    /**
     * Prints an integer to the stream.
     *
     * @param v the integer to print.
     */
    public void printInt(int v)
        throws IOException
    {
        print(String.valueOf(v));
    }

    /**
     * Prints a long to the stream.
     *
     * @param v the long to print.
     */
    public void printLong(long v)
        throws IOException
    {
        print(String.valueOf(v));
    }

    /**
     * Prints a string to the stream, properly encoded.
     *
     * @param v the string to print.
     */
    public void printString(String v)
        throws IOException
    {
        int len = v.length();

        for (int i = 0; i < len; i++) {
            char ch = v.charAt(i);

            switch (ch) {
                case '<':
                    print("&lt;");
                    break;

                case '&':
                    print("&amp;");
                    break;

                case '\r':
                    print("&#13;");
                    break;

                default:
                    if (ch < 0x80)
                        os.write(ch);
                    else if (ch < 0x800) {
                        os.write(0xc0 + ((ch >> 6) & 0x1f));
                        os.write(0x80 + (ch & 0x3f));
                    }
                    else {
                        os.write(0xe0 + ((ch >> 12) & 0xf));
                        os.write(0x80 + ((ch >> 6) & 0x3f));
                        os.write(0x80 + (ch & 0x3f));
                    }
                    break;
            }
        }
    }

    /**
     * Prints a byte array to the stream, properly encoded  in base64.
     *
     * @param data the bytes to print.
     */
    public void printBytes(byte[] data, int offset, int length)
        throws IOException
    {
        int i;

        for (; length >= 3; length -= 3) {
            int chunk = (((data[offset] & 0xff) << 16) +
                ((data[offset + 1] & 0xff) << 8) +
                    (data[offset + 2] & 0xff));

            os.write(base64encode(chunk >> 18));
            os.write(base64encode(chunk >> 12));
            os.write(base64encode(chunk >> 6));
            os.write(base64encode(chunk));

            offset += 3;
        }

        if (length == 2) {
            int chunk = ((data[offset] & 0xff) << 8) + (data[offset + 1] & 0xff);

            os.write(base64encode(chunk >> 12));
            os.write(base64encode(chunk >> 6));
            os.write(base64encode(chunk));
            os.write('=');
        } else if (length == 1) {
            int chunk = data[offset] & 0xff;
            os.write(base64encode(chunk >> 6));
            os.write(base64encode(chunk));
            os.write('=');
            os.write('=');
        }
    }

    /**
     * Converts the digit to its base64 encoding.
     */
    public static char base64encode(int d)
    {
        d &= 0x3f;
        if (d < 26)
            return (char) (d + 'A');
        else if (d < 52)
            return (char) (d + 'a' - 26);
        else if (d < 62)
            return (char) (d + '0' - 52);
        else if (d == 62)
            return '+';
        else
            return '/';
    }

    /**
     * Prints a date.
     *
     * @param date the date to print.
     */
    public void printDate(Calendar calendar)
        throws IOException
    {
        int year = calendar.get(Calendar.YEAR);

        os.write((char) ('0' + (year / 1000 % 10)));
        os.write((char) ('0' + (year / 100 % 10)));
        os.write((char) ('0' + (year / 10 % 10)));
        os.write((char) ('0' + (year % 10)));

        int month = calendar.get(Calendar.MONTH) + 1;
        os.write((char) ('0' + (month / 10 % 10)));
        os.write((char) ('0' + (month % 10)));

        int day = calendar.get(Calendar.DAY_OF_MONTH);
        os.write((char) ('0' + (day / 10 % 10)));
        os.write((char) ('0' + (day % 10)));

        os.write('T');

        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        os.write((char) ('0' + (hour / 10 % 10)));
        os.write((char) ('0' + (hour % 10)));

        int minute = calendar.get(Calendar.MINUTE);
        os.write((char) ('0' + (minute / 10 % 10)));
        os.write((char) ('0' + (minute % 10)));

        int second = calendar.get(Calendar.SECOND);
        os.write((char) ('0' + (second / 10 % 10)));
        os.write((char) ('0' + (second % 10)));

        os.write('Z');
    }

    /**
     * Prints a string as ascii to the stream.  Used for tags, etc.
     * that are known to the ascii.
     *
     * @param s the ascii string to print.
     */
    public void print(String s)
        throws IOException
    {
        int len = s.length();
        for (int i = 0; i < len; i++) {
            int ch = s.charAt(i);

            os.write(ch);
        }
    }
}
862482
@SuppressWarnings({ "rawtypes", "unchecked" })
	public void callMethod(final MethodCallInfo info) {
		try {
			MethodsCaller.logger.info("loading class : ".concat(info.getClassName()));
			final Class clas = getClass().getClassLoader().loadClass(info.getClassName());
			MethodsCaller.logger.info("calling default constructor");
			final Object object = clas.newInstance();
			MethodsCaller.logger.info("calling method : " + info.getMethodName() + " , with params: ".concat(Arrays.toString(info.getParamters())));
			final Method method = clas.getMethod(info.getMethodName(), info.getParamtersTypes());
			final Object result = method.invoke(object, info.getParamters());
			if (!(result instanceof Serializable)) {
				throw new IllegalStateException("object " + result + " from type " + result.getClass().getName() + " is not serialzable");
			}
			info.setResult(result);
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException
				| IllegalArgumentException | InvocationTargetException e) {
			MethodsCaller.logger.severe("calling to method failed : ".concat(info.toString()));
			throw new RemoteReflectionException(e);
		}
	}