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)); }