/// <summary>
/// reads an object
/// </summary>
/// <returns></returns>
public T Read()
{
IJavaData data = stream.ReadObject();
if (reducer != null && data is JavaObject)
{
data = reducer.Reduce((JavaObject)data);
}
return(converter.Convert(data));
}
void ReduceArray(JavaArray array, HashSet <JavaObject> visited)
{
for (int i = array.Items.Count - 1; i >= 0; --i)
{
IJavaData data = array.Items[i];
if (data is JavaArray)
{
ReduceArray((JavaArray)data, visited);
}
else if (data is JavaObject)
{
array.Items[i] = ReduceObject((JavaObject)data, visited);
}
}
}
/// <summary>
/// reads an object
/// </summary>
/// <returns></returns>
public T Read()
{
IJavaData data = stream.ReadObject();
if (reducer != null && data is JavaObject)
{
data = reducer.Reduce((JavaObject)data);
}
JavaValue value = data as JavaValue;
if (value == null)
{
throw new InvalidOperationException("Stream contains no object of the specified type");
}
return(value.Get <T>());
}
IJavaData ReduceObject(JavaObject @object, HashSet <JavaObject> visited)
{
if (visited.Contains(@object))
{
return(@object);
}
visited.Add(@object);
foreach (JavaField field in @object.Fields)
{
if (field.Value is JavaArray)
{
ReduceArray((JavaArray)field.Value, visited);
}
else if (field.Value is JavaObject)
{
field.Value = ReduceObject((JavaObject)field.Value, visited);
}
}
for (int i = @object.Custom.Count - 1; i >= 0; --i)
{
IJavaData data = @object.Custom[i];
if (data is JavaArray)
{
ReduceArray((JavaArray)data, visited);
}
else if (data is JavaObject)
{
@object.Custom[i] = ReduceObject((JavaObject)data, visited);
}
}
visited.Remove(@object);
IDataTransformer transformer = transformationtable.Get(@object.Type);
if (transformer == null)
{
return(@object);
}
return(transformer.Convert(@object));
}
/// <summary>
/// writes an xml document out of a java data structure
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public XmlDocument Convert(IJavaData data)
{
HashSet <JavaObject> visited = new HashSet <JavaObject>();
XmlDocument document = new XmlDocument();
if (data is JavaObject)
{
WriteObject(document.CreateAndAppendElement(GetTagName(((JavaObject)data).Type)), (JavaObject)data, visited);
}
else if (data is JavaValue)
{
document.CreateAndAppendElement("value").InnerText = GetValue((JavaValue)data);
}
else if (data is JavaArray)
{
WriteArray(document.CreateAndAppendElement("array"), (JavaArray)data, visited);
}
return(document);
}
void WriteData(XmlNode parent, IJavaData data, HashSet <JavaObject> visited)
{
if (data is JavaArray)
{
JavaArray array = (JavaArray)data;
WriteArray(parent, array, visited);
}
else if (data is JavaValue)
{
parent.InnerText = GetValue((JavaValue)data);
}
else if (data is JavaObject)
{
WriteObject(parent.CreateAndAppendAttribute("type", GetTagName(((JavaObject)data).Type)), (JavaObject)data, visited);
}
else
{
throw new InvalidOperationException("Invalid data type in array");
}
}
public IEnumerable <IJavaData> Select(IJavaData data)
{
if (data is JavaArray)
{
foreach (IJavaData child in ((JavaArray)data).Items)
{
foreach (IJavaData result in Select(child))
{
yield return(result);
}
}
}
else if (data is JavaObject)
{
JavaField field = ((JavaObject)data).Fields.FirstOrDefault(f => f.Name == Name);
if (field != null)
{
yield return(field.Value);
}
}
}
void WriteArray(XmlNode parent, JavaArray array, HashSet <JavaObject> visited)
{
if (array.Items.Count == 0)
{
return;
}
IJavaData data = array.Items.First();
if (data is JavaArray)
{
foreach (JavaArray childarray in array.Items.Cast <JavaArray>())
{
WriteArray(parent.CreateAndAppendElement("array"), childarray, visited);
}
}
else if (data is JavaValue)
{
#if FRAMEWORK35
parent.InnerText = string.Join(";", array.Items.Cast <JavaValue>().Select(GetValue).ToArray());
#else
parent.InnerText = string.Join(";", array.Items.Cast <JavaValue>().Select(GetValue));
#endif
}
else if (data is JavaObject)
{
foreach (JavaObject item in array.Items.Cast <JavaObject>())
{
WriteObject(parent.CreateAndAppendElement(GetTagName(item.Type)), item, visited);
}
}
else
{
throw new InvalidOperationException("Invalid data type in array");
}
}
/// <summary>
/// selects nodes using a path
/// </summary>
/// <typeparam name="T">type of nodes to select</typeparam>
/// <param name="data">data from which to select</param>
/// <param name="path">path to nodes</param>
/// <returns>nodes of the selected type which match the path</returns>
public static IEnumerable <T> SelectNodes <T>(this IJavaData data, string path)
where T : IJavaData
{
return(SelectNodes(data, path).Where(n => n is T).Cast <T>());
}
/// <summary>
/// select child data using a xpath like path specification
/// </summary>
/// <param name="data"></param>
/// <param name="path">path to data</param>
/// <returns>data if path leads to a valid node, null otherwise</returns>
public static IEnumerable <IJavaData> SelectNodes(this IJavaData data, string path)
{
IPathElement[] elements = parser.ParsePath(path).ToArray();
return(SelectNodes(data, elements, 0));
}
public JavaDataController(IJavaData iJavaData, ITestService testService)
{
_java = iJavaData;
_testService = testService;
}
void CreateReference(IJavaData data)
{
references.Add(data);
}
/// <summary>
/// creates a new java exception
/// </summary>
/// <param name="object"></param>
public JavaException(IJavaData @object)
{
Object = @object;
}
/// <summary>
/// creates a new java field
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public JavaField(string name, IJavaData value)
{
Name = name;
Value = value;
}
