scilab/modules/xcos/src/java/org/scilab/modules/xcos/io/scicos/ScilabDirectHandler.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2011 - Scilab Enterprises - Clement DAVID
   4  *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  *
   7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9  * This file was originally licensed under the terms of the CeCILL v2.1,
  10  * and continues to be available under such terms.
  11  * For more information, see the COPYING file which you should have received
  12  * along with this program.
  13  *
  14  */
  15
  16 package org.scilab.modules.xcos.io.scicos;
  17
  18 import java.util.HashMap;
  19 import java.util.Map;
  20 import java.util.concurrent.Semaphore;
  21 import java.util.concurrent.TimeUnit;
  22 import java.util.logging.Logger;
  23
  24 import org.scilab.modules.javasci.JavasciException;
  25 import org.scilab.modules.javasci.Scilab;
  26 import org.scilab.modules.types.ScilabList;
  27 import org.scilab.modules.types.ScilabString;
  28 import org.scilab.modules.types.ScilabType;
  29
  30 /**
  31  * Scilab data direct access.
  32  */
  33 public class ScilabDirectHandler implements Handler {
  34     /**
  35      * Context Scilab variable name
  36      */
  37     public static final String CONTEXT = "context";
  38     /**
  39      * Diagram Scilab variable name
  40      */
  41     public static final String SCS_M = "scs_m";
  42     /**
  43      * Block Scilab variable name
  44      */
  45     public static final String BLK = "blk";
  46
  47     private static final Logger LOG = Logger.getLogger(ScilabDirectHandler.class.getPackage().getName());
  48     private static final ScilabDirectHandler INSTANCE = new ScilabDirectHandler();
  49
  50     private final Semaphore lock = new Semaphore(1, true);
  51
  52     private ScilabDirectHandler() {
  53     }
  54
  55     /*
  56      * Lock management to avoid multiple actions
  57      */
  58
  59     /**
  60      * Get the current instance of a ScilabDirectHandler.
  61      *
  62      * Please note that after calling {@link #acquire()} and performing action,
  63      * you should release the instance using {@link #release()}.
  64      *
  65      * <p>
  66      * It is recommended practice to <em>always</em> immediately follow a call
  67      * to {@code getInstance()} with a {@code try} block, most typically in a
  68      * before/after construction such as:
  69      *
  70      * <pre>
  71      * class X {
  72      *
  73      *     // ...
  74      *
  75      *     public void m() {
  76      *         final ScilabDirectHandler handler = ScilabDirectHandler.getInstance();
  77      *         try {
  78      *             // ... method body
  79      *         } finally {
  80      *             handler.release();
  81      *         }
  82      *     }
  83      * }
  84      * </pre>
  85      *
  86      * @see #release()
  87      * @return the instance or null if another operation is in progress
  88      */
  89     public static ScilabDirectHandler acquire() {
  90         LOG.finest("lock request");
  91
  92         try {
  93             final boolean status = INSTANCE.lock.tryAcquire(0, TimeUnit.SECONDS);
  94             if (!status) {
  95                 return null;
  96             }
  97         } catch (InterruptedException e) {
  98             e.printStackTrace();
  99         }
 100
 101         LOG.finest("lock acquired");
 102
 103         return INSTANCE;
 104     }
 105
 106     /**
 107      * Release the instance
 108      */
 109     public void release() {
 110         LOG.finest("lock release");
 111
 112         INSTANCE.lock.release();
 113     }
 114
 115     /*
 116      * Handler implementation
 117      */
 118
 119     @Override
 120     public synchronized Map<String, ScilabType> readContext() {
 121         LOG.entering("ScilabDirectHandler", "readContext");
 122         final Map<String, ScilabType> result = new HashMap<String, ScilabType>();
 123
 124         final ScilabType keys;
 125         final ScilabType values;
 126         try {
 127             keys = Scilab.getInCurrentScilabSession(CONTEXT + "_names");
 128             values = Scilab.getInCurrentScilabSession(CONTEXT + "_values");
 129         } catch (JavasciException e) {
 130             throw new RuntimeException(e);
 131         }
 132         final ScilabString k;
 133         final ScilabList v;
 134         if (keys instanceof ScilabString && values instanceof ScilabList) {
 135             k = (ScilabString) keys;
 136             v = (ScilabList) values;
 137             LOG.finer("data available");
 138         } else {
 139             LOG.finer("data unavailable");
 140             return result;
 141         }
 142
 143         for (int i = 0; i < Math.min(k.getWidth(), v.size()); i++) {
 144             result.put(k.getData()[0][i], v.get(i));
 145         }
 146
 147         LOG.exiting("ScilabDirectHandler", "readContext");
 148         return result;
 149     }
 150
 151     @Override
 152     public void writeContext(final String[] context) {
 153         LOG.entering("ScilabDirectHandler", "writeContext");
 154
 155         try {
 156             Scilab.putInCurrentScilabSession(CONTEXT, new ScilabString(context));
 157         } catch (JavasciException e) {
 158             throw new RuntimeException(e);
 159         }
 160
 161         LOG.exiting("ScilabDirectHandler", "writeContext");
 162     }
 163 }