/// <summary>
/// Initialize the template loader with a
/// a resources class.
/// </summary>
public override void Init(ExtendedProperties configuration)
{
assemblyNames = configuration.GetVector("assembly");
prefixes = configuration.GetVector("prefix");
if (assemblyNames.Count != prefixes.Count)
{
throw new ResourceNotFoundException("Need to specify prefixes!");
}
}
/// <summary>
/// This initialization is used by all resource
/// loaders and must be called to set up common
/// properties shared by all resource loaders
/// </summary>
public void CommonInit(IRuntimeServices rs, ExtendedProperties configuration)
{
runtimeServices = rs;
// these two properties are not required for all loaders.
// For example, for ClassPathLoader, what would cache mean?
// so adding default values which I think are the safest
// don't cache, and modCheckInterval irrelevant...
isCachingOn = configuration.GetBoolean("cache", false);
modificationCheckInterval = configuration.GetLong("modificationCheckInterval", 0);
// this is a must!
className = configuration.GetString("class");
}
/// <summary>
/// Initialize the template loader with a resources class.
/// </summary>
public override void Init(ExtendedProperties configuration)
{
object value = configuration["assembly"];
if (value is string)
{
assemblyNames = new List<string> { (string)configuration["assembly"] };
}
else if (value is List<string>)
{
assemblyNames = configuration.GetStringList("assembly");
}
else
{
throw new VelocityException("Expected property 'assembly' to be of type string or List<string>.");
}
}
/// <summary> /// Initialize the template loader with a /// a resources class. /// </summary> public abstract void Init(ExtendedProperties configuration);
/// <summary> Create an ExtendedProperties object that is a subset
/// of this one. Take into account duplicate keys
/// by using the setProperty() in ExtendedProperties.
/// *
/// </summary>
/// <param name="prefix">prefix
///
/// </param>
public ExtendedProperties Subset(String prefix)
{
ExtendedProperties c = new ExtendedProperties();
bool validSubset = false;
foreach(Object key in Keys)
{
if (key is String && ((String) key).StartsWith(prefix))
{
if (!validSubset)
validSubset = true;
String newKey;
/*
* Check to make sure that c.subset(prefix) doesn't
* blow up when there is only a single property
* with the key prefix. This is not a useful
* subset but it is a valid subset.
*/
if (((String) key).Length == prefix.Length)
{
newKey = prefix;
}
else
{
newKey = ((String) key).Substring(prefix.Length + 1);
}
/*
* use addPropertyDirect() - this will plug the data as
* is into the Map, but will also do the right thing
* re key accounting
*/
c.AddPropertyDirect(newKey, this[key]);
}
}
if (validSubset)
{
return c;
}
else
{
return null;
}
}
/// <summary> Combines an existing Hashtable with this Hashtable.
/// *
/// Warning: It will overwrite previous entries without warning.
/// *
/// </summary>
/// <param name="c">ExtendedProperties
///
/// </param>
public void Combine(ExtendedProperties c)
{
foreach(String key in c.Keys)
{
Object o = c[key];
// if the value is a String, escape it so that if there are delimiters that the value is not converted to a list
if (o is String)
{
o = ((String) o).Replace(",", @"\,");
}
SetProperty(key, o);
}
}
/// <summary>
/// Creates and loads the extended properties from the specified
/// file.
/// </summary>
/// <param name="file">A String.</param>
/// <param name="defaultFile">File to load defaults from.</param>
/// <exception cref="IOException" />
public ExtendedProperties(String file, String defaultFile)
{
this.file = file;
basePath = new FileInfo(file).FullName;
basePath = basePath.Substring(0, (basePath.LastIndexOf(fileSeparator) + 1) - (0));
Load(new FileStream(file, FileMode.Open, FileAccess.Read));
if (defaultFile != null)
{
defaults = new ExtendedProperties(defaultFile);
}
}
/// <summary>
/// Add a property to the configuration. If it already
/// exists then the value stated here will be added
/// to the configuration entry.
/// <remarks>
/// For example, if
/// <c>resource.loader = file</c>
/// is already present in the configuration and you
/// <c>addProperty("resource.loader", "classpath")</c>
///
/// Then you will end up with a <see cref="IList"/> like the
/// following:
///
/// <c>["file", "classpath"]</c>
/// </remarks>
/// </summary>
/// <param name="key">key</param>
/// <param name="value">value</param>
public void AddProperty(String key, Object value)
{
if (overridingProperties == null)
{
overridingProperties = new ExtendedProperties();
}
overridingProperties.AddProperty(key, value);
}
/// <summary>
/// CTOR that invokes an init(String), initializing
/// the engine using the Properties specified
/// </summary>
/// <param name="p">name of properties to init with</param>
public VelocityEngine(ExtendedProperties p)
{
runtimeInstance.Init(p);
}
/// <summary>
/// initialize the Velocity runtime engine, using default properties
/// plus the properties in the passed in java.util.Properties object
/// </summary>
/// <param name="p"> Properties object containing initialization properties</param>
public void Init(ExtendedProperties p)
{
runtimeInstance.Init(p);
}
/// <summary>
/// initialize the Velocity runtime engine, using default properties
/// plus the properties in the passed in java.util.Properties object
/// </summary>
/// <param name="p">
/// Proprties object containing initialization properties
/// </param>
public static void Init(ExtendedProperties p)
{
RuntimeSingleton.Init(p);
}
/// <summary>
/// Set an entire configuration at once. This is
/// useful in cases where the parent application uses
/// the ExtendedProperties class and the velocity configuration
/// is a subset of the parent application's configuration.
/// </summary>
public static void SetExtendedProperties(ExtendedProperties value)
{
RuntimeSingleton.Configuration = value;
}
/// <summary> This methods initializes all the directives
/// that are used by the Velocity Runtime. The
/// directives to be initialized are listed in
/// the RUNTIME_DEFAULT_DIRECTIVES properties
/// file.
///
/// @throws Exception
/// </summary>
private void initializeDirectives()
{
initializeDirectiveManager();
/*
* Initialize the runtime directive table.
* This will be used for creating parsers.
*/
// runtimeDirectives = new Hashtable();
ExtendedProperties directiveProperties = new ExtendedProperties();
/*
* Grab the properties file with the list of directives
* that we should initialize.
*/
try
{
directiveProperties.Load(
Assembly.GetExecutingAssembly().GetManifestResourceStream(RuntimeConstants.DEFAULT_RUNTIME_DIRECTIVES));
}
catch(System.Exception ex)
{
throw new System.Exception(
string.Format(
"Error loading directive.properties! Something is very wrong if these properties aren't being located. Either your Velocity distribution is incomplete or your Velocity jar file is corrupted!\n{0}",
ex.Message));
}
/*
* Grab all the values of the properties. These
* are all class names for example:
*
* NVelocity.Runtime.Directive.Foreach
*/
IEnumerator directiveClasses = directiveProperties.Values.GetEnumerator();
while(directiveClasses.MoveNext())
{
String directiveClass = (String) directiveClasses.Current;
// loadDirective(directiveClass);
directiveManager.Register(directiveClass);
}
/*
* now the user's directives
*/
String[] userdirective = configuration.GetStringArray("userdirective");
for(int i = 0; i < userdirective.Length; i++)
{
// loadDirective(userdirective[i]);
directiveManager.Register(userdirective[i]);
}
}
/// <summary>
/// Initialize the Velocity Runtime with the name of
/// ExtendedProperties object.
/// </summary>
/// <param name="configurationFile">Properties</param>
public void Init(String configurationFile)
{
overridingProperties = new ExtendedProperties(configurationFile);
Init();
}
/// <summary>
/// Initialize the Velocity Runtime with a Properties
/// object.
/// </summary>
/// <param name="p">Properties</param>
public void Init(ExtendedProperties p)
{
overridingProperties = ExtendedProperties.ConvertProperties(p);
Init();
}
/// <summary>
/// Initialize the Velocity Runtime with an ExtendedProperties object.
/// </summary>
/// <param name="p">Properties</param>
public static void Init(ExtendedProperties p)
{
ri.Init(p);
}
public override void Init(ExtendedProperties configuration)
{
runtimeServices.Info("FileResourceLoader : initialization starting.");
paths = configuration.GetVector("path");
}
/// <summary>
/// Set an entire configuration at once. This is
/// useful in cases where the parent application uses
/// the ExtendedProperties class and the velocity configuration
/// is a subset of the parent application's configuration.
/// </summary>
public void SetExtendedProperties(ExtendedProperties value)
{
runtimeInstance.Configuration = value;
}
/// <summary>
/// Convert a standard properties class into a configuration class.
/// </summary>
/// <param name="p">properties object to convert into a ExtendedProperties object.</param>
/// <returns>ExtendedProperties configuration created from the properties object.</returns>
public static ExtendedProperties ConvertProperties(ExtendedProperties p)
{
ExtendedProperties c = new ExtendedProperties();
foreach(String key in p.Keys)
{
Object value = p.GetProperty(key);
// if the value is a String, escape it so that if there are delimiters that the value is not converted to a list
if (value is String)
value = value.ToString().Replace(",", @"\,");
c.SetProperty(key, value);
}
return c;
}
public RuntimeInstance()
{
// logSystem = new PrimordialLogSystem();
configuration = new ExtendedProperties();
// create a VM factory, resource manager
// and introspector
vmFactory = new VelocimacroFactory(this);
// make a new introspector and initialize it
introspector = new Introspector(this);
// and a store for the application attributes
applicationAttributes = new Hashtable();
}
