/// <summary>
/// Loads all the elements found in the elements file.
/// </summary>
/// <param name="includeDisabled"></param>
/// <returns>An array of the the elements found.</returns>
public ElementInfo[] LoadInfoFromFile(bool includeDisabled)
{
// Logging disabled to boost performance
//using (LogGroup logGroup = LogGroup.StartDebug("Loading the elements from the XML file."))
//{
if (Elements == null)
{
List<ElementInfo> validElements = new List<ElementInfo>();
ElementInfo[] elements = new ElementInfo[]{};
using (StreamReader reader = new StreamReader(File.OpenRead(FileNamer.ElementsInfoFilePath)))
{
XmlSerializer serializer = new XmlSerializer(typeof(ElementInfo[]));
elements = (ElementInfo[])serializer.Deserialize(reader);
}
foreach (ElementInfo element in elements)
if (element.Enabled || includeDisabled)
validElements.Add(element);
Elements = validElements.ToArray();
}
//}
return Elements;
}
public override DecodedObject<object> decodeString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!PERCoderUtils.is7BitEncodedString(elementInfo))
return base.decodeString(decodedTag, objectClass, elementInfo, stream);
else
{
DecodedObject<object> result = new DecodedObject<object>();
int strLen = decodeLength(elementInfo, stream);
if (strLen <= 0)
{
result.Value = ("");
return result;
}
BitArrayInputStream bitStream = (BitArrayInputStream) stream;
byte[] buffer = new byte[strLen];
// 7-bit decoding of string
for (int i = 0; i < strLen; i++)
buffer[i] = (byte)bitStream.readBits(7);
result.Value = new string(
System.Text.ASCIIEncoding.ASCII.GetChars(buffer)
);
return result;
}
}
public override int encode(IASN1TypesEncoder encoder, object obj, Stream stream, ElementInfo elementInfo)
{
Object result = null;
ASN1ElementMetadata saveInfo = elementInfo.PreparedASN1ElementInfo;
elementInfo.PreparedInfo = (valueFieldMeta);
if (!CoderUtils.isNullField(valueField, elementInfo))
{
result = encoder.invokeGetterMethodForField(valueField, obj, elementInfo);
}
if (saveInfo != null)
{
if (!saveInfo.HasTag
&& elementInfo.hasPreparedASN1ElementInfo()
&& elementInfo.PreparedASN1ElementInfo.HasTag)
{
ASN1ElementMetadata elData = new ASN1ElementMetadata(
saveInfo.Name,
saveInfo.IsOptional,
elementInfo.PreparedASN1ElementInfo.HasTag,
elementInfo.PreparedASN1ElementInfo.IsImplicitTag,
elementInfo.PreparedASN1ElementInfo.TagClass,
elementInfo.PreparedASN1ElementInfo.Tag,
saveInfo.HasDefaultValue
);
elementInfo.PreparedASN1ElementInfo = elData;
}
else
elementInfo.PreparedASN1ElementInfo = (saveInfo);
}
return valueFieldMeta.TypeMetadata.encode(encoder, result, stream, elementInfo);
}
public override int encodeSequence(Object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
if(!CoderUtils.isSequenceSet(elementInfo))
return base.encodeSequence(obj, stream, elementInfo);
else {
int resultSize = 0;
PropertyInfo[] fields = null;
if (elementInfo.hasPreparedInfo())
{
fields = elementInfo.getProperties(obj.GetType());
}
else
{
SortedList<int, PropertyInfo> fieldOrder = CoderUtils.getSetOrder(obj.GetType());
//TO DO Performance optimization need (unnecessary copy)
fields = new PropertyInfo[fieldOrder.Count];
fieldOrder.Values.CopyTo(fields, 0);
}
for (int i = 0; i < fields.Length; i++)
{
PropertyInfo field = fields[fields.Length - 1 - i];
resultSize += encodeSequenceField(obj, fields.Length - 1 - i, field, stream, elementInfo);
}
resultSize += encodeHeader(
BERCoderUtils.getTagValueForElement(
elementInfo,
TagClasses.Universal,
ElementType.Constructed,
UniversalTags.Set)
, resultSize, stream);
return resultSize;
}
}
public override DecodedObject<object> decodeAny(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
int bufSize = elementInfo.MaxAvailableLen;
if (bufSize == 0)
return null;
System.IO.MemoryStream anyStream = new System.IO.MemoryStream(1024);
/*int tagValue = (int)decodedTag.Value;
for (int i = 0; i < decodedTag.Size; i++)
{
anyStream.WriteByte((byte)tagValue);
tagValue = tagValue >> 8;
}*/
if(bufSize<0)
bufSize = 1024;
int len = 0;
if (bufSize > 0)
{
byte[] buffer = new byte[bufSize];
int readed = stream.Read(buffer, 0, buffer.Length);
while (readed > 0)
{
anyStream.Write(buffer, 0, readed);
len += readed;
if (elementInfo.MaxAvailableLen > 0)
break;
readed = stream.Read(buffer, 0, buffer.Length);
}
}
CoderUtils.checkConstraints(len, elementInfo);
return new DecodedObject<object>(anyStream.ToArray(), len);
}
public static bool is7BitEncodedString(ElementInfo info)
{
bool is7Bit = false;
int stringType = CoderUtils.getStringTagForElement(info);
is7Bit = (
stringType == UniversalTags.PrintableString
|| stringType == UniversalTags.VisibleString
);
return is7Bit;
}
/// <summary>
/// Creates a new copy of this ElementInfo.
/// </summary>
/// <returns>A new ElementInfo that is a copy of this instance.</returns>
public ElementInfo Clone()
{
var cloneElementInfo = new ElementInfo();
cloneElementInfo.Texture = Texture.Clone();
cloneElementInfo.XOffset = XOffset;
cloneElementInfo.YOffset = YOffset;
return cloneElementInfo;
}
public override DecodedObject<object> decodeBitString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Bitstring, elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
int trailBitCnt = stream.ReadByte();
CoderUtils.checkConstraints(len.Value * 8 - trailBitCnt, elementInfo);
byte[] byteBuf = new byte[len.Value - 1];
stream.Read(byteBuf,0,byteBuf.Length);
return new DecodedObject<object>( new BitString(byteBuf,trailBitCnt), len.Value + len.Size);
}
public override DecodedObject<object> decodeBoolean(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Boolean, elementInfo))
return null;
DecodedObject<object> result = decodeIntegerValue(stream);
int val = (int) result.Value;
if (val != 0)
result.Value = true;
else
result.Value = false;
return result;
}
/**
* tries to group the chained elements into blocks
*
* the elements must be in a valid order allready
*
* this function also translates all constraints into the blocks of TranslateInfo
*
*/
public static TranslateInfo translateIntoBlocks(List<int> elements, List<CausalSets.Constraint> constraints)
{
int i;
int elementI;
int blockIdCounter;
bool blockIdCounterWasIncremented;
TranslateInfo resultTranslateInfo;
ElementInfo[] elementInfos;
debugInput(elements, constraints);
resultTranslateInfo = new TranslateInfo();
elementInfos = new ElementInfo[elements.Count];
for( i = 0; i < elements.Count; i++ )
{
elementInfos[i] = new ElementInfo();
}
// go througth all the constraints and search the index of the dependencies and the element then store it in the array
storeDependenciesIntoElementInfos(elements, elementInfos, constraints);
// search in the array for interlinked blocks, label the elements with a blockcounter
blockIdCounter = 0;
blockIdCounterWasIncremented = false;
for( elementI = 1; elementI < elements.Count; elementI++ )
{
if( elementInfos[elementI].dependencies.Count > 0 && elementInfos[elementI].dependencies.Contains(elementI-1) )
{
elementInfos[elementI].blockId = blockIdCounter;
}
else
{
blockIdCounter++;
elementInfos[elementI].blockId = blockIdCounter;
}
}
// store the elements into the blocks
// and transfer the orginal constraints to the blocks
storeElementsIntoBlocks(elements, elementInfos, resultTranslateInfo);
checkInvariantForBlocks(elements, resultTranslateInfo);
transferConstraintsToBlocks(resultTranslateInfo, constraints);
debugResultTranslateInfo(resultTranslateInfo);
return resultTranslateInfo;
}
static bool handleProperties (XmlNode node, ElementInfo ei) {
if (ei.properties == null)
ei.properties = new ArrayList ();
XmlElement elt = node as XmlElement;
if (elt == null)
return true;
foreach (XmlElement property in elt.ChildNodes) {
if (IsHidden (property))
continue;
PropertyInfo pi = new PropertyInfo ();
pi.name = property["name"].InnerText;
pi.managed_name = (property["managed_name"] != null) ? property["managed_name"].InnerText : null;
pi.type = property["type"].InnerText;
pi.readable = property["flags"].InnerText.IndexOf ('R') != -1;
pi.writeable = property["flags"].InnerText.IndexOf ('W') != -1;
if (property["enum-values"] != null) {
pi.enuminfo = new EnumInfo ();
pi.enuminfo.flag = false;
pi.enuminfo.values = new ArrayList ();
foreach (XmlNode val in property["enum-values"].ChildNodes) {
EnumValue env = new EnumValue ();
env.name = val.Attributes["nick"].InnerText;
env.value = Int32.Parse (val.Attributes["value"].InnerText);
pi.enuminfo.values.Add (env);
}
} else if (property["flags-values"] != null) {
pi.enuminfo = new EnumInfo ();
pi.enuminfo.flag = true;
pi.enuminfo.values = new ArrayList ();
foreach (XmlNode val in property["flags-values"].ChildNodes) {
FlagValue env = new FlagValue ();
env.name = val.Attributes["nick"].InnerText;
env.value = UInt32.Parse (val.Attributes["value"].InnerText);
pi.enuminfo.values.Add (env);
}
}
ei.properties.Add (pi);
}
return true;
}
static bool handlePads (XmlNode node, ElementInfo ei) {
if (ei.pads == null)
ei.pads = new ArrayList ();
XmlElement elt = node as XmlElement;
if (elt == null)
return true;
foreach (XmlElement pad in elt.ChildNodes)
if (!IsHidden (pad) && !IsHidden (pad["name"]))
ei.pads.Add (pad["name"].InnerText);
return true;
}
/// <summary>
/// Stores the element in an extension.
/// </summary>
/// <param name="extensible">The object that is being extended.</param>
/// <param name="element">The element to store.</param>
/// <returns>This method always returns true.</returns>
public bool StoreElement(IExtensible extensible, ElementInfo element)
{
GenericExtension extension;
extension = extensible.Extensions.FirstOrDefault((e) => e.Name == GenericExtensionHandler.ExtensionName) as GenericExtension;
if (extension == null)
{
extension = new GenericExtension(GenericExtensionHandler.ExtensionName);
extensible.Extensions.Add(extension);
}
Utilities.SetParent(element.Element, extensible as XliffElement);
extension.AddChild(element);
return true;
}
/// <summary>
/// Stores the <see cref="XliffElement"/> as a child of this <see cref="XliffElement"/>.
/// </summary>
/// <param name="child">The child to add.</param>
/// <returns>True if the child was stored, otherwise false.</returns>
protected override bool StoreChild(ElementInfo child)
{
bool result;
result = true;
if (child.Element is Match)
{
this.Matches.Add((Match)child.Element);
}
else
{
result = base.StoreChild(child);
}
return result;
}
/// <summary>
/// Stores the <see cref="XliffElement"/> as a child of this <see cref="XliffElement"/>.
/// </summary>
/// <param name="child">The child to add.</param>
/// <returns>True if the child was stored, otherwise false.</returns>
protected override bool StoreChild(ElementInfo child)
{
bool result;
result = true;
if (child.Element is XliffDocument)
{
Utilities.ThrowIfPropertyNotNull(this, PropertyNames.Document, this.Document);
this.Document = (XliffDocument)child.Element;
}
else
{
result = base.StoreChild(child);
}
return result;
}
public static DecodedObject<int> getTagValueForElement(ElementInfo info, int tagClass, int elemenType, int universalTag)
{
DecodedObject<int> result = new DecodedObject<int>();
// result.Value = tagClass | elemenType | universalTag;
if (universalTag < UniversalTags.LastUniversal)
{
result.Value = tagClass | elemenType | universalTag;
}
else
result = getTagValue(tagClass, elemenType, universalTag, universalTag, tagClass);
result.Size = 1;
if (info.hasPreparedInfo())
{
ASN1ElementMetadata meta = info.PreparedASN1ElementInfo;
if (meta != null && meta.HasTag)
{
result = getTagValue(tagClass, elemenType, universalTag,
meta.Tag,
meta.TagClass
);
}
}
else
{
ASN1Element elementInfo = null;
if (info.ASN1ElementInfo != null)
{
elementInfo = info.ASN1ElementInfo;
}
else if (info.isAttributePresent<ASN1Element>())
{
elementInfo = info.getAttribute<ASN1Element>();
}
if (elementInfo != null)
{
if (elementInfo.HasTag)
{
result = getTagValue(tagClass, elemenType, universalTag, elementInfo.Tag, elementInfo.TagClass);
}
}
}
return result;
}
/// <summary>
/// Saves the provided elements to file.
/// </summary>
/// <param name="elements">An array of the elements to save to file.</param>
public void SaveInfoToFile(ElementInfo[] elements)
{
// Logging disabled to boost performance
//using (LogGroup logGroup = LogGroup.StartDebug("Saving the provided elements to XML file."))
//{
string path = FileNamer.ElementsInfoFilePath;
//LogWriter.Debug("Path : " + path);
if (!Directory.Exists(Path.GetDirectoryName(path)))
Directory.CreateDirectory(Path.GetDirectoryName(path));
using (StreamWriter writer = File.CreateText(path))
{
XmlSerializer serializer = new XmlSerializer(elements.GetType());
serializer.Serialize(writer, elements);
writer.Close();
}
//}
}
public override int encodeString(System.Object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
if (!PERCoderUtils.is7BitEncodedString(elementInfo))
return base.encodeString(obj, stream, elementInfo);
else
{
int resultSize = 0;
byte[] val = System.Text.ASCIIEncoding.ASCII.GetBytes((string)obj);
resultSize = encodeLength(val.Length, elementInfo, stream);
if (val.Length == 0)
return resultSize;
BitArrayOutputStream bitStream = (BitArrayOutputStream) stream;
// 7-bit encoding of string
for (int i = 0; i < val.Length; i++)
{
bitStream.writeBits(val[i], 7);
}
return resultSize;
}
}
public override DecodedObject<object> decodeSequence(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
bool isSet = false;
if (!CoderUtils.isSequenceSet(elementInfo))
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo))
{
return null;
}
}
else
{
if (checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo))
{
isSet = true;
}
else
return null;
}
DecodedObject<int> len = decodeLength(stream);
int saveMaxAvailableLen = elementInfo.MaxAvailableLen;
elementInfo.MaxAvailableLen = (len.Value);
DecodedObject<object> result = null;
if(!isSet)
result =base.decodeSequence(decodedTag, objectClass, elementInfo, stream);
else
result = decodeSet(decodedTag, objectClass, elementInfo, len.Value, stream);
if (result.Size != len.Value)
throw new System.ArgumentException("Sequence '" + objectClass.ToString() + "' size is incorrect!");
result.Size = result.Size + len.Size;
elementInfo.MaxAvailableLen = (saveMaxAvailableLen);
return result;
}
void IWindowExplorer.HighLightElement(ElementInfo ElementInfo, bool locateElementByItLocators = false)
{
HighLightElement(ElementInfo);
}
private void ShowControlActions(ElementInfo EI)
{
//AvailableControlActionsGrid.DataSourceList = EI.GetAvailableActions();
}
public static RunnableConditionalActions LoadActionSets(ElementInfo root)
{
var ret = new RunnableConditionalActions();
if (root.Name != "ConditionalActions")
{
throw new FormatException("Condtional actions root element wasn't named \"ConditionalActions\"!");
}
foreach (var conditionInfo in root.Children)
{
var set = new SerializableConditionalActionSet();
#region Conditions
if (ConditionManager.TryLoadCustomCondition(conditionInfo, out var customCondition))
{
set.Condition = customCondition;
}
else
{
switch (conditionInfo.Name)
{
case "OnAdminGained":
set.Condition = new SCOnAdminGained()
{
target = conditionInfo.Attributes.GetOrThrow("target", "No target found for OnAdminGained condition!")
};
break;
case "OnConnect":
set.Condition = new SCOnConnect()
{
target = conditionInfo.Attributes.GetOrThrow("target", "No target found for OnConnect condition!"),
requiredFlags = conditionInfo.Attributes.GetString("requiredFlags", null),
needsMissionComplete = conditionInfo.Attributes.GetBool("needsMissionComplete")
};
break;
case "HasFlags":
set.Condition = new SCHasFlags()
{
requiredFlags = conditionInfo.Attributes.GetString("requiredFlags", null)
};
break;
case "Instantly":
set.Condition = new SCInstantly()
{
needsMissionComplete = conditionInfo.Attributes.GetBool("needsMissionComplete")
};
break;
case "OnDisconnect":
set.Condition = new SCOnDisconnect()
{
target = conditionInfo.Attributes.GetOrDefault("target")
};
break;
case "DoesNotHaveFlags":
set.Condition = new SCDoesNotHaveFlags()
{
Flags = conditionInfo.Attributes.GetString("Flags", null)
};
break;
}
}
if (set.Condition == null)
{
throw new FormatException($"Condition {conditionInfo.Name} could not be found!");
}
#endregion
set.Actions.AddRange(conditionInfo.Children.Select(ReadAction));
ret.Actions.Add(set);
}
return(ret);
}
public void HighLightElement(ElementInfo ElementInfo, bool locateElementByItLocators = false)
{
}
public override int encode(IASN1TypesEncoder encoder, object obj, Stream stream, ElementInfo elementInfo)
{
return(encoder.encodeString(obj, stream, elementInfo));
}
void IWindowExplorer.HighLightElement(ElementInfo ElementInfo)
{
HighLightElement(ElementInfo);
}
public override void StartElement(string name, Variant attributes, Variant.EnumType variantType)
{
ElementInfo context = new ElementInfo(name, attributes, variantType);
if (m_stack.Count != 0)
{
ElementInfo parentContext = m_stack.Peek();
switch (parentContext.m_type)
{
case Variant.EnumType.Any:
if (!parentContext.m_isTyped)
{
// Untyped elements with children are converted to Bags
parentContext.m_type = Variant.EnumType.Bag;
parentContext.m_element = new Variant(parentContext.m_type);
}
break;
case Variant.EnumType.None:
case Variant.EnumType.String:
case Variant.EnumType.Int32:
case Variant.EnumType.UInt32:
case Variant.EnumType.Int64:
case Variant.EnumType.UInt64:
case Variant.EnumType.Float:
case Variant.EnumType.Double:
case Variant.EnumType.Boolean:
case Variant.EnumType.Date:
case Variant.EnumType.Time:
case Variant.EnumType.DateTime:
case Variant.EnumType.Buffer:
throw new VariantException("Unexpected start element");
case Variant.EnumType.TimeSeries:
if (context.m_attributes.ContainsKey("time"))
{
context.m_time = context.m_attributes["time"].As <DateTime>();
context.m_attributes.Remove("time");
}
else
{
throw new VariantException("Missing 'time' attribute for TimeSeries element");
}
break;
}
}
m_stack.Push(context);
// infer type from 'variant' attribute
if (context.m_attributes.ContainsKey("variant"))
{
context.m_type = Variant.StringToEnum(context.m_attributes["variant"].As <string>());
context.m_isTyped = true;
context.m_attributes.Remove("variant");
}
switch (context.m_type)
{
case Variant.EnumType.Any:
if (!context.m_isTyped && !context.m_attributes.Empty)
{
// untyped elements with attributes are assumed
// to be bags
context.m_type = Variant.EnumType.Bag;
context.m_element = new Variant(context.m_type);
}
break;
case Variant.EnumType.None:
case Variant.EnumType.String:
case Variant.EnumType.Int32:
case Variant.EnumType.UInt32:
case Variant.EnumType.Int64:
case Variant.EnumType.UInt64:
case Variant.EnumType.Float:
case Variant.EnumType.Double:
case Variant.EnumType.Boolean:
case Variant.EnumType.Date:
case Variant.EnumType.Time:
case Variant.EnumType.DateTime:
case Variant.EnumType.Buffer:
break;
case Variant.EnumType.List:
case Variant.EnumType.Dictionary:
case Variant.EnumType.Bag:
case Variant.EnumType.TimeSeries:
context.m_element = new Variant(context.m_type);
break;
case Variant.EnumType.Exception:
case Variant.EnumType.Object:
// Exception and Object are parsed via a dictionary for convenience.
context.m_element = new Variant(Variant.EnumType.Dictionary);
break;
case Variant.EnumType.Tuple:
{
if (context.m_attributes.ContainsKey("size"))
{
context.m_element = new Variant(Variant.EnumType.Tuple, context.m_attributes["size"].As <int>());
context.m_attributes.Remove("size");
}
else
{
throw new VariantException("Missing 'size' attribute for Tuple variant");
}
break;
}
default:
throw new VariantException("Case exhaustion: " + context.m_type.ToString());
}
}
public override void EndElement()
{
if (m_stack.Count == 0)
{
throw new VariantException("End tag does not match start tag");
}
ElementInfo context = m_stack.Peek();
if (!context.m_attributes.Empty)
{
if (context.m_element.Is(Variant.EnumType.Mapping))
{
foreach (VariantItem item in context.m_attributes)
{
context.m_element.Add(item.Key, item.Value);
}
}
else
{
throw new VariantException("No attributes allowed in XML element of " + context.m_type);
}
}
switch (context.m_type)
{
case Variant.EnumType.None:
context.m_element = new Variant();
break;
case Variant.EnumType.Any:
case Variant.EnumType.String:
case Variant.EnumType.Int32:
case Variant.EnumType.UInt32:
case Variant.EnumType.Int64:
case Variant.EnumType.UInt64:
case Variant.EnumType.Float:
case Variant.EnumType.Double:
case Variant.EnumType.Boolean:
case Variant.EnumType.Date:
case Variant.EnumType.Time:
case Variant.EnumType.DateTime:
context.m_element = new Variant(context.m_type, context.m_data);
break;
case Variant.EnumType.Buffer:
context.m_element = new Variant(System.Convert.FromBase64String(context.m_data));
break;
case Variant.EnumType.Exception:
{
string typeStr = "", messageStr = "", sourceStr = "", stackStr = "";
if (context.m_element.ContainsKey("type"))
{
typeStr = context.m_element["type"].As <string>();
}
else
{
throw new VariantException("Missing 'type' element in Exception variant");
}
if (context.m_element.ContainsKey("message"))
{
messageStr = context.m_element["message"].As <string>();
}
else
{
throw new VariantException("Missing 'message' element in Exception variant");
}
if (context.m_element.ContainsKey("source"))
{
sourceStr = context.m_element["source"].As <string>();
}
if (context.m_element.ContainsKey("stack"))
{
stackStr = context.m_element["stack"].As <string>();
}
context.m_element = new Variant(new VariantExceptionInfo(typeStr, messageStr, sourceStr, stackStr));
break;
}
case Variant.EnumType.Object:
{
string className = "";
int version;
Variant param;
if (context.m_element.ContainsKey("class"))
{
className = context.m_element["class"].As <string>();
}
else
{
throw new VariantException("Missing 'class' element in Object variant");
}
if (context.m_element.ContainsKey("version"))
{
version = context.m_element["version"].As <int>();
}
else
{
throw new VariantException("Missing 'version' element in Object variant");
}
if (context.m_element.ContainsKey("params"))
{
param = context.m_element["params"];
}
else
{
throw new VariantException("Missing 'params' element in Object variant");
}
IVariantObject obj = null;
if (m_factory != null)
{
obj = m_factory.Create(className);
if (obj == null && (m_mode & XmlMode.CreateProxy) == 0)
{
throw new VariantException("Object of class " + className + " is not regsistered in factory");
}
}
if (obj == null)
{
obj = new VariantObjectProxy(className);
}
obj.Inflate(param, version);
context.m_element = new Variant(obj);
break;
}
}
if (m_stack.Count > 0)
{
m_stack.Pop();
}
if (m_stack.Count == 0)
{
m_result = context.m_element;
}
else
{
ElementInfo parentContext = m_stack.Peek();
switch (parentContext.m_type)
{
case Variant.EnumType.Exception:
case Variant.EnumType.Object:
case Variant.EnumType.Dictionary:
case Variant.EnumType.Bag:
{
parentContext.m_element.Add(context.m_name, context.m_element);
break;
}
case Variant.EnumType.List:
{
parentContext.m_element.Add(context.m_element);
break;
}
case Variant.EnumType.Tuple:
{
parentContext.m_element[parentContext.m_rowIndex++] = context.m_element;
break;
}
case Variant.EnumType.TimeSeries:
{
parentContext.m_element.Add(context.m_time, context.m_element);
break;
}
}
}
}
/// <summary> /// Update the mapped vertex and index buffer values using the provided element info. /// </summary> /// <param name="elementInfo">The structure containing the information about the element to draw.</param> /// <param name="vertexPointer">The pointer to the vertex array buffer to update.</param> /// <param name="indexPointer">The pointer to the index array buffer to update. This value is null if the index buffer used is static.</param> /// <param name="vexterStartOffset">The offset in the vertex buffer where the vertex of the element starts</param> protected abstract void UpdateBufferValuesFromElementInfo(ref ElementInfo elementInfo, IntPtr vertexPointer, IntPtr indexPointer, int vexterStartOffset);
ObservableList <OptionalValue> IWindowExplorer.GetOptionalValuesList(ElementInfo ElementInfo, eLocateBy elementLocateBy, string elementLocateValue)
{
throw new NotImplementedException();
}
public ElementInfo GetMatchingElement(ElementInfo latestElement, ObservableList <ElementInfo> originalElements)
{
throw new NotImplementedException();
}
public bool TestElementLocators(ElementInfo EI, bool GetOutAfterFoundElement = false)
{
throw new NotImplementedException();
}
public override DecodedObject<object> decodeString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo), elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
CoderUtils.checkConstraints(len.Value, elementInfo);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
string result = CoderUtils.bufferToASN1String(byteBuf, elementInfo);
return new DecodedObject<object>(result, len.Value + len.Size);
}
protected bool checkTagForObject(DecodedObject<object> decodedTag, int tagClass, int elementType, int universalTag, ElementInfo elementInfo)
{
if (decodedTag == null)
return false;
int definedTag = BERCoderUtils.getTagValueForElement(elementInfo, tagClass, elementType, universalTag).Value;
return definedTag == (int)decodedTag.Value;
}
ObservableList <ControlProperty> IWindowExplorer.GetElementProperties(ElementInfo ElementInfo)
{
return(GetElementProperties(ElementInfo));
}
object IWindowExplorer.GetElementData(ElementInfo ElementInfo, eLocateBy elementLocateBy, string elementLocateValue)
{
throw new System.NotImplementedException();
}
ObservableList <ElementLocator> IWindowExplorer.GetElementLocators(ElementInfo ElementInfo)
{
return(GetElementLocators(ElementInfo));
}
public System.Collections.Generic.List <ElementInfo> GetElementChildren(ElementInfo ElementInfo)
{
throw new System.NotImplementedException();
}
public override DecodedObject<object> decodeChoice(DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if ( (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag)
|| (elementInfo.ASN1ElementInfo != null && elementInfo.ASN1ElementInfo.HasTag))
{
if (!checkTagForObject(decodedTag, TagClasses.ContextSpecific, ElementType.Constructed, UniversalTags.LastUniversal, elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
DecodedObject<object> childDecodedTag = decodeTag(stream);
DecodedObject<object> result = base.decodeChoice(childDecodedTag, objectClass, elementInfo, stream);
result.Size += len.Size + childDecodedTag.Size;
return result;
}
else
return base.decodeChoice(decodedTag, objectClass, elementInfo, stream);
}
public ElementInfo LearnElementInfoDetails(ElementInfo EI)
{
return(EI);
}
/// <summary>
/// Stores the <see cref="XliffElement"/> as a child of this <see cref="XliffElement"/>.
/// </summary>
/// <param name="child">The child to add.</param>
/// <returns>True if the child was stored, otherwise false.</returns>
protected override bool StoreChild(ElementInfo child)
{
bool result;
result = true;
if (child.Element is MetaGroup)
{
this.Groups.Add((MetaGroup)child.Element);
}
else
{
result = base.StoreChild(child);
}
return result;
}
public static SerializableAction ReadAction(ElementInfo actionInfo)
{
if (ActionManager.TryLoadCustomAction(actionInfo, out var customAction))
{
return(customAction);
}
switch (actionInfo.Name)
{
case "LoadMission":
return(ActionDelayDecorator.Create(actionInfo, new SALoadMission()
{
MissionName = actionInfo.Attributes.GetOrThrow("MissionName", "Invalid mission for LoadMission action", StringExtensions.ContentFileExists)
}));
case "RunFunction":
return(new SARunFunction()
{
FunctionName = actionInfo.Attributes.GetOrThrow("FunctionName", "No function given for RunFunction action"),
FunctionValue = actionInfo.Attributes.GetInt("FunctionValue"),
Delay = actionInfo.Attributes.GetFloat("Delay"),
DelayHost = actionInfo.Attributes.GetString("DelayHost", null)
});
case "AddAsset":
return(ActionDelayDecorator.Create(actionInfo, new SAAddAsset()
{
TargetComp = actionInfo.Attributes.GetString("TargetComp", null),
TargetFolderpath = actionInfo.Attributes.GetString("TargetFolderpath", null),
FileName = actionInfo.Attributes.GetString("FileName", null),
FileContents = actionInfo.Attributes.GetString("FileContents", null)
}));
case "AddMissionToHubServer":
var tag = actionInfo.Attributes.GetString("AssignmentTag");
if (string.IsNullOrWhiteSpace(tag))
{
tag = null;
}
return(ActionDelayDecorator.Create(actionInfo, new SAAddMissionToHubServer()
{
MissionFilepath = actionInfo.Attributes.GetOrWarn("MissionFilepath", "Invalid mission file path for AddMissionToHubServer", StringExtensions.ContentFileExists),
TargetComp = actionInfo.Attributes.GetOrThrow("TargetComp", "Invalid target computer for AddMissionToHubServer", StringExtensions.HasContent),
AssignmentTag = tag,
StartsComplete = actionInfo.Attributes.GetBool("StartsComplete")
}));
case "RemoveMissionFromHubServer":
return(ActionDelayDecorator.Create(actionInfo, new SARemoveMissionFromHubServer()
{
MissionFilepath = actionInfo.Attributes.GetOrWarn("MissionFilepath", "Invalid mission file path for RemoveMissionFromHubServer", StringExtensions.ContentFileExists),
TargetComp = actionInfo.Attributes.GetOrThrow("TargetComp", "Invalid target computer for RemoveMissionFromHubServer", StringExtensions.HasContent)
}));
case "AddThreadToMissionBoard":
return(ActionDelayDecorator.Create(actionInfo, new SAAddThreadToMissionBoard()
{
ThreadFilepath = actionInfo.Attributes.GetOrWarn("ThreadFilepath", "Invalid thread path for AddThreadToMissionBoard", StringExtensions.ContentFileExists),
TargetComp = actionInfo.Attributes.GetOrThrow("TargetComp", "Invalid target computer for AddThreadToMissionBoard", StringExtensions.HasContent)
}));
case "AddIRCMessage":
return(new SAAddIRCMessage()
{
Author = ComputerLoader.filter(actionInfo.Attributes.GetOrThrow("Author", "Invalid author for AddIRCMessage", StringExtensions.HasContent)),
Message = ComputerLoader.filter(string.IsNullOrEmpty(actionInfo.Content) ? throw new FormatException("Invalid message for AddIRCMessage") : actionInfo.Content),
Delay = actionInfo.Attributes.GetFloat("Delay"),
TargetComp = actionInfo.Attributes.GetOrThrow("TargetComp", "Invalid target computer for AddIRCMessage", StringExtensions.HasContent)
});
public override int encode(IASN1TypesEncoder encoder, object obj, Stream stream, ElementInfo elementInfo)
{
return encoder.encodeSequence(obj, stream, elementInfo);
}
public void HighLightElement(ElementInfo ElementInfo)
{
return;
}
public Operation_Element_ChangeRotAngle_Trans(ElementInfo e, float angleOld, float angleNew)
: base(e, angleOld, angleNew)
{
}
public override DecodedObject<object> decodeReal(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Real, elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
int realPreamble = stream.ReadByte();
Double result = 0.0D;
int szResult = len.Value;
if ((realPreamble & 0x40) == 1)
{
// 01000000 Value is PLUS-INFINITY
result = Double.PositiveInfinity;
}
if ((realPreamble & 0x41) == 1)
{
// 01000001 Value is MINUS-INFINITY
result = Double.NegativeInfinity;
szResult += 1;
}
else
if (len.Value > 0)
{
int szOfExp = 1 + (realPreamble & 0x3);
int sign = realPreamble & 0x40;
int ff = (realPreamble & 0x0C) >> 2;
DecodedObject<object> exponentEncFrm = decodeLongValue(stream, new DecodedObject<int>(szOfExp));
long exponent = (long)exponentEncFrm.Value;
DecodedObject<object> mantissaEncFrm = decodeLongValue(stream, new DecodedObject<int>(szResult - szOfExp - 1));
// Unpack mantissa & decrement exponent for base 2
long mantissa = (long)mantissaEncFrm.Value << ff;
while ((mantissa & 0x000ff00000000000L) == 0x0)
{
exponent -= 8;
mantissa <<= 8;
}
while ((mantissa & 0x0010000000000000L) == 0x0)
{
exponent -= 1;
mantissa <<= 1;
}
mantissa &= 0x0FFFFFFFFFFFFFL;
long lValue = (exponent + 1023 + 52) << 52;
lValue |= mantissa;
if (sign == 1)
{
lValue = (long)((ulong)lValue | 0x8000000000000000L);
}
#if PocketPC
byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue);
result = System.BitConverter.ToDouble(dblValAsBytes, 0);
#else
result = System.BitConverter.Int64BitsToDouble(lValue);
#endif
}
return new DecodedObject<object>(result, len.Value + len.Size);
}
public Operation_Element_ChangeAlpha_Trans(ElementInfo e, float alphaOld, float alphaNew)
: base(e, alphaOld, alphaNew)
{
}
public override DecodedObject<object> decodeSequenceOf(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!CoderUtils.isSequenceSetOf(elementInfo))
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo))
return null;
}
else
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo))
return null;
}
Type paramType = (System.Type)objectClass.GetGenericArguments()[0];
Type collectionType = typeof(List<>);
Type genCollectionType = collectionType.MakeGenericType(paramType);
Object param = Activator.CreateInstance(genCollectionType);
DecodedObject<int> len = decodeLength(stream);
if (len.Value != 0)
{
int lenOfItems = 0;
int itemsCnt = 0;
do
{
ElementInfo info = new ElementInfo();
info.ParentAnnotatedClass = elementInfo.AnnotatedClass;
info.AnnotatedClass = paramType;
if (elementInfo.hasPreparedInfo())
{
ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata;
info.PreparedInfo = (seqOfMeta.getItemClassMetadata());
}
DecodedObject<object> itemTag = decodeTag(stream);
DecodedObject<object> item = decodeClassType(itemTag, paramType, info, stream);
MethodInfo method = param.GetType().GetMethod("Add");
if (item != null)
{
lenOfItems += item.Size + itemTag.Size;
method.Invoke(param, new object[] { item.Value });
itemsCnt++;
}
}
while (lenOfItems < len.Value);
CoderUtils.checkConstraints(itemsCnt, elementInfo);
}
return new DecodedObject<object>(param, len.Value + len.Size);
}
public Operation_Element_ChangeScale_Trans(ElementInfo e, SizeF scale)
: base(e, scale)
{
}
StackPanel ITreeViewItem.Header()
{
return(TreeViewUtils.CreateItemHeader(UIAElementInfo.ElementTitle, ElementInfo.GetElementTypeImage(eElementType.Label)));
}
StackPanel ITreeViewItem.Header()
{
return(TreeViewUtils.CreateItemHeader(Name, ElementInfo.GetElementTypeImage(eElementType.Browser)));
}
protected virtual DecodedObject<object> decodeSet(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, int len, System.IO.Stream stream)
{
object sequence = createInstanceForElement(objectClass,elementInfo);
initDefaultValues(sequence);
DecodedObject<object> fieldTag = null;
int sizeOfSequence = 0;
int maxSeqLen = elementInfo.MaxAvailableLen;
if (maxSeqLen == -1 || maxSeqLen > 0)
{
fieldTag = decodeTag(stream);
if (fieldTag != null)
sizeOfSequence += fieldTag.Size;
}
PropertyInfo[] fields =
elementInfo.getProperties(objectClass);
bool fieldEncoded = false;
do
{
for (int i = 0; i < fields.Length; i++)
{
PropertyInfo field = fields[i];
DecodedObject<object> obj = decodeSequenceField(
fieldTag, sequence, i, field, stream, elementInfo, false
);
if (obj != null)
{
fieldEncoded = true;
sizeOfSequence += obj.Size;
bool isAny = false;
if (i + 1 == fields.Length - 1)
{
ElementInfo info = new ElementInfo();
info.AnnotatedClass = (fields[i + 1]);
info.MaxAvailableLen = (elementInfo.MaxAvailableLen);
if (elementInfo.hasPreparedInfo())
{
info.PreparedInfo = (elementInfo.PreparedInfo.getPropertyMetadata(i + 1));
}
else
info.ASN1ElementInfo = CoderUtils.getAttribute<ASN1Element>(fields[i + 1]);
isAny = CoderUtils.isAnyField(fields[i + 1], info);
}
if (maxSeqLen != -1)
{
elementInfo.MaxAvailableLen = (maxSeqLen - sizeOfSequence);
}
if (!isAny)
{
if (i < fields.Length - 1)
{
if (maxSeqLen == -1 || elementInfo.MaxAvailableLen > 0)
{
fieldTag = decodeTag(stream);
if (fieldTag != null)
sizeOfSequence += fieldTag.Size;
else
{
break;
}
}
else
fieldTag = null;
}
else
break;
}
}
;
}
}
while (sizeOfSequence < len && fieldEncoded);
return new DecodedObject<object>(sequence, sizeOfSequence);
}
public ObservableList <ControlProperty> GetElementProperties(ElementInfo ElementInfo)
{
return(new ObservableList <ControlProperty>());
throw new System.NotImplementedException();
}
object IWindowExplorer.GetElementData(ElementInfo ElementInfo, eLocateBy elementLocateBy, string elementLocateValue)
{
UIAElementInfo EI = (UIAElementInfo)ElementInfo;
return(mUIAutomationHelper.GetElementData(EI.ElementObject));
}
public ObservableList <ElementLocator> GetElementLocators(ElementInfo ElementInfo)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Stores the <see cref="XliffElement"/> as a child of this <see cref="XliffElement"/>.
/// </summary>
/// <param name="child">The child to add.</param>
/// <returns>True if the child was stored, otherwise false.</returns>
protected override bool StoreChild(ElementInfo child)
{
if (child.Element is CustomElement2)
{
this.Element2 = (CustomElement2)child.Element;
}
else if (child.Element is CustomElement1)
{
this.Element1 = (CustomElement1)child.Element;
}
else
{
this.children.Add(child);
}
return true;
}
List <ElementInfo> IWindowExplorer.GetElementChildren(ElementInfo ElementInfo)
{
return(GetElementChildren(ElementInfo));
}
public override DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
return decoder.decodeSequence(decodedTag,objectClass,elementInfo,stream);
}
void IWindowExplorer.UpdateElementInfoFields(ElementInfo eI)
{
}
/// <summary>
/// Stores the <see cref="XliffElement"/> as a child of this <see cref="XliffElement"/>.
/// </summary>
/// <param name="child">The child to add.</param>
/// <returns>True if the child was stored, otherwise false.</returns>
protected override bool StoreChild(ElementInfo child)
{
bool result;
result = true;
if (child.Element is ResourceItemRef)
{
this.ResourceItemReferences.Add((ResourceItemRef)child.Element);
}
else if (child.Element is ResourceItem)
{
this.ResourceItems.Add((ResourceItem)child.Element);
}
else
{
result = base.StoreChild(child);
}
return result;
}
public async Task <ElementRects> GetMainElementRects()
{
return(await ElementInfo.GetElementRectsByID($"main_{IdentityKey}"));
}