public void AddReference(ReferenceDefinition referenceDefinition)
{
if (referenceDefinition == null)
{
throw new ArgumentNullException("referenceDefinition");
}
if (References.Contains(referenceDefinition))
{
throw new ArgumentException("Reference definition is already added");
}
ReferenceList.Add(referenceDefinition);
}
public static ReferenceList ReadReferences(XElement xml)
{
if (xml.Element("references") != null)
{
var references = new ReferenceList();
foreach (var refs in xml.Element("references").Elements())
{
switch (refs.Name.ToString())
{
case "linkReference":
references.Add(new LinkReference(refs));
break;
case "bookReference":
references.Add(new BookReference(refs));
break;
}
}
return(references);
}
return(null);
}
/// <summary>
/// Read rows from the excel xml format.
/// Overridden by each class that inherits this class.
/// </summary>
/// <param name="userContext">
/// Information about the user that makes this method call.
/// </param>
/// <param name='xmlDoc'>The xml document that the row node will be read from.</param>
/// <param name="nsmgr">Namespacemanager containing all namespaces used by the excel compatible xml format</param>
protected override void ReadExcelXmlRows(IUserContext userContext,
XmlDocument xmlDoc,
XmlNamespaceManager nsmgr)
{
ReferenceList references;
XmlNode dataNode;
XmlNodeList rowNodes;
rowNodes = xmlDoc.SelectNodes("/ss:Workbook/ss:Worksheet/ss:Table/ss:Row", nsmgr);
references = new ReferenceList();
foreach (XmlNode rowNode in rowNodes)
{
dataNode = rowNode.SelectSingleNode("ss:Cell/ss:Data", nsmgr);
references.Add(CoreData.ReferenceManager.GetReference(userContext, dataNode.InnerText.WebParseInt32()));
}
References = references;
}
/// <summary>
/// Convert a list of WebReference instances
/// to a ReferenceList.
/// </summary>
/// <param name="userContext">
/// Information about the user that makes this method call.
/// </param>
/// <param name="webReferences">List of WebReference instances.</param>
/// <returns>A ReferenceList.</returns>
private ReferenceList GetReferences(IUserContext userContext,
List <WebReference> webReferences)
{
ReferenceList references;
references = null;
if (webReferences.IsNotEmpty())
{
references = new ReferenceList();
foreach (WebReference webReference in webReferences)
{
references.Add(GetReference(userContext, webReference));
}
references.Sort();
}
return(references);
}
public void AddReference(Reference refer)
{
ReferenceList.Add(refer);
}
private static FilterCriterion BuildCriterion(List <Token> tokens, Type dataType, Type defaultCriterionType, CultureInfo culture)
{
FilterCriterion filterCriterion = null;
ReferenceList <FilterCriterion> initializedCriteria = new ReferenceList <FilterCriterion>();
List <int> precedences = new List <int>();
FilterParser.FillPrecedenceList(precedences);
for (int index = 0; index < precedences.Count; index++)
{
int curOperatorPrecedence = precedences[index];
foreach (Type type in FilterParser.RegisteredFilterCriterionTypes)
{
CriterionDescriptorAttribute attribute = ( CriterionDescriptorAttribute )type.GetCustomAttributes(typeof(CriterionDescriptorAttribute), true)[0];
if (( int )attribute.OperatorPrecedence == curOperatorPrecedence)
{
if (!string.IsNullOrEmpty(attribute.Pattern))
{
bool tokenConsumed;
do
{
tokenConsumed = false;
for (int i = 0; i < tokens.Count; i++)
{
FilterCriterionToken filterToken = tokens[i] as FilterCriterionToken;
if ((filterToken != null) && (filterToken.FilterCriterion.GetType() == type) && (!initializedCriteria.Contains(filterToken.FilterCriterion)))
{
List <object> parameters = new List <object>();
if (attribute.Pattern.StartsWith("@"))
{
if (i <= 0)
{
throw new DataGridException(string.Format(FilterParser.MissingLeftOperandErrorText, type.Name));
}
if (tokens[i - 1] is ValueToken)
{
FilterParser.AddValueToParameters(parameters, ( ValueToken )tokens[i - 1], dataType, culture);
}
else
{
parameters.Add((( FilterCriterionToken )tokens[i - 1]).FilterCriterion);
}
tokens.RemoveAt(i - 1);
i--;
}
if (attribute.Pattern.EndsWith("@"))
{
if (i + 1 >= tokens.Count)
{
throw new DataGridException(string.Format(FilterParser.MissingRightOperandErrorText, type.Name));
}
if (tokens[i + 1] is ValueToken)
{
FilterParser.AddValueToParameters(parameters, ( ValueToken )tokens[i + 1], dataType, culture);
}
else
{
parameters.Add((( FilterCriterionToken )tokens[i + 1]).FilterCriterion);
}
tokens.RemoveAt(i + 1);
i--;
}
filterToken.FilterCriterion.InitializeFrom(parameters.ToArray(), defaultCriterionType);
initializedCriteria.Add(filterToken.FilterCriterion);
tokenConsumed = true;
break;
}
}
}while(tokenConsumed);
}
else
{
if (type != typeof(ContainsFilterCriterion))
{
throw new DataGridInternalException("Missing pattern in attribute: " + type.Name);
}
}
}
}
}
if ((tokens.Count == 1) && (tokens[0] is FilterCriterionToken))
{
filterCriterion = (( FilterCriterionToken )tokens[0]).FilterCriterion;
}
else
{
throw new DataGridException(FilterParser.InvalidExpressionErrorText);
}
return(filterCriterion);
}
void WriteObject(object obj)
{
CheckDebug.NotNull(obj);
WriteMarker(Marker.Object);
if (ObjectReferenceAddOrWrite(obj))
{
return;
}
var info = context.GetClassInfo(obj);
if (refClasses.Add(info, out var index))
{
// http://download.macromedia.com/pub/labs/amf/amf3_spec_121207.pdf
// """
// The first (low) bit is a flag with value 1. The second bit is a flag
// (representing whether a trait reference follows) with value 0 to imply that
// this objects traits are being sent by reference. The remaining 1 to 27
// significant bits are used to encode a trait reference index (an integer).
// -- AMF3 specification, 3.12 Object type
// """
// <u27=trait-reference-index> <0=trait-reference> <1=object-inline>
WriteInlineHeaderValue(index << 1);
}
else
{
// write the class definition
// we can use the same format to serialize normal and extern classes, for simplicity's sake.
// normal: <u25=member-count> <u1=dynamic> <0=externalizable> <1=trait-inline> <1=object-inline>
// externalizable: <u25=insignificant> <u1=insignificant> <1=externalizable> <1=trait-inline> <1=object-inline>
var header = info.Members.Length;
header = (header << 1) | (info.IsDynamic ? 1 : 0);
header = (header << 1) | (info.IsExternalizable ? 1 : 0);
header = (header << 1) | 1;
// the final shift is done here.
WriteInlineHeaderValue(header);
// write the type name
UnmarkedWriteString(info.Name, isString: true);
// then, write the actual object value
if (info.IsExternalizable)
{
if (!(obj is IExternalizable externalizable))
{
throw new ArgumentException($"{obj.GetType().FullName} ({info.Name}) is marked as externalizable but does not implement IExternalizable");
}
externalizable.WriteExternal(new DataOutput(writer));
}
else
{
foreach (var member in info.Members)
{
UnmarkedWriteString(member.Name, isString: true);
}
foreach (var member in info.Members)
{
WriteItem(member.GetValue(obj));
}
if (info.IsDynamic)
{
if (!(obj is IDictionary <string, object> dictionary))
{
throw new ArgumentException($"{obj.GetType()} is marked as dynamic but does not implement IDictionary");
}
foreach (var(key, value) in dictionary)
{
UnmarkedWriteString(key, isString: true);
WriteItem(value);
}
UnmarkedWriteString(string.Empty, isString: true);
}
}
}
}
void ReferenceAdd(object value) => refs.Add(value, out var _);
object ReadContent(XmlReader reader)
{
reader.MoveToContent();
if (reader.NodeType != XmlNodeType.Element)
{
throw new XmlException(String.Format("Node type {0} is not expected as a WS-Security message header content.", reader.NodeType));
}
switch (reader.NamespaceURI)
{
case Constants.WsuNamespace:
switch (reader.LocalName)
{
case "Timestamp":
return(ReadTimestamp(reader));
}
break;
//case Constants.WstNamespace:
case Constants.Wss11Namespace:
if (reader.LocalName == "SignatureConfirmation")
{
return(ReadSignatureConfirmation(reader, doc));
}
break;
case SignedXml.XmlDsigNamespaceUrl:
switch (reader.LocalName)
{
case "Signature":
WSSignedXml sxml = new WSSignedXml(doc);
sxml.Signature.LoadXml((XmlElement)doc.ReadNode(reader));
UpdateSignatureKeyInfo(sxml.Signature, doc, serializer);
return(sxml);
}
break;
case EncryptedXml.XmlEncNamespaceUrl:
switch (reader.LocalName)
{
case "EncryptedData":
XmlElement el = (XmlElement)doc.ReadNode(reader);
return(CreateEncryptedData(el));
case "ReferenceList":
ReferenceList rl = new ReferenceList();
reader.Read();
for (reader.MoveToContent();
reader.NodeType != XmlNodeType.EndElement;
reader.MoveToContent())
{
switch (reader.LocalName)
{
case "DataReference":
DataReference dref = new DataReference();
dref.LoadXml((XmlElement)doc.ReadNode(reader));
rl.Add(dref);
continue;
case "KeyReference":
KeyReference kref = new KeyReference();
kref.LoadXml((XmlElement)doc.ReadNode(reader));
rl.Add(kref);
continue;
}
throw new XmlException(String.Format("Unexpected {2} node '{0}' in namespace '{1}' in ReferenceList.", reader.Name, reader.NamespaceURI, reader.NodeType));
}
reader.ReadEndElement();
return(rl);
}
break;
}
// SecurityTokenReference will be handled here.
// This order (Token->KeyIdentifierClause) is
// important because WrappedKey could be read
// in both context (but must be a token here).
if (serializer.CanReadToken(reader))
{
return(serializer.ReadToken(reader, resolver));
}
else if (serializer.CanReadKeyIdentifierClause(reader))
{
return(serializer.ReadKeyIdentifierClause(reader));
}
else
{
throw new XmlException(String.Format("Unexpected element '{0}' in namespace '{1}' as a WS-Security message header content.", reader.Name, reader.NamespaceURI));
}
}
public override void AddRawFileReference(string relativeFilename)
{
ReferenceList.Add(new AssetReference(Path, relativeFilename, -1, AssetReferenceType.RawFilename));
}
