TetradLoggerConfig which will be used to determine whether
* some event should be logged.
*
* Although one can explicity construct instance of TetradLoggerConfig and
* set them in the logger, the configuration details for most models is defined in the
* configuration.xml file and added to the logger at startup. A pre-configured
* TetradLoggerConfig for some model can be found by calling
* getTetradLoggerConfigForModel(Class)
*
* Furthermore the logger supports logging to a sequence of files in some directory. To start logging
* to a new file in the logging directory (assuming it has been set) call setNextOutputStream
* to remove this stream from the logger call removeNextOutputStream. In addiong to the feature
* arbitrary streams can be add and removed from the logger by calling addOutputStream and
* removeOutputStream.
*
* @author Tyler Gibson
*/
@SuppressWarnings({"MethodMayBeStatic"})
public class TetradLogger {
/**
* A mapping between output streams and writers used to wrap them.
*/
private final MapTetradLoggerConfig.
*/
@SuppressWarnings({"UnusedDeclaration"})
public void setEventsToLog(String... events) {
setTetradLoggerConfig(new DefaultTetradLoggerConfig(events));
}
/**
* Forces the logger to log all events, useful for testing.
*/
public void setForceLog(boolean force) {
this.forceLog = force;
if (!force) {
flush();
}
}
/**
* If there is a pre-defined configuration for the given model it is set, otherwise
* an exception is thrown.
*/
public void setConfigForClass(Class model) {
TetradLoggerConfig config = this.classConfigMap.get(model);
// if (config == null) {
// System.out.println("There is no pre-defined logger config for the model " + model);
// }
setTetradLoggerConfig(config);
}
/**
* Adds the given TetradLoggerConfig to the logger, so that it can be used
* throughout the life of the application.
*/
public void addTetradLoggerConfig(Class model, TetradLoggerConfig config) {
this.classConfigMap.put(model, config);
}
public TetradLoggerConfig getLoggerForClass(Class clazz) {
TetradLoggerConfig config = this.classConfigMap.get(clazz);
if (config == null) {
return null;
}
return config.copy();
}
/**
* Resets the logger by removing any configuration info set with setTetradLoggerConfig.
*/
public void reset() {
this.config = null;
flush();
}
/**
* States whether the logger is turned on or not.
*
* @return true iff the logger is logging.
*/
public boolean isLogging() {
return this.logging;
}
/**
* Sets whether the logger is on or not.
*/
public void setLogging(boolean logging) {
Preferences.userRoot().putBoolean("loggingActivated", logging);
this.logging = logging;
}
/**
* Flushes the writers.
*/
public void flush() {
if (this.logging) {
try {
for (Writer writer : this.writers.values()) {
writer.flush();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
for (OutputStream stream : this.writers.keySet()) {
if (stream instanceof LogDisplayOutputStream) {
LogDisplayOutputStream logStream = (LogDisplayOutputStream) stream;
logStream.moveToEnd();
}
}
}
/**
* Logs the given message with a newline associated with the given event.
*
* @param event - The name of the log event.
* @param message - The messag eto be logged.
*/
public void log(String event, String message) {
boolean eventActive = isEventActive(event);
if ((this.logging && eventActive && !writers.isEmpty())) {
try {
for (Writer writer : writers.values()) {
writer.write(message);
writer.write("\n");
writer.flush();
}
} catch (IOException e) {
// should be an error stream too?
e.printStackTrace();
}
}
}
/**
* Logs an error, this will log the message regardless of any configuration information.
* Although it won't be logged if the logger is off and of course if there are no streams
* attached.
*/
public void error(String message) {
if (this.logging) {
try {
for (Writer writer : writers.values()) {
writer.write(message);
writer.write("\n");
}
} catch (IOException e) {
// should be an error stream too?
e.printStackTrace();
}
}
}
/**
* Logs the given message regardless of the logger's getModel settings. Although nothing
* will be logged if the logger has been turned off.
*/
public void forceLogMessage(String message) {
if (this.logging) {
if (this.config == null) {
this.fireActived(new EmptyConfig(true));
}
try {
for (Writer writer : writers.values()) {
writer.write(message);
writer.write("\n");
writer.flush();
}
} catch (IOException e) {
// should be an error stream too?
e.printStackTrace();
}
}
}
/**
* Sets the OutputStream that is used to log matters out to.
*/
public void addOutputStream(OutputStream stream) {
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stream));
this.writers.put(stream, writer);
}
/**
* Removes the given stream from the logger.
*/
public void removeOutputStream(OutputStream stream) {
this.writers.remove(stream);
}
/**
* Removes all streams from the logger.
*/
public void clear() {
for (OutputStream stream : this.writers.keySet()) {
if (stream != System.out) {
try {
stream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
this.writers.clear();
this.stream = null;
}
/**
* Sets the next output stream to use for logging, call removeNextOutputStream to remove it.
* This will create the next output file in the output directory and form a stream from it and add it
* to the logger.
*
* @throws IllegalStateException - Thrown if there is an error setting the stream, the message will state
* the nature of the error.
*/
public void setNextOutputStream() {
if (logging && this.isFileLoggingEnabled()) {
File dir = new File(getLoggingDirectory());
if (!dir.exists()) {
if (!dir.mkdir()) {
throw new IllegalStateException("Could not create the output directory "
+ dir.getAbsolutePath() + ".");
}
}
if (!dir.canWrite()) {
throw new IllegalStateException("Cannot write to the directory choosen for saving output " +
" logs (" + dir.getAbsolutePath() + "). Please pick another directory.");
}
// get the next file name to use.
String prefix = getLoggingFilePrefix();
ListsetNextOutputStream will be respected.
*/
public void setFileLoggingEnabled(boolean enabled) {
Preferences.userRoot().putBoolean("enableFileLogging", enabled);
}
/**
* States whether the automatic log display is enabled or not, or returns null if
* there is no value stored in the user's prefs.
*/
public Boolean isAutomaticLogDisplayEnabled() {
// String s = Preferences.userRoot().get("allowAutomaticLogDisplay", "unknown");
// if(s.equals("unknown")){
// return null;
// }
// return s.equals("allow");
// Having the log output box pop up unrequested turned out to be annoying. Turning it off. Leaving
// the mechanism intact in case we change our mind. -Joe 3/15/2009
return false;
}
/**
* States whether log displays should be automatically displayed or not.
*/
public void setAutomaticLogDisplayEnabled(boolean enable) {
Preferences.userRoot().put("allowAutomaticLogDisplay", enable ? "allow" : "disallow");
}
/**
* @return - logging directory.
*/
public String getLoggingDirectory() {
return Preferences.userRoot().get("loggingDirectory",
Preferences.userRoot().absolutePath());
}
/**
* Sets the logging directory, but first checks whether we can write to it etc.
*
* @param directory - The directory to set.
* @throws IllegalStateException if there is a problem with the directory.
*/
public void setLoggingDirectory(String directory) {
File selectedFile = new File(directory);
if (selectedFile.exists() && !selectedFile.isDirectory()) {
throw new IllegalStateException("That 'output directory' is actually a file, not a directory");
}
if (selectedFile.exists() && selectedFile.isDirectory() & !selectedFile.canWrite()) {
throw new IllegalStateException("The output directory cannot be written to.");
}
if (!selectedFile.exists()) {
boolean created = selectedFile.mkdir();
if (!created) {
throw new IllegalStateException("The output directory cannot be created. ");
}
if (!selectedFile.canWrite()) {
throw new IllegalStateException("That output directory cannot be written to. " +
"Keeping the old one.");
}
selectedFile.delete();
}
Preferences.userRoot().put("loggingDirectory", selectedFile.getAbsolutePath());
}
//========================================= Private Method ============================//
/**
* States whether the given event is active or not.
*/
public boolean isEventActive(String id) {
return this.forceLog || (this.config != null && this.config.isEventActive(id));
}
/**
* Normalizes the prefix.
*/
private String normalize(String prefix) {
StringBuilder buf = new StringBuilder();
Pattern pattern = Pattern.compile("[a-zA-Z_]");
for (int i = 0; i < prefix.length(); i++) {
String s = prefix.substring(i, i + 1);
Matcher matcher = pattern.matcher(s);
if (matcher.matches()) {
buf.append(s);
}
}
return buf.toString();
}
private void fireActived(TetradLoggerConfig config) {
if (this.logging && !this.listeners.isEmpty()) {
TetradLoggerEvent evt = new TetradLoggerEvent(this, config);
for (TetradLoggerListener l : this.listeners) {
l.configurationActived(evt);
}
}
}
private void fireDeactived() {
if (this.logging && !this.listeners.isEmpty() && this.config == null) {
TetradLoggerEvent evt = new TetradLoggerEvent(this, null);
for (TetradLoggerListener l : this.listeners) {
l.configurationDeactived(evt);
}
}
}
public String getLatestFilePath() {
return latestFilePath;
}
public TetradLoggerConfig getLoggerConfig() {
return this.config;
}
//================================ Inner classes ====================================//
/**
* A empty config, where no event is active.
*/
public static class EmptyConfig implements TetradLoggerConfig {
static final long serialVersionUID = 23L;
private final boolean active;
@SuppressWarnings({"SameParameterValue"})
public EmptyConfig(boolean active) {
this.active = active;
}
/**
* Generates a simple exemplar of this class to test serialization.
*/
public static EmptyConfig serializableInstance() {
return new EmptyConfig(true);
}
public boolean isEventActive(String id) {
return this.active;
}
public boolean isActive() {
return this.active;
}
public TetradLoggerConfig copy() {
return new EmptyConfig(active);
}
public List