/// <inheritdoc /> public override T Dequeue() { if (_events.Count > _threshold) { return(_events.Dequeue()); } throw new InvalidOperationException("Event queue is empty"); }
public async Task StartListening() { while (true) { var dispatchedEvent = _eventQueue.Dequeue(); var strategy = _dispatcherStrategyFactory.GetStrategy(dispatchedEvent.DispatcherStrategy); await strategy.DispatchEventAsync(dispatchedEvent.EndpointUrl, dispatchedEvent.Payload); } }
public void Publish(string pluginName, IEventPublisher callback) { while (ququedEventsQueue.GetCount(pluginName) > 0) { var e = ququedEventsQueue.Peek(pluginName); if (RePublish(pluginName, e, callback)) { ququedEventsQueue.Dequeue(pluginName); } else { logger.Warn("Can not send event {0} for plugin {1} so this loop was break.", e, pluginName); break; } } }
public static IEventBase?Dequeue(this IEventQueue eventQueue) { return(eventQueue.Dequeue(DefaultQueueName)); }
public static bool TryDequeue(this IEventQueue eventQueue, string queueName, out IEventBase? @event) { @event = eventQueue.Dequeue(queueName); return(@event is not null); }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'parseTypeCollectionPropertyElt' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Collection Parse Type Property Element and its Children</param> /// <param name="parent">Parent Event (ie. Node) of the Property Element</param> private void GrammarProductionParseTypeCollectionPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Parse Type Collection Property Element"); } //Get the first Event, should be an ElementEvent //Type checking is done by the Parent Production IRdfXmlEvent first = eventlist.Dequeue(); ElementEvent element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); //Apply Namespaces this.ApplyNamespaces(context, element); //Validate Attributes String ID = String.Empty; if (element.Attributes.Count > 2) { //Can't be more than 2 Attributes, only allowed an optional rdf:ID and a required rdf:parseType throw ParserHelper.Error("An Property Element with Parse Type 'Collection' was encountered with too many Attributes. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Collection'", "Parse Type Collection Property Element", element); } else { //Check the attributes that do exist foreach (AttributeEvent a in element.Attributes) { if (RdfXmlSpecsHelper.IsIDAttribute(a)) { ID = "#" + a.Value; } else if (a.QName.Equals("rdf:parseType")) { //OK } else { //Invalid Attribute throw ParserHelper.Error("Unexpected Attribute '" + a.QName + "' was encountered on a Property Element with Parse Type 'Collection'. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Collection'", "Parse Type Collection Property Element", element); } } } //Build sequence of Blank Nodes IRdfXmlEvent next; IRdfXmlEvent nodeElement; Queue<ElementEvent> seqNodes = new Queue<ElementEvent>(); while (eventlist.Count > 1) { #region Node Element Processing //Need to process the Node Element first //Create a new Sublist IEventQueue<IRdfXmlEvent> subevents = new EventQueue<IRdfXmlEvent>(); int nesting = 0; nodeElement = eventlist.Peek(); //Add Node Element to sequence seqNodes.Enqueue((ElementEvent)nodeElement); //Gather the Sublist taking account of nesting do { next = eventlist.Dequeue(); subevents.Enqueue(next); if (next is ElementEvent) { nesting++; } else if (next is EndElementEvent) { nesting--; } } while (nesting > 0); //Call the next Grammar Production this.GrammarProductionNodeElement(context, subevents); #endregion } //Build a triple expressing the start of the list (which may be an empty list) INode subj, pred, obj; INode firstPred, restPred; INode b1, b2; //Subject comes from Parent ElementEvent parentElement = (ElementEvent)parent; subj = parentElement.SubjectNode; //Validate the ID (if any) if (!ID.Equals(String.Empty)) { this.ValidateID(context, ID.Substring(1), subj); } //Predicate from the Element pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName); if (seqNodes.Count > 0) { //Non-empty list ElementEvent node; //Get first Element from the Queue node = seqNodes.Dequeue(); //Object is first thing in the Sequence which we create a Blank Node for b1 = context.Handler.CreateBlankNode(); //Assert if (!context.Handler.HandleTriple(new Triple(subj, pred, b1))) ParserHelper.Stop(); //Reify if applicable if (!ID.Equals(String.Empty)) { //Resolve the Uri UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty); IUriNode uri = this.Resolve(context, uriref, element.BaseUri); this.Reify(context, uri, subj, pred, b1); } //Set the first element in the list subj = b1; firstPred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListFirst)); if (!context.Handler.HandleTriple(new Triple(subj, firstPred, node.SubjectNode))) ParserHelper.Stop(); //Middle elements of the list restPred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListRest)); while (seqNodes.Count >= 1) { node = seqNodes.Dequeue(); //Set Node 2 to be the rest of the previous items list b2 = context.Handler.CreateBlankNode(); if (!context.Handler.HandleTriple(new Triple(b1, restPred, b2))) ParserHelper.Stop(); //Set Node 2 to be the start of it's own list if (!context.Handler.HandleTriple(new Triple(b2, firstPred, node.SubjectNode))) ParserHelper.Stop(); b1 = b2; } //Set last element of the list to have its rest as nil if (!context.Handler.HandleTriple(new Triple(b1, restPred, context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListNil))))) ParserHelper.Stop(); } else { //Empty list //Object is therefore rdf:nil obj = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfListNil)); //Assert if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); //Reify if applicable if (!ID.Equals(String.Empty)) { //Resolve the Uri UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty); IUriNode uri = this.Resolve(context, uriref, element.BaseUri); this.Reify(context, uri, subj, pred, obj); } } //Check last event is an EndElementEvent next = eventlist.Dequeue(); if (!(next is EndElementEvent)) { throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an EndElementEvent to terminate a Parse Type Collection Property Element!", "Parse Type Collection Property Element", next); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'nodeElementList' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events to apply the Production to</param> private void GrammarProductionNodeElementList(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist) { //Tracing if (this._traceparsing) { this.ProductionTrace("Node Element List"); } IRdfXmlEvent next; //Want to break up into a number of sublists while (eventlist.Count > 0) { //Create a new Sublist IEventQueue<IRdfXmlEvent> subevents = new EventQueue<IRdfXmlEvent>(); int nesting = 0; //Gather the Sublist taking account of nesting do { next = eventlist.Dequeue(); subevents.Enqueue(next); if (next is ElementEvent) { nesting++; } else if (next is EndElementEvent) { nesting--; } } while (nesting > 0); //Call the next Grammar Production this.GrammarProductionNodeElement(context, subevents); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'nodeElement' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Node Element and its Children to apply the Production to</param> private void GrammarProductionNodeElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Node Element"); } //Get First Event in the Queue IRdfXmlEvent first = eventlist.Dequeue(); //Check it's an ElementEvent if (!(first is ElementEvent)) { //Unexpected Event throw ParserHelper.Error("Expected an ElementEvent but encountered a '" + first.GetType().ToString() + "'", "Node Element", first); } //Check it has a valid Uri ElementEvent element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); this.ApplyNamespaces(context, element); if (!RdfXmlSpecsHelper.IsNodeElementUri(element.QName)) { throw ParserHelper.Error("A Node Element was encountered with an invalid URI '" + element.QName + "' \nCore Syntax Terms, Old Syntax Terms and rdf:li cannot be used as Node Element URIs", "Node Element", element); } //Check the set of Attributes is Valid int limitedAttributesFound = 0; String ID = String.Empty; foreach (AttributeEvent attr in element.Attributes) { if (RdfXmlSpecsHelper.IsIDAttribute(attr)) { ID = attr.Value; limitedAttributesFound++; //Set the Subject element.Subject = new UriReferenceEvent("#" + attr.Value, attr.SourceXml); } else if (RdfXmlSpecsHelper.IsNodeIDAttribute(attr)) { limitedAttributesFound++; //Validate the Node ID if (!XmlSpecsHelper.IsName(attr.Value)) { throw ParserHelper.Error("The value '" + attr.Value + "' for rdf:nodeID is not valid, RDF Node IDs can only be valid Names as defined by the W3C XML Specification", "Node Element", attr); } //Set the Subject element.Subject = new BlankNodeIDEvent(attr.Value, attr.SourceXml); } else if (RdfXmlSpecsHelper.IsAboutAttribute(attr)) { limitedAttributesFound++; //Set the Subject element.Subject = new UriReferenceEvent(attr.Value, attr.SourceXml); } else if (RdfXmlSpecsHelper.IsPropertyAttribute(attr)) { //Don't need to do anything here yet } else { //Unknown and Unexpected Attribute Type throw ParserHelper.Error("Unexpected Attribute '" + attr.QName + "' was encountered!", "Node Element", element); } //Can't have more than 1 of ID, Node ID or About Attributes if (limitedAttributesFound > 1) { throw ParserHelper.Error("A Node Element can only have 1 of the following attributes: rdf:id, rdf:nodeID, rdf:about", "Node Element", element); } } //Generate a Blank Node ID if our Subject is empty if (element.Subject == null) { element.Subject = new BlankNodeIDEvent(element.SourceXml); } //Add statements as necessary INode subj, pred, obj; if (element.SubjectNode == null) { //Don't always want to drop in here since the SubjectNode may already be set elsewhere if (element.Subject is UriReferenceEvent) { UriReferenceEvent uri = (UriReferenceEvent)element.Subject; subj = this.Resolve(context, uri, element.BaseUri); } else if (element.Subject is BlankNodeIDEvent) { BlankNodeIDEvent blank = (BlankNodeIDEvent)element.Subject; //Select whether we need to generate an ID or if there's one given for the Blank Node //Note that we let the Graph class handle generation of IDs if (blank.Identifier.Equals(String.Empty)) { subj = context.Handler.CreateBlankNode(); } else { subj = context.Handler.CreateBlankNode(blank.Identifier); } } else { throw ParserHelper.Error("Unexpected Subject generated for a Triple", "Node Element", element.Subject); } } else { subj = element.SubjectNode; } //Set the Subject Node property of the Event for later reuse element.SubjectNode = subj; //Validate the ID (if any) if (!ID.Equals(String.Empty)) { this.ValidateID(context, ID, subj); } if (!element.QName.Equals("rdf:Description") && !element.QName.Equals(":Description")) { //Assert a Triple regarding Type pred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType)); obj = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName); if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); } //Go back over Attributes looking for property attributes foreach (AttributeEvent attr in element.Attributes) { if (RdfXmlSpecsHelper.IsPropertyAttribute(attr)) { if (attr.QName.Equals("rdf:type")) { //Generate a Type Triple pred = context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType)); //Resolve URIRef into a Uri Node UriReferenceEvent uriref = new UriReferenceEvent(attr.Value, attr.SourceXml); obj = this.Resolve(context, uriref, element.BaseUri); if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); } else { //Generate a Property Triple pred = context.Handler.CreateUriNode(UriFactory.Create(Tools.ResolveQName(attr.QName, context.Namespaces, context.BaseUri))); //Add Language to Literal if necessary if (element.Language.Equals(String.Empty)) { obj = context.Handler.CreateLiteralNode(attr.Value); } else { obj = context.Handler.CreateLiteralNode(attr.Value, element.Language); } if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); } } } //Handle Child Elements IEventQueue<IRdfXmlEvent> children = new EventQueue<IRdfXmlEvent>(); while (eventlist.Count > 1) { children.Enqueue(eventlist.Dequeue()); } if (children.Count > 0) this.GrammarProductionPropertyElementList(context, children, element); //Check Last Event in queue is an EndElement event IRdfXmlEvent last = eventlist.Dequeue(); if (!(last is EndElementEvent)) { throw ParserHelper.Error("Unexpected Event '" + last.GetType().ToString() + "', expected an EndElement Event", "NodeElement", last); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'literalPropertyElt' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Literal Property Element and its Children</param> /// <param name="parent">Parent Event (ie. Node) of the Property Element</param> private void GrammarProductionLiteralPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Literal Property Element"); } //Get the 3 Events (should only be three) IRdfXmlEvent first, middle, last; first = eventlist.Dequeue(); middle = eventlist.Dequeue(); last = eventlist.Dequeue(); //If Queue is non-empty then Error if (eventlist.Count > 0) { throw ParserHelper.Error("Too many events encountered while trying to parse a Literal Property Element", first); } ElementEvent element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); //Apply Namespaces this.ApplyNamespaces(context, element); //Validate that the middle event is a TextEvent if (!(middle is TextEvent)) { throw ParserHelper.Error("Unexpected event '" + middle.GetType().ToString() + "', expected a TextEvent in a Literal Property Element", middle); } TextEvent text = (TextEvent)middle; //Validate the Attributes String ID = String.Empty; String datatype = String.Empty; if (element.Attributes.Count > 2) { throw ParserHelper.Error("A Literal Property Element contains too many attributes, only rdf:ID and rdf:datatype are permitted", element); } else { //Only rdf:ID and rdf:datatype allowed foreach (AttributeEvent a in element.Attributes) { if (RdfXmlSpecsHelper.IsIDAttribute(a)) { ID = "#" + a.Value; } else if (RdfXmlSpecsHelper.IsDataTypeAttribute(a)) { datatype = a.Value; } else { throw ParserHelper.Error("A Literal Property Element contains an unexpected attribute, only rdf:ID and rdf:datatype are permitted", element); } } } //Create the Nodes for the Graph INode subj, pred, obj; //Get the Subject from the Parent ElementEvent parentEl = (ElementEvent)parent; subj = parentEl.SubjectNode; //Validate the ID (if any) if (!ID.Equals(String.Empty)) { this.ValidateID(context, ID.Substring(1), subj); } //Create a Predicate from this Element pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName); //Create an Object from the Text Event if (datatype.Equals(String.Empty)) { //No Type with possible Language if (element.Language.Equals(String.Empty)) { obj = context.Handler.CreateLiteralNode(text.Value); } else { obj = context.Handler.CreateLiteralNode(text.Value, element.Language); } } else { //Typed //Resolve the Datatype Uri UriReferenceEvent dtref = new UriReferenceEvent(datatype, String.Empty); IUriNode dturi = this.Resolve(context, dtref, element.BaseUri); obj = context.Handler.CreateLiteralNode(text.Value, dturi.Uri); } //Assert the Triple if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); //Reify if applicable if (!ID.Equals(String.Empty)) { //Resolve the Uri UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty); IUriNode uri = this.Resolve(context, uriref,element.BaseUri); this.Reify(context, uri, subj, pred, obj); } }
/// <summary> /// Helper function which inserts an Element back on the front of a Queue /// </summary> /// <param name="eventlist">Queue to insert onto the Front of</param> /// <param name="evt">Event to put on the front of the Queue</param> private void QueueJump(IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent evt) { Stack<IRdfXmlEvent> temp = new Stack<IRdfXmlEvent>(); temp.Push(evt); while (eventlist.Count > 0) { temp.Push(eventlist.Dequeue()); } foreach (IRdfXmlEvent e in temp.Reverse()) { eventlist.Enqueue(e); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'resourcePropertyElt' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Resource Property Element and its Children</param> /// <param name="parent">Parent Event (ie. Node) of the Property Element</param> private void GrammarProductionResourcePropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Resource Property Element"); } //Cast to an ElementEvent //We don't validate type here since we know this will be an ElementEvent because the calling function //will have done this validation previously IRdfXmlEvent first = eventlist.Dequeue(); IRdfXmlEvent next = eventlist.Peek(); ElementEvent element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); //Apply Namespaces this.ApplyNamespaces(context, element); //Only allowed one attribute max which must be an ID attribute String ID = String.Empty; if (element.Attributes.Count > 1) { throw ParserHelper.Error("A Resource Property Element contains too many Attributes, only rdf:ID is permitted", element); } else if (element.Attributes.Count == 1) { if (!RdfXmlSpecsHelper.IsIDAttribute(element.Attributes.First())) { throw ParserHelper.Error("A Resource Property Element was encountered with a single attribute which was not rdf:ID, only rdf:ID is permitted", element); } else { ID = element.Attributes.First().Value; } } //Next must be an ElementEvent if (!(next is ElementEvent)) { throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an ElementEvent as the first Event in a Resource Property Elements Event list", next); } //Get list of Sub Events IEventQueue<IRdfXmlEvent> subevents = new EventQueue<IRdfXmlEvent>(); while (eventlist.Count > 1) { subevents.Enqueue(eventlist.Dequeue()); } this.GrammarProductionNodeElement(context, subevents); //Check Last is an EndElementEvent IRdfXmlEvent last = eventlist.Dequeue(); if (!(last is EndElementEvent)) { throw ParserHelper.Error("Unexpected Event '" + last.GetType().ToString() + "', expected an EndElement Event", last); } //Now we can generate the relevant RDF INode subj, pred, obj; //Validate the Type of the Parent if (!(parent is ElementEvent)) { throw ParserHelper.Error("Unexpected Parent Event '" + parent.GetType().ToString() + "', expected an ElementEvent", parent); } ElementEvent parentEl = (ElementEvent)parent; //Get the Subject Node from the Parent subj = parentEl.SubjectNode; //Validate the ID (if any) if (!ID.Equals(String.Empty)) { this.ValidateID(context, ID, subj); } //Create a Predicate from this Element pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName); //Get the Object Node from the Child Node ElementEvent child = (ElementEvent)next; obj = child.SubjectNode; //Assert the Triple if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); //Add Reification where appropriate if (element.Attributes.Count == 1) { //Must be an rdf:ID attribute as we've validated this earlier //Get the Attribute Event and generate a Uri from it AttributeEvent attr = element.Attributes.First(); UriReferenceEvent uriref = new UriReferenceEvent("#" + attr.Value, attr.SourceXml); IUriNode uri = this.Resolve(context, uriref, element.BaseUri); this.Reify(context, uri, subj, pred, obj); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'propertyElt' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Property Element and its Children</param> /// <param name="parent">Parent Event (ie. Node) of the Property Element</param> private void GrammarProductionPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Property Element"); } //Get first thing from the Queue IRdfXmlEvent first = eventlist.Dequeue(); ElementEvent element; //Must be an ElementEvent if (!(first is ElementEvent)) { //Unexpected Event throw ParserHelper.Error("Expected an ElementEvent but encountered a '" + first.GetType().ToString() + "'", "PropertyElement", first); } //Validate the Uri element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); this.ApplyNamespaces(context, element); if (!RdfXmlSpecsHelper.IsPropertyElementURI(element.QName)) { //Invalid Uri throw ParserHelper.Error("A Property Element was encountered with an invalid URI '" + element.QName + "'\nCore Syntax Terms, Old Syntax Terms and rdf:Description cannot be used as Property Element URIs", "PropertyElement", element); } //List Expansion if (element.QName.Equals("rdf:li")) { UriReferenceEvent u = this.ListExpand(parent); element.SetUri(u); } //Need to select what to do based on the Type of Property Element IRdfXmlEvent next = eventlist.Peek(); //This call inserts the first element back at the head of the queue //Most of the sub-productions here need this //Would ideally use Stacks instead of Queues but Queues make more sense for most of the Parsing this.QueueJump(eventlist, first); if (element.ParseType == RdfXmlParseType.None) { //A Resource/Literal Property Element if (next is ElementEvent) { //Resource this.GrammarProductionResourcePropertyElement(context, eventlist, parent); } else if (next is TextEvent) { //Literal this.GrammarProductionLiteralPropertyElement(context, eventlist, parent); } else if (next is EndElementEvent) { //An Empty Property Element this.GrammarProductionEmptyPropertyElement(context, element, parent); } else { //Error throw ParserHelper.Error("An Element which should be Parsed with the Default Parsing Rules was encountered without a valid subsequent Event - Parser cannot proceed!", "Property Element", element); } } else if (element.ParseType == RdfXmlParseType.Literal) { //A rdf:parseType="Literal" Property Element this.GrammarProductionParseTypeLiteralPropertyElement(context, eventlist, parent); } else if (element.ParseType == RdfXmlParseType.Collection) { //A rdf:parseType="Collection" Property Element this.GrammarProductionParseTypeCollectionPropertyElement(context, eventlist, parent); } else if (element.ParseType == RdfXmlParseType.Resource) { //A rdf:parseType="Resource" Property Element this.GrammarProductionParseTypeResourcePropertyElement(context, eventlist, parent); } else if (next is EndElementEvent) { //An Empty Property Element this.GrammarProductionEmptyPropertyElement(context, element, parent); } else { //Error throw ParserHelper.Error("An Element without a known Parse Type was encountered Or the Parser was unable to determine what to do based on the subsequent event - Parser cannot proceed!", "Node Element", element); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'parseTypeResourcePropertyElt' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Resource Parse Type Property Element and its Children</param> /// <param name="parent">Parent Event (ie. Node) of the Property Element</param> private void GrammarProductionParseTypeResourcePropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Parse Type Resource Property Element"); } //Get the first Event, should be an ElementEvent //Type checking is done by the Parent Production IRdfXmlEvent first = eventlist.Dequeue(); ElementEvent element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); //Apply Namespaces this.ApplyNamespaces(context, element); //Validate Attributes String ID = String.Empty; if (element.Attributes.Count > 2) { //Can't be more than 2 Attributes, only allowed an optional rdf:ID and a required rdf:parseType throw ParserHelper.Error("An Property Element with Parse Type 'Resource' was encountered with too many Attributes. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Resource'", "Parse Type Resource Property Element", element); } else { //Check the attributes that do exist foreach (AttributeEvent a in element.Attributes) { if (RdfXmlSpecsHelper.IsIDAttribute(a)) { ID = "#" + a.Value; } else if (a.QName.Equals("rdf:parseType")) { //OK } else { //Invalid Attribute throw ParserHelper.Error("Unexpected Attribute '" + a.QName + "' was encountered on a Property Element with Parse Type 'Resource'. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Resource'", "Parse Type Resource Property Element", element); } } } //Add a Triple about this INode subj, pred, obj; //Get the Subject from the Parent ElementEvent parentEvent = (ElementEvent)parent; subj = parentEvent.SubjectNode; //Validate the ID (if any) if (!ID.Equals(String.Empty)) { this.ValidateID(context, ID.Substring(1), subj); } //Create the Predicate from the Element pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName); //Generate a Blank Node ID for the Object obj = context.Handler.CreateBlankNode(); //Assert if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); //Reify if applicable if (!ID.Equals(String.Empty)) { //Resolve the Uri UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty); IUriNode uri = this.Resolve(context, uriref,element.BaseUri); this.Reify(context, uri, subj, pred, obj); } //Get the next event in the Queue which should be either an Element Event or a End Element Event //Validate this IRdfXmlEvent next = eventlist.Dequeue(); if (next is EndElementEvent) { //Content is Empty so nothing else to do } else if (next is ElementEvent) { //Non-Empty Content so need to build a sequence of new events IEventQueue<IRdfXmlEvent> subEvents = new EventQueue<IRdfXmlEvent>(); //Create an rdf:Description event as the container ElementEvent descrip = new ElementEvent("rdf:Description", element.BaseUri, String.Empty); descrip.Subject = new BlankNodeIDEvent(String.Empty); descrip.SubjectNode = obj; subEvents.Enqueue(descrip); //Add the current element we were looking at subEvents.Enqueue(next); //Add rest of events in list (exceot the last) while (eventlist.Count > 1) { subEvents.Enqueue(eventlist.Dequeue()); } //Terminate with an EndElement Event subEvents.Enqueue(new EndElementEvent()); //Process with Node Element Production this.GrammarProductionNodeElement(context, subEvents); //Get the last thing in the List next = eventlist.Dequeue(); } else { throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an ElementEvent or EndElementEvent after a Parse Type Resource Property Element!", "Parse Type Resource Property Element", next); } //Check for the last thing being an EndElement Event if (!(next is EndElementEvent)) { throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an EndElementEvent to terminate a Parse Type Resource Property Element!", "Parse Type Resource Property Element", next); } }
/// <summary> /// Implementation of the RDF/XML Grammar Production 'parseTypeLiteralPropertyElt' /// </summary> /// <param name="context">Parser Context</param> /// <param name="eventlist">Queue of Events that make up the Literal Parse Type Property Element and its Children</param> /// <param name="parent">Parent Event (ie. Node) of the Property Element</param> private void GrammarProductionParseTypeLiteralPropertyElement(RdfXmlParserContext context, IEventQueue<IRdfXmlEvent> eventlist, IRdfXmlEvent parent) { //Tracing if (this._traceparsing) { this.ProductionTracePartial("Parse Type Literal Property Element"); } //Get the first Event, should be an ElementEvent //Type checking is done by the Parent Production IRdfXmlEvent first = eventlist.Dequeue(); ElementEvent element = (ElementEvent)first; if (this._traceparsing) this.ProductionTracePartial(element); //Apply Namespaces this.ApplyNamespaces(context, element); //Validate Attributes String ID = String.Empty; if (element.Attributes.Count > 2) { //Can't be more than 2 Attributes, only allowed an optional rdf:ID and a required rdf:parseType throw ParserHelper.Error("An Property Element with Parse Type 'Literal' was encountered with too many Attributes. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Literal'", "Parse Type Literal Property Element", element); } else { //Check the attributes that do exist foreach (AttributeEvent a in element.Attributes) { if (RdfXmlSpecsHelper.IsIDAttribute(a)) { ID = "#" + a.Value; } else if (a.QName.Equals("rdf:parseType")) { //OK } else { //Invalid Attribute throw ParserHelper.Error("Unexpected Attribute '" + a.QName + "' was encountered on a Property Element with Parse Type 'Literal'. Only rdf:ID and rdf:parseType are allowed on Property Elements with Parse Type 'Literal'", "Parse Type Literal Property Element", element); } } } //Get the next event in the Queue which should be a TypedLiteralEvent //Validate this IRdfXmlEvent lit = eventlist.Dequeue(); if (!(lit is TypedLiteralEvent)) { throw ParserHelper.Error("Unexpected Event '" + lit.GetType().ToString() + "', expected a TypedLiteralEvent after a Property Element with Parse Type 'Literal'", "Parse Type Literal Property Element", lit); } //Get the Subject from the Parent INode subj, pred, obj; ElementEvent parentEl = (ElementEvent) parent; subj = parentEl.SubjectNode; //Validate the ID (if any) if (!ID.Equals(String.Empty)) { this.ValidateID(context, ID.Substring(1), subj); } //Create the Predicate from the Element pred = this.Resolve(context, element);//context.Handler.CreateUriNode(element.QName); //Create the Object from the Typed Literal TypedLiteralEvent tlit = (TypedLiteralEvent)lit; //At the moment we're just going to ensure that we normalize it to Unicode Normal Form C String xmllit = tlit.Value; #if !NO_NORM xmllit = xmllit.Normalize(); #endif obj = context.Handler.CreateLiteralNode(xmllit, UriFactory.Create(tlit.DataType)); //Assert the Triple if (!context.Handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); //Reify if applicable if (!ID.Equals(String.Empty)) { //Resolve the Uri UriReferenceEvent uriref = new UriReferenceEvent(ID, String.Empty); IUriNode uri = this.Resolve(context, uriref,element.BaseUri); this.Reify(context, uri, subj, pred, obj); } //Check for the last thing being an EndElement Event IRdfXmlEvent next = eventlist.Dequeue(); if (!(next is EndElementEvent)) { throw ParserHelper.Error("Unexpected Event '" + next.GetType().ToString() + "', expected an EndElementEvent to terminate a Parse Type Literal Property Element!", "Parse Type Literal Property Element", next); } }
public IReadOnlyCollection <IDomainEvent> DequeueAllEvents() => _eventQueue.Dequeue();
public static bool TryDequeue(this IEventQueue eventQueue, out IEventBase @event) { @event = eventQueue.Dequeue(DefaultQueueName); return(null != @event); }