public void Test_Evaluate()
{
IRuntimeServices rs = RuntimeSingleton.RuntimeServices;
Introspector i = new Introspector(rs);
MethodInfo mi = i.GetMethod(typeof(VelocityTest), "Test_Evaluate", null);
Assert.IsNotNull(mi, "Expected to find VelocityTest.Test_Evaluate");
Assert.IsTrue(mi.ToString().Equals("Void Test_Evaluate()"), "method not found");
mi = i.GetMethod(typeof(ExtendedProperties), "GetString", new Object[] {"parm1", "parm2"});
Assert.IsNotNull(mi, "Expected to find ExtendedProperties.GetString(String, String)");
Assert.IsTrue(mi.ToString().Equals("System.String GetString(System.String, System.String)"), "method not found");
}
private T GetSmallestContainingIntervalWorker(int start, int length, Func <T, int, int, bool> predicate)
{
var result = default(T);
if (root == null || MaxEndValue(root) < start)
{
return(result);
}
int end = start + length;
// * our interval tree is a binary tree that is ordered by a start position.
//
// this method works by
// 1. find a sub tree that has biggest "start" position that is smaller than given "start" by going down right side of a tree
// 2. once it encounters a right sub tree that it can't go down anymore, move down to left sub tree once and try #1 again
// 3. once it gets to the position where it can't find any smaller span (both left and
// right sub tree doesn't contain given span) start to check whether current node
// contains the given "span"
// 4. move up the spin until it finds one that contains the "span" which should be smallest span that contains the given "span"
// 5. if it is going up from right side, it make sure to check left side of tree first.
using (var pooledObject = SharedPools.Default <Stack <Node> >().GetPooledObject())
{
var spineNodes = pooledObject.Object;
spineNodes.Push(root);
while (spineNodes.Count > 0)
{
var currentNode = spineNodes.Peek();
// only goes to right if right tree contains given span
if (Introspector.GetStart(currentNode.Value) <= start)
{
var right = currentNode.Right;
if (right != null && end < MaxEndValue(right))
{
spineNodes.Push(right);
continue;
}
}
// right side, sub tree doesn't contain the given span, put current node on
// stack, and move down to left sub tree
var left = currentNode.Left;
if (left != null && end <= MaxEndValue(left))
{
spineNodes.Push(left);
continue;
}
// we reached the point, where we can't go down anymore.
// now, go back up to find best answer
while (spineNodes.Count > 0)
{
currentNode = spineNodes.Pop();
// check whether current node meets condition
if (predicate(currentNode.Value, start, length))
{
// hold onto best answer
if (EqualityComparer <T> .Default.Equals(result, default) ||
(Introspector.GetStart(result) <= Introspector.GetStart(currentNode.Value) &&
Introspector.GetLength(currentNode.Value) < Introspector.GetLength(result)))
{
result = currentNode.Value;
}
}
// there is no parent, result we currently have is the best answer
if (spineNodes.Count == 0)
{
return(result);
}
var parentNode = spineNodes.Peek();
// if we are under left side of parent node
if (parentNode.Left == currentNode)
{
// go one level up again
continue;
}
// okay, we are under right side of parent node
if (parentNode.Right == currentNode)
{
// try left side of parent node if it can have better answer
if (parentNode.Left != null && end <= MaxEndValue(parentNode.Left))
{
// right side tree doesn't have any answer or if the right side has
// an answer but left side can have better answer then try left side
if (EqualityComparer <T> .Default.Equals(result, default) ||
Introspector.GetStart(parentNode.Value) == Introspector.GetStart(currentNode.Value))
{
// put left as new root, and break out inner loop
spineNodes.Push(parentNode.Left);
break;
}
}
// no left side, go one more level up
continue;
}
}
}
return(result);
}
}
public BooleanPropertyExecutor(RuntimeLogger r, Introspector i, Type clazz, String propertyName) : base(r, i, clazz, propertyName)
{
}
/// <param name="Log">
/// </param>
/// <param name="introspector">
/// </param>
/// <param name="clazz">
/// </param>
/// <param name="property">
/// </param>
/// <since> 1.5
/// </since>
public BooleanPropertyExecutor(Log log, Introspector introspector, System.Type clazz, string property)
: base(log, introspector, clazz, property)
{
}
private void OutputStatement(Statement exp, Object outer, bool isArgument)
{
Object target = exp.Target;
String methodName = exp.MethodName;
if (target == null || methodName == null)
{
throw new NullPointerException((target == null ? "target" : "methodName") + " should not be null");
}
Object[] args = exp.Arguments;
bool expression = exp.GetType() == typeof(Expression);
Object value = (expression) ? GetValue((Expression)exp) : null;
String tag = (expression && isArgument) ? "object" : "void";
String attributes = "";
ValueData d = GetValueData(value);
// Special cases for targets.
if (target == outer)
{
}
else if (target == typeof(Array) && methodName.Equals("newInstance"))
{
tag = "array";
attributes = attributes + " class=" + Quote(((Class)args[0]).Name);
attributes = attributes + " length=" + Quote(args[1].ToString());
args = new Object[] {};
}
else if (target.GetType() == typeof(Class))
{
attributes = attributes + " class=" + Quote(((Class)target).Name);
}
else
{
d.Refs = 2;
if (d.Name == null)
{
GetValueData(target).Refs++;
List <Statement> statements = StatementList(target);
if (!statements.Contains(exp))
{
statements.Add(exp);
}
OutputValue(target, outer, false);
}
if (expression)
{
OutputValue(value, outer, isArgument);
}
return;
}
if (expression && (d.Refs > 1))
{
String instanceName = NameGenerator.InstanceName(value);
d.Name = instanceName;
attributes = attributes + " id=" + Quote(instanceName);
}
// Special cases for methods.
if ((!expression && methodName.Equals("set") && args.Length == 2 && args[0] is Integer) || (expression && methodName.Equals("get") && args.Length == 1 && args[0] is Integer))
{
attributes = attributes + " index=" + Quote(args[0].ToString());
args = (args.Length == 1) ? new Object[] {} : new Object[] { args[1] };
}
else if ((!expression && methodName.StartsWith("set") && args.Length == 1) || (expression && methodName.StartsWith("get") && args.Length == 0))
{
if (3 < methodName.Length())
{
attributes = attributes + " property=" + Quote(Introspector.Decapitalize(methodName.Substring(3)));
}
}
else if (!methodName.Equals("new") && !methodName.Equals("newInstance"))
{
attributes = attributes + " method=" + Quote(methodName);
}
OutputXML(tag, attributes, value, args);
}
