| /******************************************************************************* |
| * Copyright (c) 2001, 2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jem.internal.proxy.core; |
| /* |
| |
| |
| */ |
| |
| import java.io.InputStream; |
| |
| /** |
| * Users will create a callback of this interface |
| * and register it with the factory. Then when ever |
| * the callback occurs, this callback will be called |
| * with data from the proxy. It can return a value too. |
| * |
| * Or an InputStream can be returned to supply the data. |
| * |
| * @since 1.0.0 |
| */ |
| public interface ICallback { |
| |
| /** |
| * This is the entry point of the callback. |
| * It will be called whenever the callback |
| * occurred. It will be on its own thread. |
| * A particular thread cannot be requested. |
| * <p> |
| * The implementation MUST return. This is |
| * because the callback will not be completed |
| * until it is returned, and the process will |
| * not continue on the remote vm until it is |
| * returned. |
| * <p> |
| * The value returned must either be an |
| * IBeanProxy or IBeanProxy[]. It is typed |
| * to Object to allow either one, but it |
| * will be checked, and if it isn't, then |
| * null will be returned instead to the |
| * caller. |
| * |
| * @param msgID |
| * @param parm The beanproxy - will not be null |
| * @return |
| * |
| * @since 1.0.0 |
| */ |
| public Object calledBack(int msgID, IBeanProxy parm); |
| |
| /** |
| * This is the entry point of the callback. |
| * It will be called whenever the callback |
| * occurred. It will be on its own thread. |
| * A particular thread cannot be requested. |
| * <p> |
| * The parms will be an array of IBeanProxys, |
| * or an entry could be another array of IBeanProxys, |
| * or null if null was sent to callBackWithParms. |
| * The final component of any entry will be an |
| * IBeanProxy. It is up to the developers to |
| * agree on the format of the parms. |
| * <p> |
| * The implementation MUST return. This is |
| * because the callback will not be completed |
| * until it is returned, and the process will |
| * not continue on the remote vm until it is |
| * returned. |
| * <p> |
| * The value returned must either be an |
| * IBeanProxy or IBeanProxy[]. It is typed |
| * to Object to allow either one, but it |
| * will be checked, and if it isn't, then |
| * null will be returned instead to the |
| * caller. |
| * |
| * @param msgID |
| * @param parms |
| * @return |
| * |
| * @see org.eclipse.jem.internal.proxy.common.ICallbackHandler#callbackWithParms(int, int, Object[]) |
| * @since 1.0.0 |
| */ |
| public Object calledBack(int msgID, Object[] parms); |
| |
| /** |
| * This is the entry point of the callback. |
| * It will be called whenever the callback |
| * occurred. It will be on its own thread. |
| * A particular thread cannot be requested. |
| * <p> |
| * The parm will be an object. This occurs |
| * if remote vm just wanted to send some objects. |
| * They will not be proxies. It is recommended |
| * that this be used only for small items. For |
| * anything large, the callbackStream should be |
| * used instead. |
| * <p> |
| * The implementation MUST return. This is |
| * because the callback will not be completed |
| * until it is returned, and the process will |
| * not continue on the remote vm until it is |
| * returned. |
| * <p> |
| * The value returned must either be an |
| * IBeanProxy or IBeanProxy[]. It is typed |
| * to Object to allow either one, but it |
| * will be checked, and if it isn't, then |
| * null will be returned instead to the |
| * caller. |
| * |
| * @param msgID |
| * @param parm The parm or <code>null</code> if null was sent. |
| * @return |
| * |
| * @see ICallback#calledBackStream(int, InputStream) |
| * @since 1.0.0 |
| */ |
| public Object calledBack(int msgID, Object parm); |
| |
| /** |
| * This is the entry point of the callback. |
| * It will be called whenever the callback stream |
| * occurred. It will be on its own thread. |
| * A particular thread cannot be requested. |
| * <p> |
| * The callback should continue to read from the InputStream |
| * until it returns -1 indicating no more data. The stream can |
| * be closed. In that case the next time the remote vm wants to |
| * send data it will first check that the stream has not been closed. |
| * If it has, it will raise an exception on that side. |
| * <p> |
| * The implementation MUST return. This is |
| * because the callback will not be completed |
| * until it is returned, and the process will |
| * not continue on the remote vm until it is |
| * returned. |
| * |
| * @param msgID |
| * @param is |
| * |
| * @since 1.0.0 |
| */ |
| public void calledBackStream(int msgID, InputStream is); |
| } |