WalkerSource.java

/*
 * Created on Feb 5, 2004
 *
 * A RBNB source that generates numbers in a bounded random walk.
 */

package org.nees.rbnb;

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

public class WalkerSource extends RBNBBase{
    
    // set the source for the random walk data
    private SimpleRandomWalk base = new SimpleRandomWalk();
    
    private static final String SOURCE_NAME_NAME = "SourceName";
    private static final String SOURCE_NAME = "RandomWalk";
    private static final String CHANNEL_NAME_NAME = "ChannelName";
    private static final String CHANNEL_NAME = "RandomWalkData";
    private static final String TIMER_INTERVAL_NAME = "TimerInterval";
    private static final long TIMER_INTERVAL=1000;
    private static final String CHANNEL_COUNT_NAME = "ChannelCount";
    private static final int CHANNEL_COUNT = 1;
    private static final String CACHE_SIZE_NAME = "CacheSize";  
    private static final int DEFAULT_CACHE_SIZE=100;
    
    private String sourceName = SOURCE_NAME;
    private String channelName = CHANNEL_NAME;
    private long timerInterval = TIMER_INTERVAL;
    private int cacheSize = DEFAULT_CACHE_SIZE;
    private int channelCount = CHANNEL_COUNT;
    
    Source source = null;
    ChannelMap sMap;
    int index;
    boolean connected = false;
    
    Thread timerThread;
    boolean runit = false;
    
    private String[] parameterNameArray;
    private String[] parameterTypeArray;
    private Object[] parameterDefaultArray;
    
    public static void main(String[] args) {
        // start from command line
        WalkerSource w = new WalkerSource();
        if (w.setArgs(args))
        {
            w.connect();
            w.startThread();
        }
    }
    
    public WalkerSource()
    {
        setParamterArrays();
        initialize();
    }

    public void printUsage() {
        System.out.println("WalkerSource: usage is...");        
        System.out.println("WalkerSource ");
        super.printUsage();  // uses h, s, p
        System.out.println("[-n source_name *" + SOURCE_NAME + "] ");
        System.out.println("[-c channel_name *" + CHANNEL_NAME + "] ");
        System.out.println("[-m number of channels *" + CHANNEL_COUNT+ " ]");
        System.out.println("[-t timer_interval *" + TIMER_INTERVAL + "]");
        System.out.println("[-z cache size *" + DEFAULT_CACHE_SIZE + "]");
        System.out.println();
    }

    protected boolean setInstanceArgs(String[] args) throws IllegalArgumentException
    {
        //parse args
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('n')) {
                String a=ah.getOption('n');
                if (a!=null) sourceName=a;
            }
            if (ah.checkFlag('c')) {
                String a=ah.getOption('c');
                if (a!=null) channelName=a;
            }
            if (ah.checkFlag('t')) {
                String a=ah.getOption('t');
                if (a!=null) timerInterval=Long.parseLong(a);
            }
            if (ah.checkFlag('z')) {
                String a=ah.getOption('z');
                if (a!=null)
                try
                {
                    Integer i =  new Integer(a);
                    int value = i.intValue();
                    cacheSize = value;
                    System.out.println("sizes " + cacheSize + "," + value);
                }
                catch (Exception ignore) {} 
            }
            if (ah.checkFlag('m')) {
                String a=ah.getOption('m');
                if (a!=null)
                try
                {
                    Integer i =  new Integer(a);
                    int value = i.intValue();
                    channelCount = value;
                    System.out.println("channel count " + channelCount + "," + value);
                }
                catch (Exception ignore) {} 
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("Argument Exception: " + e);
        }
        
        System.out.println("Starting WalkerSource on " + getServer() + " as " + sourceName);
        System.out.println("  Channel name = " + channelName + "; timer interval = " + timerInterval);
        System.out.println("  Cache Size = " + cacheSize + " Channel Count = " + channelCount);
        System.out.println("  Use WalkerSource -h to see optional parameters");
        
        return true;
    }
    
/*  public WalkerSource(String server_host, String source_name, String channel_name,
        long timer_interval, int cache_size, int channel_count)
    {
        this();
        sourceName = source_name;
        channelName = channel_name;
        timerInterval = timer_interval;
        cacheSize = cache_size;
        channelCount = channel_count;
        
        System.out.println("Starting WalkerSource on " + getServer() + " as " + sourceName);
        System.out.println("  Channel name = " + channelName + "; timer interval = " + timerInterval);
        System.out.println("  Cache Size = " + cacheSize + " Channel Count = " + channelCount);
        System.out.println("  Use WalkerSource -h to see optional parameters");
    }
    */

    protected void setParamterArrays() {

        String [] pNameArray = super.getBaseParameterNameArray();
        String [] pTypeArray = super.getBaseParameterTypeArray();
        Object [] pDefaultArray = super.getBaseParameterDefaultArray();
        
        int base = pNameArray.length;
        int numberOfparameters = 5;
        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] = SOURCE_NAME_NAME;
        parameterTypeArray[base + 0] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 0] = new String(SOURCE_NAME);      

        parameterNameArray[base + 1] = CHANNEL_NAME_NAME;
        parameterTypeArray[base + 1] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 1] = new String(CHANNEL_NAME);     

        parameterNameArray[base + 2] = TIMER_INTERVAL_NAME;
        parameterTypeArray[base + 2] = RBNBBaseParameterHolder.LONG_TYPE;
        parameterDefaultArray[base + 2] = new Long(TIMER_INTERVAL);     

        parameterNameArray[base + 3] = CHANNEL_COUNT_NAME;
        parameterTypeArray[base + 3] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 3] = new Integer(CHANNEL_COUNT);       

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

    }
    
    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setVariablesFromParameters()
     */
    public void setVariablesFromParameters() {
        super.setBaseVarialbesFromParametes();
        
        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){}

        timerInterval = TIMER_INTERVAL;
        try{
            Long l = new Long(TIMER_INTERVAL);
            Object obj = getValueWithDefault(TIMER_INTERVAL_NAME, l);
            timerInterval = ((Long)obj).longValue();
        } catch (Throwable ignore){}

        channelCount = CHANNEL_COUNT;
        try{
            Integer i = new Integer(CHANNEL_COUNT);
            Object obj = getValueWithDefault(CHANNEL_COUNT_NAME, i);
            channelCount = ((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()
    {
System.out.println("WalkerSource: Attempting to connect to server = "
    + getServer() + " as " + sourceName + " with " + channelName + ".");
        try {
            // Create a source and connect:
            source=new Source(cacheSize, "none", 0);
            source.OpenRBNBConnection(getServer(),sourceName);
            connected = true;
            System.out.println("WalkerSource: Connection made to server = "
                + getServer() + " as " + sourceName + " with " + channelName + ".");
        } catch (SAPIException se) { se.printStackTrace(); }
    }

    private void disconnect() {
        source.CloseRBNBConnection();
        connected = false;
        source = null;
    }

    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;
        timerThread = new Thread(r, "Timer");
        timerThread.start();
        System.out.println("WalkerSource: Started thread.");
    }

    public void stopThread()
    {
        if (!connected) return;
        
        runit = false;
        timerThread.interrupt();
        System.out.println("WalkerSource: Stopped thread.");
    }
    
    private void runWork ()
    {
        String[] names = new String[channelCount];
        names[0] = channelName;
        for (int i = 1; i < channelCount; i++)
        {
            names[i] = channelName + i;
        }
        try 
        {
            while(connected && runit)
            {
                // Push data onto the server:
                // System.out.print("Put new data to server: ");
                sMap = new ChannelMap();
                int index[] = new int[channelCount];
                for (int i = 0; i < channelCount; i++)
                    index[i] = sMap.Add(names[i]);
                sMap.PutTimeAuto("timeofday");
                for (int i = 0; i < channelCount; i++)
                {
                    double data[] = new double[1];
                    data[0] = base.next();
                    sMap.PutDataAsFloat64(index[i],data);
                }
                // System.out.println("" + data[0]);
                source.Flush(sMap);
                Thread.sleep(timerInterval);
            }
        } catch (SAPIException se) {
            se.printStackTrace(); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stop();
    }
    
    public boolean isRunning()
    {
        return (connected && runit);
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterNameArray()
     */
    public String[] getParameterNameArray() {
        return parameterNameArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterTypeArray()
     */
    public String[] getParameterTypeArray() {
        return parameterTypeArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterDefaultArray()
     */
    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;
    }

}

---