public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
long now = DateTime.getCurrentTimeSec();
long sts = now - DateTime.DaySeconds(3);
long ets = now;
GoogleChartTemperature gct = new GoogleChartTemperature();
try {
gct.setSize(700, 400);
gct.setTitle(Color.black, 16, "Temperature");
gct.setTemperatureRange(1, F2C(0.0), F2C(130.0), 10);
gct.setDateRange(new DateTime(sts), new DateTime(ets), 8);
gct.setDateFormat("MM/dd");
gct.setTimeFormat("HH:mm:ss");
int setCount = 3;
int tempCount = 15;
gct._addRandomSampleData(setCount, tempCount);
System.out.println(gct.toString());
} catch (Throwable th) {
Print.logException("Error", th);
System.exit(1);
}
}
protected boolean _setDevice(Device device, String ipAddress, int clientPort) {
/* valid device? */
if (device == null) {
return false;
}
/* validate ID address */
DataTransport dataXPort = device.getDataTransport();
if ((ipAddress != null) && !dataXPort.isValidIPAddress(ipAddress)) {
Print.logError(
"Invalid IPAddr: "
+ device.getAccountID()
+ "/"
+ device.getDeviceID()
+ " Found="
+ ipAddress
+ " Expect="
+ dataXPort.getIpAddressValid());
return false;
}
/* update device */
this.device = device;
this.dataXPort = dataXPort;
this.dataXPort.setIpAddressCurrent(ipAddress); // FLD_ipAddressCurrent
this.dataXPort.setRemotePortCurrent(clientPort); // FLD_remotePortCurrent
this.dataXPort.setDeviceCode(this.getDeviceCode()); // FLD_deviceCode
this.device.setLastTotalConnectTime(DateTime.getCurrentTimeSec()); // FLD_lastTotalConnectTime
/* ok */
return true;
}
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append(CHART_API_URL);
sb.append("uniq=").append(DateTime.getCurrentTimeSec()).append("&");
sb.append("cht=").append(this.cht).append("&");
sb.append("chs=").append(this.chs).append("&");
sb.append("chxt=").append(this.chxt).append("&");
sb.append("chg=").append(this.chg).append("&");
sb.append("chxl=").append(this.chxl).append("&");
sb.append("chts=").append(this.chts).append("&");
sb.append("chtt=").append(this.chtt).append("&");
sb.append("chco=").append(this.chco).append("&");
sb.append("chdl=").append(this.chdl).append("&");
sb.append("chd=").append(this.chd).append("&");
sb.append("chm=").append(this.chm);
return sb.toString();
}
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
long ts = DateTime.getCurrentTimeSec();
double C = -5.6;
TemperatureSet TSList[] = new TemperatureSet[3];
for (int s = 0; s < TSList.length; s++) {
TemperatureSet TS = new TemperatureSet();
for (int i = 0; i < 10; i++) {
long tempTS = ts + (12345L * (i + 1) * (s + 1));
double tempC = C + (2.3 * i) + (1.1 * s);
Print.logInfo(s + ":" + i + "] Adding " + tempTS + ", " + tempC);
TS.addTemperature(tempTS, tempC);
}
TSList[s] = TS;
}
String t = TemperatureSet.CreateGoogleDataTableJavaScript(false, TSList);
Print.sysPrintln(t);
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
/* help */
if (RTConfig.hasProperty(ARG_HELP)) {
_usage();
System.exit(1); // control does not reach here
}
/* extra args */
String extraArgs = RTConfig.getString(ARG_EXTRA, "");
if (!StringTools.isBlank(extraArgs)) {
// Print.logInfo("Extra: " + extraArgs);
RTProperties cfgProps = RTConfig.getConfigFileProperties();
if (extraArgs.indexOf(",") > 0) {
cfgProps.setProperties(extraArgs, ',');
} else {
cfgProps.setProperties(extraArgs);
}
// cfgProps.printProperties("");
}
/* special case "expire" */
String ARG_EXPIRE = "expire";
RTProperties expireRTP = RTConfig.getPropertiesForKey(ARG_EXPIRE, false);
if (expireRTP != null) {
Print.errPrintln("\n'expire' cannot be defined.");
System.exit(1);
}
/* args */
File directory = RTConfig.getFile(ARG_DIR, null);
String templateName =
StringTools.trim(RTConfig.getString(ARG_OPTIONAL, RTConfig.getString(ARG_TEMPLATE, "")));
boolean isOptional = RTConfig.hasProperty(ARG_OPTIONAL);
String packageName = StringTools.trim(RTConfig.getString(ARG_PACKAGE, null));
String outputName = RTConfig.getString(ARG_OUTPUT, "");
boolean overwrite = RTConfig.getBoolean(ARG_OVERWRITE, false);
/* cannot specify "-output=inline" if internal template specified */
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output will be to "stdout"
outputName = "";
} else if (outputName.equalsIgnoreCase("inline")) {
// -- output will be to input file
if (templateName.startsWith(TEMPLATE_)) {
// -- @template not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with internal template");
_usage();
System.exit(1); // control does not reach here
} else if (isOptional) {
// -- optional not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with optional template");
_usage();
System.exit(1); // control does not reach here
} else if (!templateName.startsWith("*")) {
// -- output to input file
outputName = templateName;
}
} else {
// -- output to specified file
if (templateName.startsWith("*")) {
// -- template specifies a file-glob
Print.errPrintln(
"\nError: Cannot specify '-output=FILE' for recursize template specification");
_usage();
System.exit(1); // control does not reach here
}
}
/* template name file? */
if (templateName.startsWith("*")) {
if (isOptional) {
// -- optional not allowed with glob file specification
Print.errPrintln("\nError: Cannot specify optional '-template?=[**/]*.java'");
_usage();
System.exit(1); // control does not reach here
}
} else {
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
if (!file.isFile() && isOptional) {
// -- templateName doesn't exist and is optional
templateName = TEMPLATE_DEFAULT;
}
}
/* random */
Random rand = new Random();
if (!RTConfig.hasProperty("random.16")) {
RTConfig.setString("random.16", "0x" + StringTools.toHexString(rand.nextInt() & 0xFFFF, 16));
}
if (!RTConfig.hasProperty("random.32")) {
RTConfig.setString("random.32", "0x" + StringTools.toHexString(rand.nextInt(), 32));
}
if (!RTConfig.hasProperty("random.64")) {
RTConfig.setString("random.64", "0x" + StringTools.toHexString(rand.nextLong(), 64));
}
/* set current time (subject to change) */
String tzStr = RTConfig.getString("timezone", null);
TimeZone tz =
!StringTools.isBlank(tzStr) ? DateTime.getTimeZone(tzStr) : DateTime.getDefaultTimeZone();
DateTime now = new DateTime(tz);
if (!RTConfig.hasProperty("timetamp")) {
RTConfig.setLong("timestamp", now.getTimeSec());
}
if (!RTConfig.hasProperty("datetime")) {
RTConfig.setString("datetime", now.format("yyyy/MM/dd HH:mm:ss z"));
}
if (!RTConfig.hasProperty("date")) {
RTConfig.setString("date", now.format("yyyy/MM/dd"));
}
if (!RTConfig.hasProperty("time")) {
RTConfig.setString("time", now.format("HH:mm:ss"));
}
if (!RTConfig.hasProperty("timezone")) {
RTConfig.setString("timezone", now.format("z"));
}
/* special case "daysUntil" */
// %{daysUntil=2012:02:20} <== fixed time
String ARG_daysUntil_ = "daysUntil";
Set<String> daysUntil_keys = RTConfig.getPropertyKeys(ARG_daysUntil_, false);
for (String daysUntil_key : daysUntil_keys) {
String daysUntil_key_date = daysUntil_key + ".date";
RTProperties daysUntilRTP = RTConfig.getPropertiesForKey(daysUntil_key, false);
if (daysUntilRTP != null) {
// -- get/update the RTProperties where "daysUntil" is defined
String daysUntil = daysUntilRTP.getString(daysUntil_key, "");
if (StringTools.isBlank(daysUntil)) {
// -- remove keys
daysUntilRTP.removeProperty(daysUntil_key);
daysUntilRTP.removeProperty(daysUntil_key_date);
// Print.sysPrintln(daysUntil_key + " ==> <removed>");
// Print.sysPrintln(daysUntil_key_date + " ==> <removed>");
} else if ((daysUntil.indexOf("/") >= 0) || (daysUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd" to "DD"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (daysUntil.startsWith("'") || daysUntil.startsWith("\"")) {
daysUntil = daysUntil.substring(1); // remove prefixing quote
}
if (daysUntil.endsWith("'") || daysUntil.endsWith("\"")) {
daysUntil = daysUntil.substring(0, daysUntil.length() - 1); // remove trailing quote
}
try {
DateTime nowDT = new DateTime(DateTime.getGMTTimeZone());
DateTime futDT = DateTime.parseArgumentDate(daysUntil, null, true);
long nowDay = DateTime.getDayNumberFromDate(nowDT);
long futDay = DateTime.getDayNumberFromDate(futDT);
long deltaD = futDay - nowDay;
if (deltaD == 0L) {
// -- today
deltaD = 1L; // make it tomorrow
} else if (deltaD < 0L) {
// -- this means that the date has already passed
// deltaD = -1L; // already negative
} else {
deltaD += 1L; // add one more day
}
daysUntilRTP.setString(daysUntil_key, String.valueOf(deltaD));
daysUntilRTP.setString(daysUntil_key_date, futDT.format(DateTime.DEFAULT_DATE_FORMAT));
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + daysUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysUntil, 0L));
daysUntilRTP.setString(
daysUntil_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
}
}
}
/* special case "daysFromNow" */
// %{daysFromNow=30} <== 30 days from now
String ARG_daysFromNow_ = "daysFromNow";
Set<String> daysFromNow_keys = RTConfig.getPropertyKeys(ARG_daysFromNow_, false);
for (String daysFromNow_key : daysFromNow_keys) {
String daysFromNow_key_date = daysFromNow_key + ".date";
RTProperties daysFromNowRTP = RTConfig.getPropertiesForKey(daysFromNow_key, false);
if (daysFromNowRTP != null) {
// -- get/update the RTProperties where "daysFromNow" is defined
String daysFromNow = daysFromNowRTP.getString(daysFromNow_key, "");
if (StringTools.isBlank(daysFromNow)) {
// -- remove keys
daysFromNowRTP.removeProperty(daysFromNow_key);
daysFromNowRTP.removeProperty(daysFromNow_key_date);
// Print.sysPrintln(daysFromNow_key + " ==> <removed>");
// Print.sysPrintln(daysFromNow_key_date + " ==> <removed>");
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysFromNow, 0L));
daysFromNowRTP.setString(daysFromNow_key, String.valueOf(futSec));
daysFromNowRTP.setString(
daysFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysFromNow_key + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key ,"?"));
// Print.sysPrintln(daysFromNow_key_date + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key_date,"?"));
}
}
}
/* special case "secondsUntil" */
// %{secondsUntil_abc=2012:02:20} <== fixed time
// %{secondsUntil_abc=86400} <== relative time (86400 seconds from now)
String ARG_secondsUntil_ = "secondsUntil";
Set<String> secUntil_keys = RTConfig.getPropertyKeys(ARG_secondsUntil_, false);
for (String secUntil_key : secUntil_keys) {
String secUntil_key_date = secUntil_key + ".date";
RTProperties secUntilRTP = RTConfig.getPropertiesForKey(secUntil_key, false);
if (secUntilRTP != null) {
// -- get/update the RTProperties where "secondsUntil" is defined
String secUntil = secUntilRTP.getString(secUntil_key, "");
if (StringTools.isBlank(secUntil)) {
// remove keys
secUntilRTP.removeProperty(secUntil_key);
secUntilRTP.removeProperty(secUntil_key_date);
// Print.sysPrintln(secUntil_key + " ==> <removed>");
// Print.sysPrintln(secUntil_key_date + " ==> <removed>");
} else if ((secUntil.indexOf("/") >= 0) || (secUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd:HH:MM:SS" to "ssssss"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (secUntil.startsWith("'") || secUntil.startsWith("\"")) {
secUntil = secUntil.substring(1); // remove prefixing quote
}
if (secUntil.endsWith("'") || secUntil.endsWith("\"")) {
secUntil = secUntil.substring(0, secUntil.length() - 1); // remove trailing quote
}
try {
long nowSec = DateTime.getCurrentTimeSec();
DateTime futDT = DateTime.parseArgumentDate(secUntil, null, true);
long futSec = futDT.getTimeSec();
long deltaS = futSec - nowSec;
if (deltaS == 0L) {
// -- now
deltaS = 1L; // make it 1 second from now
} else if (deltaS < 0L) {
// -- this means that the time has already passed
// deltaS = -1L; // already negative
} else {
deltaS += 1L; // add one more second
}
secUntilRTP.setString(secUntil_key, String.valueOf(deltaS));
secUntilRTP.setString(secUntil_key_date, futDT.toString());
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + secUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secUntil, 0L);
secUntilRTP.setString(secUntil_key_date, (new DateTime(futSec)).toString());
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
}
}
}
/* special case "secondsFromNow" */
// %{secondsFromNow=30} <== 30 seconds from now
String ARG_secondsFromNow_ = "secondsFromNow";
Set<String> secondsFromNow_keys = RTConfig.getPropertyKeys(ARG_secondsFromNow_, false);
for (String secondsFromNow_key : secondsFromNow_keys) {
String secondsFromNow_key_date = secondsFromNow_key + ".date";
RTProperties secondsFromNowRTP = RTConfig.getPropertiesForKey(secondsFromNow_key, false);
if (secondsFromNowRTP != null) {
// -- get/update the RTProperties where "secondsFromNow" is defined
String secondsFromNow = secondsFromNowRTP.getString(secondsFromNow_key, "");
if (StringTools.isBlank(secondsFromNow)) {
// -- remove keys
secondsFromNowRTP.removeProperty(secondsFromNow_key);
secondsFromNowRTP.removeProperty(secondsFromNow_key_date);
// Print.sysPrintln(secondsFromNow_key + " ==> <removed>");
// Print.sysPrintln(secondsFromNow_key_date + " ==> <removed>");
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secondsFromNow, 0L);
secondsFromNowRTP.setString(secondsFromNow_key, String.valueOf(futSec));
secondsFromNowRTP.setString(
secondsFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(secondsFromNow_key + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key ,"?"));
// Print.sysPrintln(secondsFromNow_key_date + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key_date,"?"));
}
}
}
/* special case "limit" */
String ARG_limit_ = "limit";
Set<String> limit_keys = RTConfig.getPropertyKeys(ARG_limit_, false);
for (String limit_key : limit_keys) {
RTProperties limitRTP = RTConfig.getPropertiesForKey(limit_key, false);
if (limitRTP != null) {
String limit = limitRTP.getString(limit_key, "");
if (StringTools.isBlank(limit)) {
limitRTP.removeProperty(limit_key);
// Print.sysPrintln(limit_key + " ==> <removed>");
} else {
// Print.sysPrintln(limit_key + " ==> " + limit);
}
}
}
/* adjust packageName */
if (packageName.equals(JAVA_PACKAGE)) {
Print.errPrintln(
"\nWarning: 'package' argument cannot equal \"package\" (setting to empty string).");
packageName = "";
}
// --------------------------------------
/* internal template (single pass only) */
if (StringTools.isBlank(templateName) || templateName.startsWith(TEMPLATE_)) {
try {
// -- input source
String inputSource = standardTemplate(templateName, packageName);
if (StringTools.isBlank(inputSource)) {
if (isOptional) {
// -- optional "templateName" not defined, use default template
inputSource = standardTemplate(null, packageName); // non-blank
} else {
throw new IOException("Standard template not found: " + templateName);
}
}
// -- write template output
File outputFile = CompiletimeVars.getOutputFile(directory, outputName, overwrite);
CompiletimeVars.writeOutputSource(inputSource, outputFile);
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
// -- error writin file
Print.errPrintln("\nError writing template: " + ioe.getMessage());
System.exit(1);
}
System.exit(0);
}
// --------------------------------------
/* get input file(s) */
File inputFileArray[] = null;
if (templateName.startsWith("**/*.")) {
// -- all files, in all directories (recursive)
String fileGlob = templateName.substring(3);
File files[] = FileTools.getFiles(directory, fileGlob, true);
inputFileArray = files;
} else if (templateName.startsWith("*.")) {
// -- all files in specified directory
String fileGlob = templateName;
File files[] = FileTools.getFiles(directory, fileGlob, false);
inputFileArray = files;
} else {
// -- single specific file
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
inputFileArray = new File[] {file};
}
/* loop through input files */
boolean singlePass = false;
for (File inputFile : inputFileArray) {
/* file must exist here */
if (!inputFile.isFile()) {
// -- not a file
continue;
}
/* get input source from template file */
String inputSource = CompiletimeVars.readTemplate(inputFile, packageName);
if (StringTools.isBlank(inputSource)) {
// -- inputSource not available?
continue;
}
/* precheck output file */
File outputFile = null;
try {
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output to stdout (multi-pass ok)
} else if (outputName.equalsIgnoreCase("inline")) {
// -- write back to template file (multi-pass ok)
overwrite = true; // assume implied overwrite
outputFile = inputFile;
} else {
// -- output to specified file (single-pass only)
outputFile = getOutputFile(directory, outputName, overwrite);
singlePass = true;
}
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
Print.errPrintln("\nInvalid output file: " + ioe.getMessage());
System.exit(1);
}
/* adjust source and write output */
try {
CompiletimeVars.writeOutputSource(inputSource, outputFile);
if (singlePass) {
break;
}
} catch (IOException ioe) {
Print.errPrintln("\nError writing file: " + ioe.getMessage());
System.exit(1);
}
}
/* success */
System.exit(0);
}