* The general form of usage is:
*
* lookup service [parameters...] ** where service is the name of the service to run and * parameters is one or more parameters required by the service. *
*
* Supported lookup services are:
*
*Table: Lookup values in from a file which contains ASCII, comma seperated * values. ** * @author Todd King, Steven Joy, Joe Mafi * @author IGPP/UCLA/PDS * @version 1.0, 05/21/03 * @since 1.0 */ public class Lookup { /** Nested class - internal use only. * This is a nested class which is used to store items found in the * lookup source which match the passed constraints. */ static class Item implements Comparable { /** Start time of the item */ PPITime mStart; /** Stop time of the item */ PPITime mStop; /** Value of the item. */ String mValue; /** Overlap with interval */ long mOverlap; /** The method of comparing Items. The value assigned to this * method matches the "order" option. * */ static int mCompareOrder = 0; /** * Creates an instanace. */ public Item() { } /** * Sets the overlap of the passed start and stop times with this * interval. Should be called after the mStart and mStop times * are set. * * @param start the start time of the interval. * @param stop the stop time of the interval. * */ public void setOverlap(PPITime start, PPITime stop) { long startMilli; long stopMilli; if(mStart.compareTo(start) < 0) { startMilli = start.mDate.getTimeInMillis(); } else { startMilli = mStart.mDate.getTimeInMillis(); } if(mStop.compareTo(stop) > 0) { stopMilli = stop.mDate.getTimeInMillis(); } else { stopMilli = mStop.mDate.getTimeInMillis(); } mOverlap = stopMilli - startMilli; } /** * Compares two Items. */ public int compareTo(Object o) { double diff; int c = 0; int d = 1; Item to = (Item) o; switch(mCompareOrder) { case 0: // AS_IS return 1; case 1: // CHRON_ASCENDING c = mStart.compareTo(to.mStart); d = mValue.compareTo(to.mValue); break; case 2: // CHRON_DESCENDING c = -mStart.compareTo(to.mStart); d = mValue.compareTo(to.mValue); break; case 3: // OVERLAP_ASCENDING diff = mOverlap - to.mOverlap; if(diff == 0) d = 0; if(diff < 0) d = -1; if(diff > 0) d = 1; break; case 4: // OVERLAP_DESCENDING diff = to.mOverlap - mOverlap; if(diff == 0) d = 0; if(diff < 0) d = -1; if(diff > 0) d = 1; break; case 5: // SPAN_ASCENDING diff = mStart.span(mStop) - to.mStart.span(to.mStop); if(diff == 0) d = 0; if(diff < 0) d = -1; if(diff > 0) d = 1; break; case 6: // SPAN_DESCENDING diff = to.mStart.span(to.mStop) - mStart.span(mStop); if(diff == 0) d = 0; if(diff < 0) d = -1; if(diff > 0) d = 1; break; case 7: // Remove duplicates - UNIQUE d = mValue.compareTo(to.mValue); if(d != 0) d = 1; // Keep same order - throw out duplicates break; } if(c == 0) return d; else return c; } } /** * Creates an instance. */ public Lookup() { } /** * Entry point for application. */ public static void main(String[] args) { boolean good = false; if(args.length < 1) { PPIRuleset.showRule(PPIAction.MESSAGE, "lookup plugin. Proper usage: time service {...}"); PPIRuleset.showRule(PPIAction.MESSAGE, "Available services are:"); PPIRuleset.showRule(PPIAction.MESSAGE, "\tTable: Lookup values in an ASCII table."); return; } if(args[0].compareToIgnoreCase("Table") == 0) { good = true; Table(args); } if(!good) PPIRuleset.showRule(PPIAction.MESSAGE, "time called with unknown action request. " + args[0]); } /** * Lookup values in an ASCII CSV table. * The lookup plug-in returns a PDS label parameter compatible with the PDS/PPI ruleset * language. Returned values are based upon a lookup table search. * Results are returned as a ruleset assignment and are in the form: * *
* $<parameter> = value ** * Returned values are formatted according to PDS implementation of ODL lexical standards. This * means that strings are enclosed in double quotes, and multiple value sets are enclosed in brackets * "{}". *
* Command line options *
* Required command line options: *
*
**source [character string] Name (includ ing path) of the lookup table. Lookup tables * should be ASCII CSV files with the format: start_time,stop_time,value. Here * start_time and start_time are in PDS format (truncated at the minutes), and * value is the return value assigned to that interval. * *start [PDS time*] Start time of the file to be labeled * *stop [PDS time*] Stop time of the file to be labeled * *fudge [integer] Size of the tolerance (in minutes) used * in matching the start and stop to intervals in the lookup table. * The way the fudge factor is applied depends upon the search method (see section describing search * method below) * *parameter [character string] Parameter to return (e.g. TARG_LIST). * *method [character string] Name of the method to use in search of * lookup table. Options: * * ** * Phase - Selection criteria: start >= start_time - * fudge && stop <= stop_time + fudge_factor.*
* Target - Selection criteria: start <= stop_time - * fudge && stop >= start_time + fudge_factor. *return [character string] Indicates whether to return value * will consist of a list or a single item. Options: * ** LIST - multiple values may be returned in a comma-separated list* Default for return depends upon the choice of search method.
* SINGLE - only a single value will be returned
*
* If method=0, then the default return is SINGLE. * If method=1, then the default return is LIST. *
* Optional command line options: *
*
* ** * Defaults *order [character string] Way in which a LIST will be sorted. If * return_type=SINGLE any value given for list_order is ignored. Options: * ** * CHRON_ASCENDING - ascending by start_time
* CHRON_DESCENDING - descending by start_time
* ALPHA_ASCENDING - ascending by ASCII sort of return value
* ALPHA_DESCENDING - descending by ASCII sort of return value
* AS_IS - preserve order of items in the lookup table
* *single [character string] Method by which to reduce the return value from multiple * items to a single item. Options: * ** MAX_LOOKUP - value corresponding to the interval from lookup table * of longest duration
* MIN_LOOKUP - value corresponding to the interval from lookup table of * shortest duration
* MAX_DATA - value from lookup table covering the greatest amount * (time span) of data interval
* MIN_DATA - value from lookup table covering the least amount (time * span) of data intervalmax [integer] Maximum number of items to include in a list. After a list is sorted * according to the list_order parameter, items in excess of max_list_items will * be dropped. The first item is considered item 1. max_list_items = 1 is * equivalent to return_type = SINGLE, using list_order rather than * single_method to determine what value is returned. *
* fudge=0* * PDS Time Note: Both year-month-day or year-day of year format PDS times are supported. *
* return:
* if method=Phase, return=SINGLE
* if method=Target, return=LIST
* order = AS_IS
* single=MIN_LOOKUP
* max=No maximum (all items will be returned)
*
* Examples
* excerpt from targets lookup table "GLL_TARGET.TAB" ...
*
* 1995-07-01T00:00, EOM , JUPITER
* 1997-12-16T11:30, 1997-12-16T12:45, EUROPA
* 1997-12-15T09:30, 1997-12-15T10:30, GANYMEDE
* LAUNCH , 1995-12-06T00:00, SOLAR_WIND
*
* Example 1:
* excerpt from rule set ...
*
* $lookup = "GLL_TARGET.TAB"
* $start = "1997-12-15T00:00"
* $stop = "1998-02-09T00:00"
* $fudge = 720
* $parameter = "TARG_LIST"
* $search = 1
* $return = "LIST"
*
* <RUN java lookup table source=$lookup start=$start
* stop=$stop fudge=$fudge parameter=$parameter
* method=$search return=$return>
*
* would return:
*
* $TARG_LIST = {"JUPITER","EUROPA","GANYMEDE"}
*
* [same as Example 1, except]
* $order = "CHRON_ASCENDING"
*
* <RUN java lookup table source=$lookup start=$start
* stop=$stop fudge=$fudge parameter=$parameter
* method=$search return=$return order=$order>
*
* would return:
*
* $TARG_LIST = {"JUPITER","GANYMEDE","EUROPA"}
*
* [same as Example 1, except]
* $order = "CHRON_DESCENDING"
* $max = 1
*
* <RUN java lookup table source=$lookup start=$start
* stop=$stop fudge=$fudge parameter=$parameter
* method=$search return=$return order=$order
* max=$max>
*
* would return:
*
* $TARG_LIST = "EUROPA"
*
* [same as Example 1, except]
* $search = 1
* $return = "SINGLE"
* $single = "MIN_LOOKUP"
*
* <RUN java lookup table source=$lookup start=$start
* stop=$stop fudge=$fudge parameter=$parameter
* method=$search return=$return single=$single>
*
* would return:
*
* $TARG_LIST = "GANYMEDE"
*
* [same as Example 1, except]
* $search = 0
* $return = "SINGLE"
* $single = "MIN_LOOKUP"
*
* <RUN java lookup table source=$lookup start=$start
* stop=$stop fudge=$fudge parameter=$parameter
* method=$search return=$return single=$single>
*
* would return:
*
* $TARG_LIST = "JUPITER"
*