This method implements the new interface by calling the old method. Note
that the input types are different between the new and old apis and this
is a bridge between the two.
485709
@Override
  public final void abortJob(org.apache.hadoop.mapreduce.JobContext context, 
                          org.apache.hadoop.mapreduce.JobStatus.State runState) 
  throws IOException {
    int state = JobStatus.getOldNewJobRunState(runState);
    if (state != JobStatus.FAILED && state != JobStatus.KILLED) {
      throw new IOException ("Invalid job run state : " + runState.name());
    }
    abortJob((JobContext) context, state);
  }
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);
        }
    }
}
713233
def method_missing msg, *args, &block
      defi = Definition.new(msg, args, block)
      if injected = __mock_injected[defi.msg]
        defi.original_method = injected.original_method
      else
        __mock_inject_method(defi)
      end
      __mock_defis_push(defi)
      Modifier.new(self, defi)
    end
704071
def replace(self, parameters=_void, return_annotation=_void):
        

        if parameters is _void:
            parameters = self.parameters.values()

        if return_annotation is _void:
            return_annotation = self._return_annotation

        return type(self)(parameters, return_annotation=return_annotation)
763146
public void add(T method)
    {
        // check for overridden method
        if (isOverrideMethod(method)) {
            return;
        }

        // Add to the list of managed methods
        _methods.put(method.getName() + method.getArgTypes(), method);

        // Ensure that all added methods have a unique index
        Object nameValue = _nameMap.get(method.getName());
        if (nameValue == null)
        {
            // first method with this name, considered unique (for now)
            _nameMap.put(method.getName(), method);
        }
        else
        {
            int nextIndex;
            if (nameValue instanceof AptMethod)
            {
                // 2nd method with this name, add index to original and start indexing
                ((AptMethod)nameValue).setIndex(0);
                nextIndex = 1;
            }
            else
            {
                // 3rd (or later) method with this name, continue indexing
                nextIndex = ((Integer)nameValue).intValue();
            }

            method.setIndex(nextIndex++);
            _nameMap.put(method.getName(), nextIndex);
        }
    }
939960
def send(self, **kwargs):
        
        payload = self.api_payload()
        payload.update(**kwargs)
        return self.api_method()(**payload)
1331237
@Override
    public Object execute() throws Exception 
    {
        Object ret = executeChange();
        if (changesManager != null)
            changesManager.modelChanged();
        return ret;
    }
647114
protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out)
    {
        super.initialize(type, oldInstance, newInstance, out);
    }
503787
@SuppressWarnings("unchecked")
    @Override
    public T newChannel() {
        switch (kind) {
            case ACCEPTOR:
                switch (type) {
                    case DATAGRAM:
                        return (T) new NioUdtMessageAcceptorChannel();
                    case STREAM:
                        return (T) new NioUdtByteAcceptorChannel();
                    default:
                        throw new IllegalStateException("wrong type=" + type);
                }
            case CONNECTOR:
                switch (type) {
                    case DATAGRAM:
                        return (T) new NioUdtMessageConnectorChannel();
                    case STREAM:
                        return (T) new NioUdtByteConnectorChannel();
                    default:
                        throw new IllegalStateException("wrong type=" + type);
                }
            case RENDEZVOUS:
                switch (type) {
                    case DATAGRAM:
                        return (T) new NioUdtMessageRendezvousChannel();
                    case STREAM:
                        return (T) new NioUdtByteRendezvousChannel();
                    default:
                        throw new IllegalStateException("wrong type=" + type);
                }
            default:
                throw new IllegalStateException("wrong kind=" + kind);
        }
    }
1030193
private static List<MethodForConnection> inputMethod(BufferedReader in) throws IOException
   {
      List<MethodForConnection> methods = new ArrayList<MethodForConnection>();
      Set<String> setMethodsSig = new HashSet<String>();
      while (true)
      {
         System.out.print("    " + rb.getString("connection.method.name") + " " +
               rb.getString("confirm.quit") + ": ");
         String methodName = in.readLine();
         if (methodName == null || methodName.equals(""))
            break;
         MethodForConnection method = new MethodForConnection();
         method.setMethodName(methodName);
         System.out.print("    " + rb.getString("connection.method.return") + ": ");
         String methodReturn = in.readLine();
         if (!(methodReturn == null || methodReturn.equals("")))
            method.setReturnType(methodReturn);
         while (true)
         {
            System.out.print("    " + rb.getString("connection.method.param.name") + " " +
                  rb.getString("confirm.quit") + ": ");
            String paramName = in.readLine();
            if (paramName == null || paramName.equals(""))
               break;
            String paramType = null;
            while (true)
            {
               System.out.print("    " + rb.getString("connection.method.param.type") + ": ");
               paramType = in.readLine();
               if (paramType != null && !paramType.equals(""))
               {
                  if (!paramType.contains("."))
                  {
                     if (BasicType.isBasicType(paramType) || BasicType.isPrimitiveType(paramType))
                        break;
                  }
                  else if (!(paramType.indexOf(".") == 0))
                  {
                     break;
                  }
               }
               System.out.print(rb.getString("config.properties.type.tip") + ": [");
               System.out.println(BasicType.allType() + "]");
            }

            MethodParam param = method.newParam(paramName, paramType);
            method.getParams().add(param);
         }
         if (setMethodsSig.contains(method.toString()))
         {
            System.out.println("    " + rb.getString("connection.method.repeat"));
            continue;
         }

         while (true)
         {
            System.out.print("    " + rb.getString("connection.method.exception") + ": ");
            String exceptions = in.readLine();
            if (exceptions == null || exceptions.equals(""))
               break;
            method.getExceptionType().add(exceptions);
         }
         methods.add(method);
         setMethodsSig.add(method.toString());
      }

      return methods;

   }
189629
private void overrideAbstractMethods() throws IOException
    {
        for (final ExecutableElement method : El.getEffectiveMethods(superClass))
        {
            if (method.getModifiers().contains(Modifier.ABSTRACT))
            {
                if (
                        method.getAnnotation(Terminal.class) != null || 
                        method.getAnnotation(Rule.class) != null || 
                        method.getAnnotation(Rules.class) != null )
                {
                    implementedAbstractMethods.add(method);
                    MethodCompiler mc = new MethodCompiler()
                    {
                        @Override
                        protected void implement() throws IOException
                        {
                            TypeMirror returnType = method.getReturnType();
                            List<? extends VariableElement> params = method.getParameters();
                            if (returnType.getKind() != TypeKind.VOID && params.size() == 1)
                            {
                                nameArgument(ARG, 1);
                                try
                                {
                                    convert(ARG, returnType);
                                }
                                catch (IllegalConversionException ex)
                                {
                                    throw new IOException("bad conversion with "+method, ex);
                                }
                                treturn();
                            }
                            else
                            {
                                if (returnType.getKind() == TypeKind.VOID && params.size() == 0)
                                {
                                    treturn();
                                }
                                else
                                {
                                    throw new IllegalArgumentException("cannot implement abstract method "+method);
                                }
                            }
                        }
                    };
                    subClass.overrideMethod(mc, method, Modifier.PROTECTED);
                }
            }
        }
    }
409720
private void consConstructorCallContext()
	{
		// This gives us everything after new, e.g. ' MyClass' if you type 'new MyClass'
		proposalPrefix = rawScan.subSequence(rawScan.indexOf("new"),rawScan.length()).toString();

		processedScan = rawScan; //new StringBuffer(subSeq);
		type = SearchType.New;
	}
177241
def _add_new_methods(cls):
        """"""
        for name, method in cls.context.new_methods.items():
            if hasattr(cls.context.new_class, name):
                raise ValueError(
                    "Name collision in state machine class - '{name}'."
                    .format(name)
                )

            setattr(cls.context.new_class, name, method)
668041
protected static MethodType replaceWithMoreSpecificType(Object[] args, MethodType callSiteType) {
        for (int i=0; i<args.length; i++) {
            // if argument null, take the static type
            if (args[i]==null) continue;
            if (callSiteType.parameterType(i).isPrimitive()) continue;
            Class argClass = args[i].getClass();
            callSiteType = callSiteType.changeParameterType(i, argClass);
        }
        return callSiteType;
    }
789071
@Override
	protected void initialize() throws Exception {
		super.initialize();

		// set the last output collector of this task to reflect the iteration intermediate state update
		// a) workset update
		// b) solution set update
		// c) none

		Collector<OT> delegate = getLastOutputCollector();
		if (isWorksetUpdate) {
			// sanity check: we should not have a solution set and workset update at the same time
			// in an intermediate task
			if (isSolutionSetUpdate) {
				throw new IllegalStateException("Plan bug: Intermediate task performs workset and solutions set update.");
			}

			Collector<OT> outputCollector = createWorksetUpdateOutputCollector(delegate);

			// we need the WorksetUpdateOutputCollector separately to count the collected elements
			if (isWorksetIteration) {
				worksetUpdateOutputCollector = (WorksetUpdateOutputCollector<OT>) outputCollector;
			}

			setLastOutputCollector(outputCollector);
		} else if (isSolutionSetUpdate) {
			setLastOutputCollector(createSolutionSetUpdateOutputCollector(delegate));
		}
	}
457987
def synchronize_all_methods
      methods = self.class.instance_methods - self.class.superclass.instance_methods

      methods.each do |method_name|
        old_method = :"old_#{method_name}"
        new_method = :"synchronized_#{method_name}"

        self.class.__send__(:alias_method, old_method, method_name)

        self.class.send(:define_method, new_method) do |*args|
          @lock.synchronize { __send__(old_method, *args) }
        end

        self.class.__send__(:alias_method, method_name, new_method)
      end
    end
549208
public static Bridge create(final Call call1, final Call call2)
    	    throws Exception {
        assert (call1 != null);
    	final String callId1 = call1.getId();
    	final String callId2 = call2.getId();
    	return Bridge.create(callId1, callId2);
    }