USyncClient.java

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.4
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

package urbi;
  /// UClient linux implementation with support for synchronous extra
  /// functions.
  /*! This class provides extra functions to synchronously request
     values. These functions can safely be called frow within a
     callback function.

     All callbacks will be called in a separate thread created in the
     constructor.
     When one of those callbacks calls a synchronous function, new incoming
     messages are kept on hold until the response from the synchronous call
     is received.

     If you want to call these callbacks in a different
     thread, call stopCallbackThread(), then regularly call
     processEvents(). Each call will call callbacks for all pending
     messages in the current thread.  */

public class USyncClient extends UClient {
  private long swigCPtr;

  public USyncClient(long cPtr, boolean cMemoryOwn) {
    super(urbiJNI.USyncClient_SWIGUpcast(cPtr), cMemoryOwn);
    swigCPtr = cPtr;
  }

  public static long getCPtr(USyncClient obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        urbiJNI.delete_USyncClient(swigCPtr);
      }
      swigCPtr = 0;
    }
    super.delete();
  }

  public USyncClient(String host, long port, long buflen) {
    this(urbiJNI.new_USyncClient__SWIG_0(host, port, buflen), true);
  }

  public USyncClient(String host, long port) {
    this(urbiJNI.new_USyncClient__SWIG_1(host, port), true);
  }

  public USyncClient(String host) {
    this(urbiJNI.new_USyncClient__SWIG_2(host), true);
  }

      /// Synchronously evaluate an Urbi expression. The expression must
    /// not start with a tag or channel.
 public  UMessage syncGet(String expression) {
    long cPtr = urbiJNI.USyncClient_syncGet__SWIG_0(swigCPtr, this, expression);
    return (cPtr == 0) ? null : new UMessage(cPtr, false);
  }

      /// Synchronously evaluate an Urbi expression. The expression must
    /// not start with a tag or channel.
 public  UMessage syncGet(long useconds, String expression) {
    long cPtr = urbiJNI.USyncClient_syncGet__SWIG_2(swigCPtr, this, useconds, expression);
    return (cPtr == 0) ? null : new UMessage(cPtr, false);
  }

  public UMessage syncGetTag(String expression, String mtag, String mmod) {
    long cPtr = urbiJNI.USyncClient_syncGetTag__SWIG_0(swigCPtr, this, expression, mtag, mmod);
    return (cPtr == 0) ? null : new UMessage(cPtr, false);
  }

  public UMessage syncGetTag(long useconds, String expression, String mtag, String mmod) {
    long cPtr = urbiJNI.USyncClient_syncGetTag__SWIG_1(swigCPtr, this, useconds, expression, mtag, mmod);
    return (cPtr == 0) ? null : new UMessage(cPtr, false);
  }

  public int syncGetValue(String valName, UValue val, long useconds) {
    return urbiJNI.USyncClient_syncGetValue__SWIG_0(swigCPtr, this, valName, UValue.getCPtr(val), val, useconds);
  }

  public int syncGetValue(String valName, UValue val) {
    return urbiJNI.USyncClient_syncGetValue__SWIG_1(swigCPtr, this, valName, UValue.getCPtr(val), val);
  }

  public int syncGetValue(String tag, String valName, UValue val, long useconds) {
    return urbiJNI.USyncClient_syncGetValue__SWIG_2(swigCPtr, this, tag, valName, UValue.getCPtr(val), val, useconds);
  }

  public int syncGetValue(String tag, String valName, UValue val) {
    return urbiJNI.USyncClient_syncGetValue__SWIG_3(swigCPtr, this, tag, valName, UValue.getCPtr(val), val);
  }

  public int syncGetDevice(String device, SWIGTYPE_p_double val, long useconds) {
    return urbiJNI.USyncClient_syncGetDevice__SWIG_0(swigCPtr, this, device, SWIGTYPE_p_double.getCPtr(val), useconds);
  }

  public int syncGetDevice(String device, SWIGTYPE_p_double val) {
    return urbiJNI.USyncClient_syncGetDevice__SWIG_1(swigCPtr, this, device, SWIGTYPE_p_double.getCPtr(val));
  }

  public int syncGetResult(String command, SWIGTYPE_p_double val, long useconds) {
    return urbiJNI.USyncClient_syncGetResult__SWIG_0(swigCPtr, this, command, SWIGTYPE_p_double.getCPtr(val), useconds);
  }

  public int syncGetResult(String command, SWIGTYPE_p_double val) {
    return urbiJNI.USyncClient_syncGetResult__SWIG_1(swigCPtr, this, command, SWIGTYPE_p_double.getCPtr(val));
  }

  public int syncGetNormalizedDevice(String device, SWIGTYPE_p_double val, long useconds) {
    return urbiJNI.USyncClient_syncGetNormalizedDevice__SWIG_0(swigCPtr, this, device, SWIGTYPE_p_double.getCPtr(val), useconds);
  }

  public int syncGetNormalizedDevice(String device, SWIGTYPE_p_double val) {
    return urbiJNI.USyncClient_syncGetNormalizedDevice__SWIG_1(swigCPtr, this, device, SWIGTYPE_p_double.getCPtr(val));
  }

  public int syncGetDevice(String device, String field, SWIGTYPE_p_double val, long useconds) {
    return urbiJNI.USyncClient_syncGetDevice__SWIG_2(swigCPtr, this, device, field, SWIGTYPE_p_double.getCPtr(val), useconds);
  }

  public int syncGetDevice(String device, String field, SWIGTYPE_p_double val) {
    return urbiJNI.USyncClient_syncGetDevice__SWIG_3(swigCPtr, this, device, field, SWIGTYPE_p_double.getCPtr(val));
  }

  public int syncGetSound(String device, int duration, USound sound, long useconds) {
    return urbiJNI.USyncClient_syncGetSound__SWIG_0(swigCPtr, this, device, duration, USound.getCPtr(sound), sound, useconds);
  }

  public int syncGetSound(String device, int duration, USound sound) {
    return urbiJNI.USyncClient_syncGetSound__SWIG_1(swigCPtr, this, device, duration, USound.getCPtr(sound), sound);
  }

      /// Wait until a message with specified tag is received. Returned
    /// message must be deleted.
 public  UMessage waitForTag(String tag, long useconds) {
    long cPtr = urbiJNI.USyncClient_waitForTag__SWIG_0(swigCPtr, this, tag, useconds);
    return (cPtr == 0) ? null : new UMessage(cPtr, false);
  }

      /// Wait until a message with specified tag is received. Returned
    /// message must be deleted.
 public  UMessage waitForTag(String tag) {
    long cPtr = urbiJNI.USyncClient_waitForTag__SWIG_1(swigCPtr, this, tag);
    return (cPtr == 0) ? null : new UMessage(cPtr, false);
  }

  public void lockQueue() {
    urbiJNI.USyncClient_lockQueue(swigCPtr, this);
  }

      /// Overriding UAbstractclient implementation
 public  void notifyCallbacks(UMessage msg) {
    urbiJNI.USyncClient_notifyCallbacks(swigCPtr, this, UMessage.getCPtr(msg), msg);
  }

      /**
     * Check message queue for pending messages, notify callbacks synchronously.
     * @param timeout If different -1 process events for at most @a timeout
     *                microseconds. This is useful if you don't want
     *                processEvents() to take to much time if there are many
     *                many pending messages.
     * @return true if at least one message was processed, false otherwise.
     * Callbacks functions are called synchronously in the caller thread.
     */
 public  boolean processEvents(long timeout) {
    return urbiJNI.USyncClient_processEvents__SWIG_0(swigCPtr, this, timeout);
  }

      /**
     * Check message queue for pending messages, notify callbacks synchronously.
     * @param timeout If different -1 process events for at most @a timeout
     *                microseconds. This is useful if you don't want
     *                processEvents() to take to much time if there are many
     *                many pending messages.
     * @return true if at least one message was processed, false otherwise.
     * Callbacks functions are called synchronously in the caller thread.
     */
 public  boolean processEvents() {
    return urbiJNI.USyncClient_processEvents__SWIG_1(swigCPtr, this);
  }

      /**
     *  Stop the callback processing thread.
     *  The user is responsible for calling processEvents() regularily
     *  once this function has been called.
     */
 public  void stopCallbackThread() {
    urbiJNI.USyncClient_stopCallbackThread(swigCPtr, this);
  }

  public void callbackThread() {
    urbiJNI.USyncClient_callbackThread(swigCPtr, this);
  }

  public void setSynchronous(boolean enable) {
    urbiJNI.USyncClient_setSynchronous(swigCPtr, this, enable);
  }

      /** Block until kernel version is available or an error occurrs.
     * Message processing must not depend on this thread.
     */
 public  void waitForKernelVersion(boolean hasProcessingThread) {
    urbiJNI.USyncClient_waitForKernelVersion__SWIG_1(swigCPtr, this, hasProcessingThread);
  }

  public void onConnect() {
    urbiJNI.USyncClient_onConnect(swigCPtr, this);
  }

      /// @return true if the current thread is the callback thread.
 public  boolean isCallbackThread() {
    return urbiJNI.USyncClient_isCallbackThread(swigCPtr, this);
  }

}