orte/java/src/org/ocera/orte/DomainApp.java

   1 /* DomainApp.java */
   2
   3 /**
   4  * Class DomainApp provides methods for work with the ORTE application domain.
   5  *
   6  * @author Lukas Pokorny (lukas_pokorny@centrum.cz)
   7  * @author CTU FEE Prague - Department of Control Engineering (dce.felk.cvut.cz)
   8  * @author Project ORTE - OCERA Real Time Ethernet (www.ocera.org)
   9  * @author dedication to Kj
  10  * @version 0.1
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU General Public License for more details.
  21  *
  22  */
  23
  24 package org.ocera.orte;
  25 import  org.ocera.orte.types.*;
  26
  27
  28 public class DomainApp extends Domain
  29 {
  30
  31   /**
  32    * Default constructor. Creates an Application Domain with default parameters.
  33    * (domain = ORTE_DEFAULT_DOMAIN, suspended thread = false)
  34    */
  35    public DomainApp()
  36    {
  37       super();
  38           // this.handle =jORTEDomainDefaultAppCreate(ORTEConstant.ORTE_DEFAULT_DOMAIN,true); - uspane vlakno po startu
  39       this.handle = jORTEDomainDefaultAppCreate(ORTEConstant.ORTE_DEFAULT_DOMAIN,false);
  40       if(this.handle == 0) System.out.println(":j!: zero domain handle! ..");
  41         else System.out.println(":j: application domain created..");
  42    }
  43
  44
  45    /**
  46     * User defined constructor. For creating an Application Domain with your parameters.
  47     */
  48    /** TODO dodelat objekty 'props', 'events' */
  49    public DomainApp(int domain, DomainProp ps, DomainEvents ev, boolean suspend)
  50    {
  51      super();
  52      this.props = ps;
  53      this.events = ev;
  54      this.handle = jORTEDomainAppCreate(domain,
  55                                         ps==null ? 0 : this.props.getHandle(),
  56                                         ev==null ? 0 : this.events.getHandle(),
  57                                         this.events,
  58                                         suspend);
  59      /* TODO osetrit neuspesne vytvoreni domeny */
  60      if(this.handle == 0) System.out.println(":j!: zero domain handle! ..");
  61       else System.out.println(":j: application domain created..");
  62    }
  63
  64    /**
  65     * Destroy the Application Domain.
  66     */
  67    @Override
  68    public boolean destroy()
  69    {
  70      if(destroyAllRegTypes() && jORTEDomainAppDestroy(this.handle) && (this.props == null || this.props.destroy())) return true;
  71      System.out.println(":j!: ORTEDomainAppDestroy() fault..");
  72      return false;
  73    }
  74
  75
  76    /**
  77     * Register new data type.
  78     * @param Name of the new type.
  79     * @param Max length of the input buffer.
  80     * @return True - registration Ok, False - registration fault.
  81     */
  82    public
  83    boolean regNewDataType(String name,
  84                                                   long maxlength)
  85    {
  86      int b = jORTETypeRegisterAdd(this.handle,
  87                                       name,
  88                                   maxlength);
  89          if (b == ORTEConstant.ORTE_BAD_HANDLE)
  90      {
  91        System.out.println(":!j: regNewDataType() failed! [bad domain handle]");
  92        return false;
  93      }
  94      if (b == ORTEConstant.ORTE_OK)
  95      {
  96        System.out.println(":j: type: '" + name + "' successfully registered..");
  97        return true;
  98          }
  99      return false;
 100    }
 101
 102
 103    /**
 104     * Destroys all previous registered data types.
 105     * @return True - registration Ok, False - destroying fault.
 106     */
 107    public
 108    boolean destroyAllRegTypes()
 109    {
 110      if (jORTETypeRegisterDestroyAll(this.handle)) return true;
 111      return false;
 112    }
 113
 114
 115    /**
 116     * Creates a new Subscription.
 117     *
 118     * @param Subscription properties.
 119     * @param Length of output buffer.
 120     * @param Callback instance.
 121     * @return Handle to the new created Subscription.
 122     */
 123    public
 124    Subscription createSubscription(SubsProp subsProp,
 125                                     MessageData instance,
 126                                         SubscriptionCallback subsCallback)
 127    {
 128        Subscription s = new Subscription(this,
 129                                          subsProp,
 130                                          instance,
 131                                          subsCallback);
 132        return s;
 133    }
 134
 135
 136    /**
 137     * Creates a new Publication.
 138     *
 139     * @param Instance of MessageData (which data will be send).
 140     * @param Time parameter, which defines how long are publicated data valid.
 141     * @param The importance of this Publication (its rating).
 142     * @return Handle to the new created Publication.
 143     */
 144    public
 145    Publication createPublication(PublProp publProp,
 146                                       MessageData instance)
 147    {
 148      //System.out.println(":j: vytvarim publikaci pro DataType: " + instance.getType());
 149      Publication p = new Publication(this,
 150                                      publProp,
 151                                      instance);
 152      return p;
 153    }
 154
 155
 156 /* ****************************************************************** *
 157  *                                                                    *
 158  *                         native methods                             *
 159  *                                                                    *
 160  * ****************************************************************** */
 161
 162 /**
 163  * jORTEDomainAppCreate - creates an default application object within given
 164  * domain, returns handle to created object (from C environment),
 165  * NULL in case of any error.
 166  *
 167  *
 168  * @param domain given domain
 169  * @return addres value (from C environment) of the created domain
 170  */
 171  private native long jORTEDomainDefaultAppCreate(int domain,boolean suspend);
 172
 173
 174 /**
 175  * jORTEDomainAppCreate - creates an application object within given
 176  * domain, returns handle to created object (from C environment),
 177  * NULL in case of any error.
 178  *
 179  *
 180  * @param domain given domain
 181  * @param handler for C pointer to ORTEDomainProps
 182  * @param handler for C pointer to ORTEDomainEvents
 183  * @param suspended specifies whether threads of this application should be started as well (False) or stay suspended (True)
 184  * @return addres value (from C environment) of the created domain
 185  */
 186
 187  private native
 188  long jORTEDomainAppCreate(int  domain,
 189                            long propHandle,
 190                            long eventsHandle,
 191                                                   DomainEvents ev,
 192                                                   boolean suspend);
 193
 194
 195 /**
 196  * jORTEDomainADestroy - destroys all application objects in specified
 197  * domain, returns False if some error occures otherwise returns True.
 198  *
 199  *
 200  * @param jp_domhandle handler to domain
 201  * @return boolean value, False when some error occures, otherwise True
 202  */
 203  private native
 204  boolean jORTEDomainAppDestroy(long dhandle);
 205
 206
 207  /**
 208   * jORTETypeRegisterAdd - register new data type.
 209   *
 210   *
 211   * @param dhandle handler to domain
 212   * @param
 213   * @param
 214   * @param
 215   * @return
 216   */
 217   private native
 218   int jORTETypeRegisterAdd(long dhandle,
 219                             String typeName,
 220                             long maxlenght);
 221
 222
 223  /**
 224   * jORTETypeRegisterDestroyAll - destroys all previous registered data types.
 225   *
 226   *
 227   * @param dhandle handler to domain
 228   * @return boolean value, False when some error occures, otherwise True
 229   */
 230   private native
 231   boolean jORTETypeRegisterDestroyAll(long dhandle);
 232
 233 }