NumberSubSample.java

/*
 * Created on Mar 5, 2004
 */
package org.nees.rbnb;

import java.io.IOException;
import java.util.Date;
import java.util.TimeZone;
import java.text.SimpleDateFormat;

import com.rbnb.sapi.*;
//import COM.Creare.Utility.ArgHandler; //for argument parsing
import com.rbnb.utility.ArgHandler; //for argument parsing

public class NumberSubSample extends RBNBBase {

    private static final String SINK_NAME_NAME = "SinkName";    
    private static final String SINK_NAME = "NumberSubSampleSink";
    private static final String SOURCE_NAME_NAME = "SourceName";
    private static final String SOURCE_NAME = "NumberSubSampleSource";
    private static final String CHANNEL_NAME_NAME = "ChannelName";
    private static final String CHANNEL_NAME = "SubSample";
    private static final String SKIP_NAME = "SamplesToSkip";
    private static final int SKIP = 4;
    private static final String REQUEST_PATH_NAME = "RequestPath";
    private static final String REQUEST_PATH = "undefined";
    private static final String CACHE_SIZE_NAME = "CacheSize";  
    private static final int DEFAULT_CACHE_SIZE=100;

    private String sinkName = SINK_NAME;
    private String sourceName = SOURCE_NAME;
    private String channelName = CHANNEL_NAME;
    private String requestPath = REQUEST_PATH;
    private int skip = SKIP;
    private int count = 0;
    private int cacheSize = DEFAULT_CACHE_SIZE;
     
    Sink sink = null;
    Source source = null;
    boolean sinkConnected = false;
    boolean sourceConnected = false;    
    
    Thread stringDataThread;
    boolean runit = false;
    
    private String[] parameterNameArray;
    private String[] parameterTypeArray;
    private Object[] parameterDefaultArray;
    
    public static void main(String[] args) {
        NumberSubSample s = new NumberSubSample();
        if (s.setArgs(args))
        {
            s.connect();
            s.startThread();
        }
    }
    
    public NumberSubSample()
    {
        setParamterArrays();
        initialize();
    }

    public void printUsage() {
        System.out.println("NumberSubSample: usage is...");     
        System.out.println("NumberSubSample ");
        super.printUsage();
        System.out.println("[-S Source Name *" + SOURCE_NAME + "] ");
        System.out.println("[-C Source Channel Name *" + CHANNEL_NAME + "] ");
        System.out.println("[-K Sink Name *" + SINK_NAME + " ]");
        System.out.println("[-x Samples to skip *" + SKIP + " ]");
        System.out.println("-P Request Path (required) e.g. \"Source/data\" ");
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setInstanceArgs(java.lang.String[])
     */
    protected boolean setInstanceArgs(String[] args) throws IllegalArgumentException
    {
        //parse args
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('S')) {
                String a=ah.getOption('S');
                if (a!=null) sourceName=a;
            }
            if (ah.checkFlag('C')) {
                String a=ah.getOption('C');
                if (a!=null) channelName=a;
            }
            if (ah.checkFlag('K')) {
                String a=ah.getOption('K');
                if (a!=null) sinkName=a;
            }
            if (ah.checkFlag('P'))
            {
                String a=ah.getOption('P');
                if (a!=null) requestPath=a;
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("NumberSubSample argument exception "+e.getMessage());
        }
        
        if(requestPath.equals(REQUEST_PATH))
        {
            System.out.println("Request Path is required");
            printUsage();
            return false;
        }

        System.out.println("Starting NumberSubSample on " + getServer() + " as " + sinkName);
        System.out.println("  Requesting " + requestPath + ";\n  supplying number as " +
            "source = " + sourceName + ", channel = " + channelName);
        System.out.println("  Use NumberSubSample -h to see optional parameters");
        return true;
    }
    
    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setParamterArrays()
     */
    protected void setParamterArrays() {
        String [] pNameArray = super.getBaseParameterNameArray();
        String [] pTypeArray = super.getBaseParameterTypeArray();
        Object [] pDefaultArray = super.getBaseParameterDefaultArray();
        
        int base = pNameArray.length;
        int numberOfparameters = 6;
        parameterNameArray = new String[base + numberOfparameters];
        parameterTypeArray = new String[base + numberOfparameters];
        parameterDefaultArray = new Object[base + numberOfparameters];
        
        for (int i = 0; i < base; i++)
        {
            parameterNameArray[i] = pNameArray[i];
            parameterTypeArray[i] = pTypeArray[i];
            parameterDefaultArray[i] = pDefaultArray[i];
        }

        parameterNameArray[base + 0] = SINK_NAME_NAME;
        parameterTypeArray[base + 0] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 0] = new String(SINK_NAME);        
        
        parameterNameArray[base + 1] = SOURCE_NAME_NAME;
        parameterTypeArray[base + 1] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 1] = new String(SOURCE_NAME);      
        
        parameterNameArray[base + 2] = CHANNEL_NAME_NAME;
        parameterTypeArray[base + 2] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 2] = new String(CHANNEL_NAME);     

        parameterNameArray[base + 3] = SKIP_NAME;
        parameterTypeArray[base + 3] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 3] = new Integer(SKIP);        
        
        parameterNameArray[base + 4] = REQUEST_PATH_NAME;
        parameterTypeArray[base + 4] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 4] = new String(REQUEST_PATH);     

        parameterNameArray[base + 5] = CACHE_SIZE_NAME;
        parameterTypeArray[base + 5] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 5] = new Integer(DEFAULT_CACHE_SIZE);      
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setVariablesFromParameters()
     */
    public void setVariablesFromParameters() {
        super.setBaseVarialbesFromParametes();
        
        sinkName = SINK_NAME;
        try{
            Object obj = getValueWithDefault(SINK_NAME_NAME, SINK_NAME);
            sinkName = (String)obj;
        } catch (Throwable ignore){}

        sourceName = SOURCE_NAME;
        try{
            Object obj = getValueWithDefault(SOURCE_NAME_NAME, SOURCE_NAME);
            sourceName = (String)obj;
        } catch (Throwable ignore){}

        channelName = CHANNEL_NAME;
        try{
            Object obj = getValueWithDefault(CHANNEL_NAME_NAME, CHANNEL_NAME);
            channelName = (String)obj;
        } catch (Throwable ignore){}

        requestPath = REQUEST_PATH;
        try{
            Object obj = getValueWithDefault(REQUEST_PATH_NAME, REQUEST_PATH);
            requestPath = (String)obj;
        } catch (Throwable ignore){}

        skip = SKIP;
        try{
            Integer i = new Integer(SKIP);
            Object obj = getValueWithDefault(SKIP_NAME, i);
            skip = ((Integer)obj).intValue();
        } catch (Throwable ignore){}

        cacheSize = DEFAULT_CACHE_SIZE;
        try{
            Integer i = new Integer(DEFAULT_CACHE_SIZE);
            Object obj = getValueWithDefault(CACHE_SIZE_NAME, i);
            cacheSize = ((Integer)obj).intValue();
        } catch (Throwable ignore){}
        
    }

    public void connect()
    {
        try {
            // Create a sink and connect:
            sink = new Sink();
            sink.OpenRBNBConnection(getServer(),sinkName);
            ChannelMap sMap = new ChannelMap();
            int index = sMap.Add(requestPath);
            sink.Subscribe(sMap,"newest");
            sinkConnected = true;
            System.out.println("NumberSubSample: Sink connection made to server = "
                + getServer() + " as " + sinkName 
                + " requesting " + requestPath + ".");
        } catch (SAPIException se) { se.printStackTrace(); }
        
        try {
            // Create a source and connect:
            source=new Source(cacheSize, "none", 0);
            source.OpenRBNBConnection(getServer(),sourceName);
            sourceConnected = true;
            System.out.println("NumberSubSample: Source connection made to server = "
                + getServer() + " as " + sourceName + " with " + channelName + ".");
        } catch (SAPIException se) { se.printStackTrace(); }
            
    }
    
    private void disconnect() {
        source.CloseRBNBConnection();
        source = null;
        sourceConnected = false;
        sink.CloseRBNBConnection();
        sink = null;
        sinkConnected = false;
    }

    private boolean connected()
    {
        return sourceConnected && sinkConnected;
    }
    
    public void startThread()
    {
        
        if (!connected()) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runWork();
            }
        };
        runit = true;
        stringDataThread = new Thread(r, "NumberSubSample");
        stringDataThread.start();
        System.out.println("NumberSubSample: Started thread.");
    }

    public void stopThread()
    {
        runit = false;
        stringDataThread.interrupt();
        System.out.println("NumberSubSample: Stopped thread.");
    }
    
    private void runWork ()
    {
        try {
            while(isRunning())
            {
                ChannelMap inMap = sink.Fetch(-1);
                double[] data = inMap.GetDataAsFloat64(0);
                double start = inMap.GetTimeStart(0);
                double duration = inMap.GetTimeDuration(0);
                count++;
                if (count > (skip + 1))
                {
                    count = 0;
                    ChannelMap outMap = new ChannelMap();
                    int index = outMap.Add(channelName);
                    outMap.PutTime(start, duration);
                    outMap.PutDataAsFloat64(index,data);
                    source.Flush(outMap);
                }
            }
        } catch (SAPIException se) {
            se.printStackTrace(); 
        }
        stringDataThread = null;
    }
    
    public boolean isRunning()
    {
        return (connected() && runit);
    }

    public String[] getParameterNameArray() {
        return parameterNameArray;
    }

    public String[] getParameterTypeArray() {
        return parameterTypeArray;
    }

    public Object[] getParameterDefaultArray() {
        return parameterDefaultArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#start()
     */
    public boolean start() {
        if (isRunning()) return false;
        if (connected()) disconnect();
        setVariablesFromParameters();
        connect();
        if (!connected()) return false;
        startThread();
        return true;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#stop()
     */
    public boolean stop() {
        if (!isRunning()) return false;
        stopThread();
        disconnect();
        return true;
    }

}

---