Java 类ch.qos.logback.core.util.OptionHelper 实例源码

private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
        String logFile) {
    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    appender.setEncoder(encoder);
    config.start(encoder);

    appender.setFile(logFile);

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setFileNamePattern(logFile + ".%i");
    appender.setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(appender);
    config.start(rollingPolicy);

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    triggeringPolicy.setMaxFileSize("10MB");
    appender.setTriggeringPolicy(triggeringPolicy);
    config.start(triggeringPolicy);

    config.appender("FILE", appender);
    return appender;
}

private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
        String logFile) {
    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    appender.setEncoder(encoder);
    config.start(encoder);

    appender.setFile(logFile);

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setFileNamePattern(logFile + ".%i");
    appender.setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(appender);
    config.start(rollingPolicy);

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    triggeringPolicy.setMaxFileSize("10MB");
    appender.setTriggeringPolicy(triggeringPolicy);
    config.start(triggeringPolicy);

    config.appender("FILE", appender);
    return appender;
}

/**
 * Attempt to create a converter using the information found in
 * 'converterMap'.
 *
 * @param kn
 * @return
 */
@SuppressWarnings("unchecked")
DynamicConverter<E> createConverter(SimpleKeywordNode kn) {
  String keyword = (String) kn.getValue();
  String converterClassStr = (String) converterMap.get(keyword);

  if (converterClassStr != null) {
    try {
      return (DynamicConverter) OptionHelper.instantiateByClassName(
              converterClassStr, DynamicConverter.class, context);
    } catch (Exception e) {
      addError("Failed to instantiate converter class [" + converterClassStr
              + "] for keyword ["+keyword+"]", e);
      return null;
    }
  } else {
    addError("There is no conversion class registered for conversion word ["
            + keyword + "]");
    return null;
  }
}

/**
 * Attempt to create a converter using the information found in
 * 'compositeConverterMap'.
 *
 * @param cn
 * @return
 */
@SuppressWarnings("unchecked")
CompositeConverter<E> createCompositeConverter(CompositeNode cn) {
  String keyword = (String) cn.getValue();
  String converterClassStr = (String) converterMap.get(keyword);

  if (converterClassStr != null) {
    try {
      return (CompositeConverter) OptionHelper.instantiateByClassName(
              converterClassStr, CompositeConverter.class, context);
    } catch (Exception e) {
      addError("Failed to instantiate converter class [" + converterClassStr
              + "] as a composite converter for keyword ["+keyword+"]", e);
      return null;
    }
  } else {
    addError("There is no conversion class registered for composite conversion word ["
            + keyword + "]");
    return null;
  }
}

private String lookupKey(String key) {
  String value = propertyContainer0.getProperty(key);
  if (value != null)
    return value;

  if (propertyContainer1 != null) {
    value = propertyContainer1.getProperty(key);
    if (value != null)
      return value;
  }

  value = OptionHelper.getSystemProperty(key, null);
  if (value != null)
    return value;

  value = OptionHelper.getEnv(key);
  if (value != null) {
    return value;
  }

  return null;
}

URL getInputURL(InterpretationContext ec, Attributes attributes) {
  String fileAttribute = attributes.getValue(FILE_ATTR);
  String urlAttribute = attributes.getValue(URL_ATTR);
  String resourceAttribute = attributes.getValue(RESOURCE_ATTR);

  if (!OptionHelper.isEmpty(fileAttribute)) {
    this.attributeInUse = ec.subst(fileAttribute);
    return filePathAsURL(attributeInUse);
  }

  if (!OptionHelper.isEmpty(urlAttribute)) {
    this.attributeInUse = ec.subst(urlAttribute);
    return attributeToURL(attributeInUse);
  }

  if (!OptionHelper.isEmpty(resourceAttribute)) {
    this.attributeInUse = ec.subst(resourceAttribute);
    return resourceAsURL(attributeInUse);
  }
  // given previous checkAttributes() check we cannot reach this line
  throw new IllegalStateException("A URL stream should have been returned");

}

/**
 * Gets the set of enabled protocols based on the configuration.
 * @param supportedProtocols protocols supported by the SSL engine 
 * @param defaultProtocols default protocols enabled by the SSL engine
 * @return enabled protocols
 */
private String[] enabledProtocols(String[] supportedProtocols,
    String[] defaultProtocols) {
  if (enabledProtocols == null) {
    // we're assuming that the same engine is used for all configurables
    // so once we determine the enabled set, we won't do it again
    if (OptionHelper.isEmpty(getIncludedProtocols())
        && OptionHelper.isEmpty(getExcludedProtocols())) {
      enabledProtocols = Arrays.copyOf(defaultProtocols, 
          defaultProtocols.length);
    }
    else {
      enabledProtocols = includedStrings(supportedProtocols, 
          getIncludedProtocols(), getExcludedProtocols());
    }
    for (String protocol : enabledProtocols) {
      addInfo("enabled protocol: " + protocol);
     }
  }
  return enabledProtocols;
}

/**
 * Gets the set of enabled cipher suites based on the configuration.
 * @param supportedCipherSuites cipher suites supported by the SSL engine 
 * @param defaultCipherSuites default cipher suites enabled by the SSL engine
 * @return enabled cipher suites
 */
private String[] enabledCipherSuites(String[] supportedCipherSuites,
    String[] defaultCipherSuites) {
  if (enabledCipherSuites == null) {
    // we're assuming that the same engine is used for all configurables
    // so once we determine the enabled set, we won't do it again
    if (OptionHelper.isEmpty(getIncludedCipherSuites())
        && OptionHelper.isEmpty(getExcludedCipherSuites())) {
      enabledCipherSuites = Arrays.copyOf(defaultCipherSuites, 
          defaultCipherSuites.length);
    }
    else {
      enabledCipherSuites = includedStrings(supportedCipherSuites, 
          getIncludedCipherSuites(), getExcludedCipherSuites());
    }
    for (String cipherSuite : enabledCipherSuites) {
      addInfo("enabled cipher suite: " + cipherSuite);
    }
  }
  return enabledCipherSuites;
}

void processScanAttrib(InterpretationContext ic, Attributes attributes) {
  String scanAttrib = ic.subst(attributes.getValue(SCAN_ATTR));
  if (!OptionHelper.isEmpty(scanAttrib)
          && !"false".equalsIgnoreCase(scanAttrib)) {
    ReconfigureOnChangeFilter rocf = new ReconfigureOnChangeFilter();
    rocf.setContext(context);
    String scanPeriodAttrib = ic.subst(attributes.getValue(SCAN_PERIOD_ATTR));
    if (!OptionHelper.isEmpty(scanPeriodAttrib)) {
      try {
        Duration duration = Duration.valueOf(scanPeriodAttrib);
        rocf.setRefreshPeriod(duration.getMilliseconds());
        addInfo("Setting ReconfigureOnChangeFilter scanning period to "
                + duration);
      } catch (NumberFormatException nfe) {
        addError("Error while converting [" + scanAttrib + "] to long", nfe);
      }
    }
    rocf.start();
    LoggerContext lc = (LoggerContext) context;
    addInfo("Adding ReconfigureOnChangeFilter as a turbo filter");
    lc.addTurboFilter(rocf);
  }
}

/**
 * FOR INTERNAL USE. This method is intended for use by  StaticLoggerBinder.
 *  
 * @param defaultLoggerContext
 * @throws ClassNotFoundException
 * @throws NoSuchMethodException
 * @throws InstantiationException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 */
public void init(LoggerContext defaultLoggerContext, Object key) throws ClassNotFoundException,
    NoSuchMethodException, InstantiationException, IllegalAccessException,
    InvocationTargetException  {
  if(this.key == null) {
    this.key = key;
  } else if (this.key != key) {
    throw new IllegalAccessException("Only certain classes can access this method.");
  }


  String contextSelectorStr = OptionHelper
      .getSystemProperty(ClassicConstants.LOGBACK_CONTEXT_SELECTOR);
  if (contextSelectorStr == null) {
    contextSelector = new DefaultContextSelector(defaultLoggerContext);
  } else if (contextSelectorStr.equals("JNDI")) {
    // if jndi is specified, let's use the appropriate class
    contextSelector = new ContextJNDISelector(defaultLoggerContext);
  } else {
    contextSelector = dynamicalContextSelector(defaultLoggerContext,
        contextSelectorStr);
  }
}

public void begin(InterpretationContext ic, String name, Attributes attributes) {
  String valueStr = attributes.getValue(VALUE_ATR);

  if (OptionHelper.isEmpty(valueStr)) {
    ic.addError("The literal action requires a value attribute");
    return;
  }

  try {
    Integer i = Integer.valueOf(valueStr);
    ic.pushObject(i);
  } catch (NumberFormatException nfe) {
    ic.addError("The value [" + valueStr
        + "] could not be converted to an Integer", nfe);
    throw nfe;
  }
}

@Override
public void begin(InterpretationContext ec, String name, Attributes attributes) {

  // See LBCLASSIC-225 (the system property is looked up first. Thus, it overrides
  // the equivalent property in the config file. This reversal of scope priority is justified
  // by the use case: the admin trying to chase rogue config file
  String debugAttrib = System.getProperty(DEBUG_SYSTEM_PROPERTY_KEY);
  if (debugAttrib == null) {
    debugAttrib =  attributes.getValue(INTERNAL_DEBUG_ATTR);
  }

  if (OptionHelper.isEmpty(debugAttrib) || debugAttrib.equals("false") || debugAttrib.equals("null")) {
    addInfo(INTERNAL_DEBUG_ATTR + " attribute not set");
  } else {
    OnConsoleStatusListener.addNewInstanceToContext(context);
  }

  new ContextUtil(context).addHostNameAsProperty();

  // the context is appender attachable, so it is pushed on top of the stack
  ec.pushObject(getContext());
}

private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
        String logFile) {
    RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    appender.setEncoder(encoder);
    config.start(encoder);

    appender.setFile(logFile);

    FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
    rollingPolicy.setFileNamePattern(logFile + ".%i");
    appender.setRollingPolicy(rollingPolicy);
    rollingPolicy.setParent(appender);
    config.start(rollingPolicy);

    SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
    triggeringPolicy.setMaxFileSize("10MB");
    appender.setTriggeringPolicy(triggeringPolicy);
    config.start(triggeringPolicy);

    config.appender("FILE", appender);
    return appender;
}

@Override
public void start() throws LifecycleException {
    super.start();
    ctx.start();
    if (filename == null) {
        filename = OptionHelper.getSystemProperty("logbackAccess.configurationFile");
        if (filename == null) {
            filename = DEFAULT_CONFIG_FILE;
        }
        ctx.getStatusManager().add(new InfoStatus("filename property not set. Assuming [" + filename + "]", this));
    }
    // TODO: Support classpath config
    File configFile = new File(filename);
    if (configFile.exists()) {
        try {
            JoranConfigurator jc = new JoranConfigurator();
            jc.setContext(ctx);
            jc.doConfigure(filename);
        } catch (JoranException e) {
            // TODO can we do better than printing a stack trace on syserr?
            e.printStackTrace();
        }
    } else {
        ctx.getStatusManager().add(new WarnStatus("[" + filename + "] does not exist", this));
    }

    if (!quiet) {
        StatusPrinter.print(ctx.getStatusManager());
    }

}

public void init(KonkerLoggerContext defaultLoggerContext, Object key) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
    if(this.key == null) {
        this.key = key;
    } else if(this.key != key) {
        throw new IllegalAccessException("Only certain classes can access this method.");
    }

    String contextSelectorStr = OptionHelper.getSystemProperty("logback.ContextSelector");
    if(contextSelectorStr == null) {
        this.contextSelector = new KonkerDefaultContextSelector(defaultLoggerContext);
    } else {
        this.contextSelector = dynamicalContextSelector(defaultLoggerContext, contextSelectorStr);
    }

}

static void installIfAsked(KonkerLoggerContext loggerContext) {
    String slClass = OptionHelper.getSystemProperty("logback.statusListenerClass");
    if(!OptionHelper.isEmpty(slClass)) {
        addStatusListener(loggerContext, slClass);
    }

}

private static StatusListener createListenerPerClassName(KonkerLoggerContext loggerContext,
                                                         String listenerClass) {
    try {
        return (StatusListener)OptionHelper.instantiateByClassName(listenerClass, StatusListener.class, loggerContext);
    } catch (Exception var3) {
        var3.printStackTrace();
        return null;
    }
}

private URL findConfigFileURLFromSystemProperties(ClassLoader classLoader, boolean updateStatus) {
    String logbackConfigFile = OptionHelper.getSystemProperty("logback.configurationFile");
    if (logbackConfigFile != null) {
        URL result = null;

        URL f;
        try {
            result = new URL(logbackConfigFile);
            URL e = result;
            return e;
        } catch (MalformedURLException var13) {
            result = Loader.getResource(logbackConfigFile, classLoader);
            if (result == null) {
                File f1 = new File(logbackConfigFile);
                if (!f1.exists() || !f1.isFile()) {
                    return null;
                }

                try {
                    result = f1.toURI().toURL();
                    URL e1 = result;
                    return e1;
                } catch (MalformedURLException var12) {
                    return null;
                }
            }

            f = result;
        } finally {
            if (updateStatus) {
                this.statusOnResourceSearch(logbackConfigFile, classLoader, result);
            }

        }

        return f;
    } else {
        return null;
    }
}

@Override
public void begin(InterpretationContext ic, String elementName, Attributes attributes)
        throws ActionException {
    String name = attributes.getValue(NAME_ATTRIBUTE);
    String source = attributes.getValue(SOURCE_ATTRIBUTE);
    Scope scope = ActionUtil.stringToScope(attributes.getValue(SCOPE_ATTRIBUTE));
    String defaultValue = attributes.getValue(DEFAULT_VALUE_ATTRIBUTE);
    if (OptionHelper.isEmpty(name) || OptionHelper.isEmpty(source)) {
        addError(
                "The \"name\" and \"source\" attributes of <springProperty> must be set");
    }
    ActionUtil.setProperty(ic, name, getValue(source, defaultValue), scope);
}

private Appender<ILoggingEvent> consoleAppender(LogbackConfigurator config) {
    ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("console", CONSOLE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    encoder.setCharset(UTF8);
    config.start(encoder);
    appender.setEncoder(encoder);
    config.appender("CONSOLE", appender);
    return appender;
}

private boolean acceptsProfiles(InterpretationContext ic, Attributes attributes) {
    String[] profileNames = StringUtils.trimArrayElements(StringUtils
            .commaDelimitedListToStringArray(attributes.getValue(NAME_ATTRIBUTE)));
    if (profileNames.length != 0) {
        for (String profileName : profileNames) {
            OptionHelper.substVars(profileName, ic, this.context);
        }
        return this.environment != null
                && this.environment.acceptsProfiles(profileNames);
    }
    return false;
}

public static void setApplicationName(String name) throws AuditException {
    if (clientApplication != null && clientApplication.getName().equals(name)) {
        // don't configure again
        return;
    }
    if (clientApplication != null && !clientApplication.getName().equals(name)) {
        throw new IllegalStateException("Application name "
                + clientApplication.getName() + " once set cannot be renamed.");
    }

    if (OptionHelper.isEmpty(name)) {
        throw new IllegalArgumentException(
                "Application name cannot be null or empty");
    } else {

        // logger.info("Naming client application as [" + name + "]");
    }

    try {
        InetAddress address = InetAddress.getLocalHost();
        String fqdn = address.getCanonicalHostName();
        // logger("Client application host is ["+fqdn+"].");
        Application aplication = new Application(name, fqdn);
        // all is nice and dandy
        clientApplication = aplication;
    } catch (UnknownHostException e) {
        throw new IllegalStateException(
                "Failed to determine the hostname for this host", e);
    }

    // defaultAuditor.close();
    defaultAuditor = new Auditor();
    defaultAuditor.setClientApplication(clientApplication);
    defaultAuditor.setName(DEFAULT_AUDITOR_NAME);
    autoConfig(defaultAuditor);
    checkSanity(defaultAuditor);
    AuditorFactory.defaultAuditor = defaultAuditor;
}

@Override
public void begin(InterpretationContext ic, String elementName, Attributes attributes)
        throws ActionException {
    String name = attributes.getValue(NAME_ATTRIBUTE);
    String source = attributes.getValue(SOURCE_ATTRIBUTE);
    Scope scope = ActionUtil.stringToScope(attributes.getValue(SCOPE_ATTRIBUTE));
    String defaultValue = attributes.getValue(DEFAULT_VALUE_ATTRIBUTE);
    if (OptionHelper.isEmpty(name) || OptionHelper.isEmpty(source)) {
        addError(
                "The \"name\" and \"source\" attributes of <springProperty> must be set");
    }
    ActionUtil.setProperty(ic, name, getValue(source, defaultValue), scope);
}

private Appender<ILoggingEvent> consoleAppender(LogbackConfigurator config) {
    ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
    PatternLayoutEncoder encoder = new PatternLayoutEncoder();
    String logPattern = this.patterns.getProperty("console", CONSOLE_LOG_PATTERN);
    encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
    encoder.setCharset(UTF8);
    config.start(encoder);
    appender.setEncoder(encoder);
    config.appender("CONSOLE", appender);
    return appender;
}

private boolean acceptsProfiles(InterpretationContext ic, Attributes attributes) {
    String[] profileNames = StringUtils.trimArrayElements(StringUtils
            .commaDelimitedListToStringArray(attributes.getValue(NAME_ATTRIBUTE)));
    if (profileNames.length != 0) {
        for (String profileName : profileNames) {
            OptionHelper.substVars(profileName, ic, this.context);
        }
        return this.environment != null
                && this.environment.acceptsProfiles(profileNames);
    }
    return false;
}

/**
 * Returns the string "true" if the {@link #setResource(String) resource} specified by the
 * user is available on the class path, "false" otherwise.
 *
 * @return "true"|"false" depending on the availability of resource on the classpath
 */
public String getPropertyValue() {
  if (OptionHelper.isEmpty(resourceStr)) {
    addError("The \"resource\" property must be set.");
    return null;
  }

  URL resourceURL = Loader.getResourceBySelfClassLoader(resourceStr);
  return booleanAsStr(resourceURL != null);
}

/**
 * Returns "true" if the file specified by {@link #setPath(String) path} property exists.
 * Returns "false" otherwise.
 *
 * @return "true"|"false" depending on the existence of file
 */
public String getPropertyValue() {
  if (OptionHelper.isEmpty(path)) {
    addError("The \"path\" property must be set.");
    return null;
  }

  File file = new File(path);
  return booleanAsStr(file.exists());
}

private OutputStream getTargetStreamForWindows(OutputStream targetStream) {
  try {
    addInfo("Enabling JANSI WindowsAnsiOutputStream for the console.");
    Object windowsAnsiOutputStream = OptionHelper.instantiateByClassNameAndParameter(WindowsAnsiOutputStream_CLASS_NAME, Object.class, context,
            OutputStream.class, targetStream);
    return (OutputStream) windowsAnsiOutputStream;
  } catch (Exception e) {
    addWarn("Failed to create WindowsAnsiOutputStream. Falling back on the default stream.", e);
  }
  return targetStream;
}

public String property(String k) {
  String val = OptionHelper.propertyLookup(k, local, context);
  if(val != null)
    return val;
  else
    return "";
}

@Override
public void begin(InterpretationContext ic, String name, Attributes attributes)
    throws ActionException {

  IfState state = new IfState();
  boolean emptyStack = stack.isEmpty();
  stack.push(state);

  if(!emptyStack) {
    return;
  }

  ic.pushObject(this);
  if(!EnvUtil.isJaninoAvailable()) {
     addError(MISSING_JANINO_MSG);
     addError(MISSING_JANINO_SEE);
     return;
   }

  state.active = true;
  Condition condition = null;
  String conditionAttribute = attributes.getValue(CONDITION_ATTR);


  if (!OptionHelper.isEmpty(conditionAttribute)) {
    conditionAttribute = OptionHelper.substVars(conditionAttribute, ic, context);
    PropertyEvalScriptBuilder pesb = new PropertyEvalScriptBuilder(ic);
    pesb.setContext(context);
    try {
      condition = pesb.build(conditionAttribute);
    } catch (Exception e) {
      addError("Failed to parse condition ["+conditionAttribute+"]", e);
    }

    if(condition!=null) {
      state.boolResult = condition.evaluate();
    }

  }
}

@Override
public void begin(InterpretationContext ec, String name, Attributes attributes)
        throws ActionException {

  SaxEventRecorder recorder = new SaxEventRecorder(context);

  this.attributeInUse = null;
  this.optional = OptionHelper.toBoolean(attributes.getValue(OPTIONAL_ATTR), false);

  if (!checkAttributes(attributes)) {
    return;
  }

  InputStream in = getInputStream(ec, attributes);

  try {
    if (in != null) {
      parseAndRecord(in, recorder);
      // remove the <included> tag from the beginning and </included> from the end
      trimHeadAndTail(recorder);

      // offset = 2, because we need to get past this element as well as the end element
      ec.getJoranInterpreter().getEventPlayer().addEventsDynamically(recorder.saxEventList, 2);
    }
  } catch (JoranException e) {
    addError("Error while parsing  " + attributeInUse, e);
  } finally {
    close(in);
  }

}

private boolean checkAttributes(Attributes attributes) {
  String fileAttribute = attributes.getValue(FILE_ATTR);
  String urlAttribute = attributes.getValue(URL_ATTR);
  String resourceAttribute = attributes.getValue(RESOURCE_ATTR);

  int count = 0;

  if (!OptionHelper.isEmpty(fileAttribute)) {
    count++;
  }
  if (!OptionHelper.isEmpty(urlAttribute)) {
    count++;
  }
  if (!OptionHelper.isEmpty(resourceAttribute)) {
    count++;
  }

  if (count == 0) {
    addError("One of \"path\", \"resource\" or \"url\" attributes must be set.");
    return false;
  } else if (count > 1) {
    addError("Only one of \"file\", \"url\" or \"resource\" attributes should be set.");
    return false;
  } else if (count == 1) {
    return true;
  }
  throw new IllegalStateException("Count value [" + count
          + "] is not expected");
}

public void begin(InterpretationContext ec, String name, Attributes attributes) throws ActionException {
  inError = false;
  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Missing class name for statusListener. Near ["
            + name + "] line " + getLineNumber(ec));
    inError = true;
    return;
  }

  try {
    statusListener = (StatusListener) OptionHelper.instantiateByClassName(
            className, StatusListener.class, context);
    ec.getContext().getStatusManager().add(statusListener);
    if (statusListener instanceof ContextAware) {
      ((ContextAware) statusListener).setContext(context);
    }
    addInfo("Added status listener of type [" + className + "]");
    ec.pushObject(statusListener);
  } catch (Exception e) {
    inError = true;
    addError(
            "Could not create an StatusListener of type [" + className + "].", e);
    throw new ActionException(e);
  }

}

/**
 * Instantiates a shutdown hook of the given class and sets its name.
 * 
 * The hook thus generated is placed in the {@link InterpretationContext}'s
 * shutdown hook bag.
 */
@Override
public void begin(InterpretationContext ic, String name, Attributes attributes) throws ActionException {    
  hook = null;
  inError = false;

  String className = attributes.getValue(CLASS_ATTRIBUTE);
  if (OptionHelper.isEmpty(className)) {
    addError("Missing class name for shutdown hook. Near [" + name
        + "] line " + getLineNumber(ic));
    inError = true;
    return;
  }

  try {
    addInfo("About to instantiate shutdown hook of type [" + className + "]");

    hook = (ShutdownHookBase) OptionHelper.instantiateByClassName(className,
        ShutdownHookBase.class, context);
    hook.setContext(context);

    ic.pushObject(hook);
  }catch (Exception e) {
    inError = true;
    addError("Could not create a shutdown hook of type [" + className + "].", e);
    throw new ActionException(e);
  }
}

boolean checkFileAttributeSanity(Attributes attributes) {
  String file = attributes.getValue(FILE_ATTRIBUTE);
  String name = attributes.getValue(NAME_ATTRIBUTE);
  String value = attributes.getValue(VALUE_ATTRIBUTE);
  String resource = attributes.getValue(RESOURCE_ATTRIBUTE);

  return !(OptionHelper.isEmpty(file))
      && (OptionHelper.isEmpty(name) && OptionHelper.isEmpty(value) && OptionHelper
          .isEmpty(resource));
}

boolean checkResourceAttributeSanity(Attributes attributes) {
  String file = attributes.getValue(FILE_ATTRIBUTE);
  String name = attributes.getValue(NAME_ATTRIBUTE);
  String value = attributes.getValue(VALUE_ATTRIBUTE);
  String resource = attributes.getValue(RESOURCE_ATTRIBUTE);

  return !(OptionHelper.isEmpty(resource))
      && (OptionHelper.isEmpty(name) && OptionHelper.isEmpty(value) && OptionHelper
          .isEmpty(file));
}

boolean checkValueNameAttributesSanity(Attributes attributes) {
  String file = attributes.getValue(FILE_ATTRIBUTE);
  String name = attributes.getValue(NAME_ATTRIBUTE);
  String value = attributes.getValue(VALUE_ATTRIBUTE);
  String resource = attributes.getValue(RESOURCE_ATTRIBUTE);

  return (!(OptionHelper.isEmpty(name) || OptionHelper.isEmpty(value)) && (OptionHelper
      .isEmpty(file) && OptionHelper.isEmpty(resource)));
}

@Override
public void begin(InterpretationContext ec, String name, Attributes attributes)
    throws ActionException {
  String keyStr = attributes.getValue(KEY_ATTRIBUTE);
  if (OptionHelper.isEmpty(keyStr)) {
    addError("Attribute named [" + KEY_ATTRIBUTE + "] cannot be empty");
    inError = true;
  }
  String datePatternStr = attributes.getValue(DATE_PATTERN_ATTRIBUTE);
  if (OptionHelper.isEmpty(datePatternStr)) {
    addError("Attribute named [" + DATE_PATTERN_ATTRIBUTE
        + "] cannot be empty");
    inError = true;
  }

  String timeReferenceStr = attributes.getValue(TIME_REFERENCE_ATTRIBUTE);
  long timeReference;
  if (CONTEXT_BIRTH.equalsIgnoreCase(timeReferenceStr)) {
    addInfo("Using context birth as time reference.");
    timeReference = context.getBirthTime();
  } else {
    timeReference =  System.currentTimeMillis();
    addInfo("Using current interpretation time, i.e. now, as time reference.");
  }


  if (inError)
    return;

  String scopeStr = attributes.getValue(SCOPE_ATTRIBUTE);
  Scope scope = ActionUtil.stringToScope(scopeStr);

  CachingDateFormatter sdf = new CachingDateFormatter(datePatternStr);
  String val = sdf.format(timeReference);

  addInfo("Adding property to the context with key=\"" + keyStr
      + "\" and value=\"" + val + "\" to the " + scope + " scope");
  ActionUtil.setProperty(ec, keyStr, val, scope);
}

static public void setProperty(InterpretationContext ic, String key, String value, Scope scope) {
  switch (scope) {
  case LOCAL:
    ic.addSubstitutionProperty(key, value);
    break;
  case CONTEXT:
    ic.getContext().putProperty(key, value);
    break;
  case SYSTEM:
    OptionHelper.setSystemProperty(ic, key, value);
  }
}

/**
 * Add all the properties found in the argument named 'props' to an
 * InterpretationContext.
 */
static public void setProperties(InterpretationContext ic, Properties props,
    Scope scope) {
  switch (scope) {
  case LOCAL:
    ic.addSubstitutionProperties(props);
    break;
  case CONTEXT:
    ContextUtil cu = new ContextUtil(ic.getContext());
    cu.addProperties(props);
    break;
  case SYSTEM:
    OptionHelper.setSystemProperties(ic, props);
  }
}