public void TestAddAndGrow() { var d = new Deque<int>(0); Assert.IsTrue(d.Count == 0); Assert.IsTrue(d.Capacity == 0); d.AddFirst(1); Assert.IsTrue(d.Count == 1); Assert.IsTrue(d.Capacity == 4); d.AddFirst(0); Assert.IsTrue(d.Count == 2); Assert.IsTrue(d.Capacity == 4); d.AddLast(2); d.AddLast(3); Assert.IsTrue(d.Count == 4); Assert.IsTrue(d.Capacity == 4); d.AddLast(4); Assert.IsTrue(d.Count == 5); Assert.IsTrue(d.Capacity == 8); var arr = d.ToArray(); var exp = new int[] { 0, 1, 2, 3, 4 }; Assert.IsTrue(arr.Length == exp.Length); for (int i = 0; i < arr.Length; i++) { Assert.IsTrue(arr[i] == exp[i]); } }
/// <summary> /// Add a buffer to the end of the queue and associate a promise with it that should be completed when /// all the buffer's bytes have been consumed from the queue and written. /// </summary> /// <param name="buf">to add to the tail of the queue</param> /// <param name="promise">to complete when all the bytes have been consumed and written, can be void.</param> public void Add(IByteBuffer buf, IPromise promise) { // buffers are added before promises so that we naturally 'consume' the entire buffer during removal // before we complete it's promise. _bufAndListenerPairs.AddLast(buf); if (promise is object && !promise.IsVoid) { _bufAndListenerPairs.AddLast(promise); } IncrementReadableBytes(buf.ReadableBytes); }
void EnqueueFrameWithoutMerge(IHttp2RemoteFlowControlled frame) { _pendingWriteQueue.AddLast(frame); // This must be called after adding to the queue in order so that hasFrame() is // updated before updating the stream state. IncrementPendingBytes(frame.Size, true); }
private static Deque <EventType> Events(bool inbound, int size) { EventType[] events; if (inbound) { events = new EventType[] { EventType.USER_EVENT, EventType.MESSAGE_RECEIVED, EventType.MESSAGE_RECEIVED_LAST, EventType.EXCEPTION_CAUGHT }; } else { events = new EventType[] { EventType.READ, EventType.WRITE, EventType.EXCEPTION_CAUGHT }; } Random random = new Random(); Deque <EventType> expectedEvents = new Deque <EventType>(); for (int i = 0; i < size; i++) { expectedEvents.AddLast(events[random.Next(events.Length)]); } return(expectedEvents); }
/// <summary> /// <para><paramref name="from"/> からの最短経路長を01-BSFで求める。</para> /// <para>計算量: O(|E| + |V|)</para> /// </summary> public static T[] ShortestPath01BFS <T, TOp, TNode, TEdge>(this IWGraph <T, TOp, TNode, TEdge> graph, int from) where T : struct where TOp : struct, INumOperator <T> where TNode : IGraphNode <TEdge> where TEdge : IWGraphEdge <T> { TOp op = default; var graphArr = graph.AsArray(); var INF = op.MaxValue; var res = new T[graphArr.Length]; System.Array.Fill(res, INF); res[from] = default; var used = new bool[graphArr.Length]; int count = 0; var remains = new Deque <int>(graphArr.Length) { from }; while (remains.Count > 0) { var ix = remains.PopFirst(); if (used[ix]) { continue; } used[ix] = true; if (++count >= graphArr.Length) { break; } var len = res[ix]; foreach (var e in graphArr[ix].Children) { var to = e.To; var nextLength = len; if (EqualityComparer <T> .Default.Equals(e.Value, default)) { if (op.GreaterThan(res[to], nextLength)) { res[to] = nextLength; remains.AddFirst(to); } } else { nextLength = op.Increment(nextLength); if (op.GreaterThan(res[to], nextLength)) { res[to] = nextLength; remains.AddLast(to); } } } } return(res); }
public override void Execute(IRunnable command) { if (command is null) { ThrowHelper.ThrowNullReferenceException_Command(); } _tasks.AddLast(command); }
public void PushStack(ExpressionResultCacheStackEntry lambda) { if (callStack == null) { callStack = new ArrayDeque <ExpressionResultCacheStackEntry>(); lastValueCacheStack = new ArrayDeque <long?>(10); } callStack.AddLast(lambda); }
public void PushContext(long contextNumber) { if (callStack == null) { callStack = new ArrayDeque <ExpressionResultCacheStackEntry>(); lastValueCacheStack = new ArrayDeque <long?>(10); } lastValueCacheStack.AddLast(contextNumber); }
public void RemoveLastTest() { var d1 = new Deque <int>(); int a = 5; d1.AddLast(a); Assert.AreEqual <int>(a, d1.RemoveLast()); }
public void Given_null_item_add_should_throw_NullPointerException() { // arrange var deque = new Deque<string>(); // act // assert Assert.Throws<NullReferenceException>(() => deque.AddFirst(null)); Assert.Throws<NullReferenceException>(() => deque.AddLast(null)); }
public void Add_element_should_increment_size() { // arrange var deque = new Deque<string>(); // act deque.AddFirst("Item"); deque.AddLast("Item2"); // assert Assert.AreEqual(2, deque.Size()); }
public void OnEndSession(RtpMidiEndSession rtpMidiEndSession, model.RtpMidiServer rtpMidiServer) { Log.Info("RtpMidi", "Session end from: {}", rtpMidiServer); RtpMidiSessionConnection midiServer = currentSessions.GetValueOrDefault(rtpMidiEndSession.Ssrc); if (midiServer != null) { RtpMidiSession RtpMidiSession = midiServer.RtpMidiSession; RtpMidiSession.Sender = null; RtpMidiSession.OnEndSession(rtpMidiEndSession, rtpMidiServer); } currentSessions.Remove(rtpMidiEndSession.Ssrc); RtpMidiSessionConnection sessionTuple = currentSessions.GetValueOrDefault(rtpMidiEndSession.Ssrc); if (sessionTuple != null) { sessions.AddLast(sessionTuple.RtpMidiSession); NotifyMaxNumberOfSessions(); } }
public void ContainsTest() { var d1 = new Deque <int>(); int a = 5; int b = 10; d1.AddLast(a); d1.AddFirst(b); Assert.IsTrue(d1.Contains(a)); }
public void TestRemoveAndTrim() { var d = new Deque<int>(4); Assert.IsTrue(d.Count == 0); Assert.IsTrue(d.Capacity == 4); d.AddLast(0); d.AddLast(1); d.AddLast(2); d.AddLast(3); d.AddLast(4); d.AddLast(5); Assert.IsTrue(d.Count == 6); Assert.IsTrue(d.Capacity == 8); d.RemoveLast(); d.RemoveLast(); d.RemoveLast(); Assert.IsTrue(d.Count == 3); Assert.IsTrue(d.Capacity == 8); d.TrimExcess(); Assert.IsTrue(d.Count == 3); Assert.IsTrue(d.Capacity == 3); var arr = d.ToArray(); var exp = new int[] { 0, 1, 2 }; Assert.IsTrue(arr.Length == exp.Length); for (int i = 0; i < arr.Length; i++) { Assert.IsTrue(arr[i] == exp[i]); } }
public void Remove_item_should_return_last_added_item() { // arrange var deque = new Deque<string>(); deque.AddLast("LastItem"); deque.AddFirst("Item"); // act var actual = deque.RemoveFirst(); var actualLast = deque.RemoveLast(); // assert Assert.AreEqual("Item", actual); Assert.AreEqual("LastItem", actualLast); }
public void TestLast() { //arrange if (Deque <int> .IsEmpty) { Deque <int> .AddLast(1); } var expected = Deque <int> .tail.Data; int count = Deque <int> .count; //act var actual = Deque <int> .Last; //assert Assert.AreEqual(expected, actual); }
public void TestAddLast() { //arrange var data = 365; int expectedCount = Deque <int> .count + 1; DoublyNode <int> expectedTail = new DoublyNode <int>(data); //act Deque <int> .AddLast(data); DoublyNode <int> actualTail = Deque <int> .tail; int actualCount = Deque <int> .count; //assert Assert.AreEqual(expectedTail.Data, actualTail.Data); Assert.AreEqual(expectedCount, actualCount); }
public void TestContains() { //arrange var data = 190; var data2 = 270; bool expected = true; bool expected2 = false; Deque <int> .Clear(); Deque <int> .AddLast(data); //act var actual = Deque <int> .Contains(data); var actual2 = Deque <int> .Contains(data2); //assert Assert.AreEqual(expected, actual); Assert.AreEqual(expected2, actual2); }
/// <summary> /// 使用双向队列来完成 /// 队列内只包含窗口内的最大值坐标,和最大值右侧的坐标 /// 1窗口滑动前按以上从队尾添加坐标 /// 2窗口滑动后,每滑动一次就可以增加一个返回值 /// 3窗口滑动后,检查每次新加进的元素和队尾元素相比,如果新元素较大,就舍掉这些队尾元素,因为只需直到最大的元素位置就可以了 /// 4当队首元素离开窗口时,要去除,由于这样的队列其实是【坐标代表元素】从大到小排列的,所以,从队首拿出来的坐标肯定是最大值 /// </summary> /// <param name="nums"></param> /// <param name="k"></param> /// <returns></returns> public int[] MaxSlidingWindow(int[] nums, int k) { var res = new List <int>(); Deque <int> q = new Deque <int>(); for (var i = 0; i < nums.Length; ++i) { if (!q.IsEmpty() && q.GetFirst() == i - k) { q.RemoveFirst(); } while (!q.IsEmpty() && nums[q.GetLast()] < nums[i]) { q.RemoveLast(); } q.AddLast(i); if (i >= k - 1) { res.Add(nums[q.GetFirst()]); } } return(res.ToArray()); }
public void TestEnumerator() { var exp = new int[] { 0, 1, 2, 3, 4, 5 }; var d = new Deque<int>(4); d.AddLast(0); d.AddLast(1); d.AddLast(2); d.AddLast(3); d.AddLast(4); d.AddLast(5); int index = 0; foreach (var i in d) { Assert.IsTrue(i == exp[index++]); } Assert.IsTrue(index == 6); index = 0; var en = d.GetEnumerator(); while (en.MoveNext()) { Assert.IsTrue(en.Current == exp[index++]); } Assert.IsTrue(index == 6); }
private static void RecursiveCompile( EvalFactoryNode evalNode, StatementContext context, ExprEvaluatorContext evaluatorContext, ICollection <string> eventTypeReferences, bool isInsertInto, MatchEventSpec tags, Deque <int> subexpressionIdStack, Stack <EvalFactoryNode> parentNodeStack, ICollection <string> allTagNamesOrdered) { var counter = 0; parentNodeStack.Push(evalNode); foreach (var child in evalNode.ChildNodes) { subexpressionIdStack.AddLast(counter++); RecursiveCompile( child, context, evaluatorContext, eventTypeReferences, isInsertInto, tags, subexpressionIdStack, parentNodeStack, allTagNamesOrdered); subexpressionIdStack.RemoveLast(); } parentNodeStack.Pop(); LinkedHashMap <string, Pair <EventType, string> > newTaggedEventTypes = null; LinkedHashMap <string, Pair <EventType, string> > newArrayEventTypes = null; if (evalNode is EvalFilterFactoryNode) { var filterNode = (EvalFilterFactoryNode)evalNode; var eventName = filterNode.RawFilterSpec.EventTypeName; if (context.TableService.GetTableMetadata(eventName) != null) { throw new ExprValidationException("Tables cannot be used in pattern filter atoms"); } var resolvedEventType = FilterStreamSpecRaw.ResolveType( context.EngineURI, eventName, context.EventAdapterService, context.PlugInTypeResolutionURIs); var finalEventType = resolvedEventType; var optionalTag = filterNode.EventAsName; var isPropertyEvaluation = false; var isParentMatchUntil = IsParentMatchUntil(evalNode, parentNodeStack); // obtain property event type, if final event type is properties if (filterNode.RawFilterSpec.OptionalPropertyEvalSpec != null) { var optionalPropertyEvaluator = PropertyEvaluatorFactory.MakeEvaluator( context.Container, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, resolvedEventType, filterNode.EventAsName, context.EventAdapterService, context.EngineImportService, context.SchedulingService, context.VariableService, context.ScriptingService, context.TableService, context.EngineURI, context.StatementId, context.StatementName, context.Annotations, subexpressionIdStack, context.ConfigSnapshot, context.NamedWindowMgmtService, context.StatementExtensionServicesContext); finalEventType = optionalPropertyEvaluator.FragmentEventType; isPropertyEvaluation = true; } if (finalEventType is EventTypeSPI) { eventTypeReferences.Add(((EventTypeSPI)finalEventType).Metadata.PrimaryName); } // If a tag was supplied for the type, the tags must stay with this type, i.e. a=BeanA -> b=BeanA -> a=BeanB is a no if (optionalTag != null) { var pair = tags.TaggedEventTypes.Get(optionalTag); EventType existingType = null; if (pair != null) { existingType = pair.First; } if (existingType == null) { pair = tags.ArrayEventTypes.Get(optionalTag); if (pair != null) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' used in the repeat-until operator cannot also appear in other filter expressions"); } } if ((existingType != null) && (existingType != finalEventType)) { throw new ExprValidationException( "Tag '" + optionalTag + "' for event '" + eventName + "' has already been declared for events of type " + existingType.UnderlyingType.FullName); } pair = new Pair <EventType, string>(finalEventType, eventName); // add tagged type if (isPropertyEvaluation || isParentMatchUntil) { newArrayEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); newArrayEventTypes.Put(optionalTag, pair); } else { newTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); newTaggedEventTypes.Put(optionalTag, pair); } } // For this filter, filter types are all known tags at this time, // and additionally stream 0 (self) is our event type. // Stream type service allows resolution by property name event if that name appears in other tags. // by defaulting to stream zero. // Stream zero is always the current event type, all others follow the order of the map (stream 1 to N). var selfStreamName = optionalTag; if (selfStreamName == null) { selfStreamName = "s_" + UuidGenerator.Generate(); } var filterTypes = new LinkedHashMap <string, Pair <EventType, string> >(); var typePair = new Pair <EventType, string>(finalEventType, eventName); filterTypes.Put(selfStreamName, typePair); filterTypes.PutAll(tags.TaggedEventTypes); // for the filter, specify all tags used var filterTaggedEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(tags.TaggedEventTypes); filterTaggedEventTypes.Remove(optionalTag); // handle array tags (match-until clause) LinkedHashMap <string, Pair <EventType, string> > arrayCompositeEventTypes = null; if (tags.ArrayEventTypes != null && !tags.ArrayEventTypes.IsEmpty()) { arrayCompositeEventTypes = new LinkedHashMap <string, Pair <EventType, string> >(); var patternSubexEventType = GetPatternSubexEventType( context.StatementId, "pattern", subexpressionIdStack); foreach (var entry in tags.ArrayEventTypes) { var specificArrayType = new LinkedHashMap <string, Pair <EventType, string> >(); specificArrayType.Put(entry.Key, entry.Value); var arrayTagCompositeEventType = context.EventAdapterService.CreateSemiAnonymousMapType( patternSubexEventType, Collections.GetEmptyMap <string, Pair <EventType, string> >(), specificArrayType, isInsertInto); context.StatementSemiAnonymousTypeRegistry.Register(arrayTagCompositeEventType); var tag = entry.Key; if (!filterTypes.ContainsKey(tag)) { var pair = new Pair <EventType, string>(arrayTagCompositeEventType, tag); filterTypes.Put(tag, pair); arrayCompositeEventTypes.Put(tag, pair); } } } StreamTypeService streamTypeService = new StreamTypeServiceImpl( filterTypes, context.EngineURI, true, false); var exprNodes = filterNode.RawFilterSpec.FilterExpressions; var spec = FilterSpecCompiler.MakeFilterSpec( resolvedEventType, eventName, exprNodes, filterNode.RawFilterSpec.OptionalPropertyEvalSpec, filterTaggedEventTypes, arrayCompositeEventTypes, streamTypeService, null, context, subexpressionIdStack); filterNode.FilterSpec = spec; } else if (evalNode is EvalObserverFactoryNode) { var observerNode = (EvalObserverFactoryNode)evalNode; try { var observerFactory = context.PatternResolutionService.Create(observerNode.PatternObserverSpec); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes, tags.ArrayEventTypes, subexpressionIdStack, "observer", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNOBSERVER, observerNode.PatternObserverSpec.ObjectParameters, validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); observerNode.ObserverFactory = observerFactory; observerFactory.SetObserverParameters(validated, convertor, validationContext); } catch (ObserverParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern observer '" + observerNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } } else if (evalNode is EvalGuardFactoryNode) { var guardNode = (EvalGuardFactoryNode)evalNode; try { var guardFactory = context.PatternResolutionService.Create(guardNode.PatternGuardSpec); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, tags.TaggedEventTypes, tags.ArrayEventTypes, subexpressionIdStack, "guard", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var validated = ValidateExpressions( ExprNodeOrigin.PATTERNGUARD, guardNode.PatternGuardSpec.ObjectParameters, validationContext); MatchedEventConvertor convertor = new MatchedEventConvertorImpl( tags.TaggedEventTypes, tags.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); guardNode.GuardFactory = guardFactory; guardFactory.SetGuardParameters(validated, convertor); } catch (GuardParameterException e) { throw new ExprValidationException( "Invalid parameter for pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } catch (PatternObjectException e) { throw new ExprValidationException( "Failed to resolve pattern guard '" + guardNode.ToPrecedenceFreeEPL() + "': " + e.Message, e); } } else if (evalNode is EvalEveryDistinctFactoryNode) { var distinctNode = (EvalEveryDistinctFactoryNode)evalNode; var matchEventFromChildNodes = AnalyzeMatchEvent(distinctNode); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, subexpressionIdStack, "every-distinct", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); IList <ExprNode> validated; try { validated = ValidateExpressions( ExprNodeOrigin.PATTERNEVERYDISTINCT, distinctNode.Expressions, validationContext); } catch (ExprValidationPropertyException ex) { throw new ExprValidationPropertyException( ex.Message + ", every-distinct requires that all properties resolve from sub-expressions to the every-distinct", ex.InnerException); } MatchedEventConvertor convertor = new MatchedEventConvertorImpl( matchEventFromChildNodes.TaggedEventTypes, matchEventFromChildNodes.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); distinctNode.Convertor = convertor; // Determine whether some expressions are constants or time period IList <ExprNode> distinctExpressions = new List <ExprNode>(); ExprTimePeriodEvalDeltaConst timeDeltaComputation = null; ExprNode expiryTimeExp = null; var count = -1; var last = validated.Count - 1; foreach (var expr in validated) { count++; if (count == last && expr is ExprTimePeriod) { expiryTimeExp = expr; var timePeriodExpr = (ExprTimePeriod)expiryTimeExp; timeDeltaComputation = timePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(context, false)); } else if (expr.IsConstantResult) { if (count == last) { var evaluateParams = new EvaluateParams(null, true, evaluatorContext); var value = expr.ExprEvaluator.Evaluate(evaluateParams); if (!(value.IsNumber())) { throw new ExprValidationException( "Invalid parameter for every-distinct, expected number of seconds constant (constant not considered for distinct)"); } var secondsExpire = expr.ExprEvaluator.Evaluate(evaluateParams); long?timeExpire; if (secondsExpire == null) { timeExpire = null; } else { timeExpire = context.TimeAbacus.DeltaForSecondsNumber(secondsExpire); } if (timeExpire != null && timeExpire > 0) { timeDeltaComputation = new ExprTimePeriodEvalDeltaConstGivenDelta(timeExpire.Value); expiryTimeExp = expr; } else { Log.Warn("Invalid seconds-expire " + timeExpire + " for " + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(expr)); } } else { Log.Warn( "Every-distinct node utilizes an expression returning a constant value, please check expression '{0}', not adding expression to distinct-value expression list", expr.ToExpressionStringMinPrecedenceSafe()); } } else { distinctExpressions.Add(expr); } } if (distinctExpressions.IsEmpty()) { throw new ExprValidationException( "Every-distinct node requires one or more distinct-value expressions that each return non-constant result values"); } distinctNode.SetDistinctExpressions(distinctExpressions, timeDeltaComputation, expiryTimeExp); } else if (evalNode is EvalMatchUntilFactoryNode) { var matchUntilNode = (EvalMatchUntilFactoryNode)evalNode; // compile bounds expressions, if any var untilMatchEventSpec = new MatchEventSpec(tags.TaggedEventTypes, tags.ArrayEventTypes); var streamTypeService = GetStreamTypeService( context.EngineURI, context.StatementId, context.EventAdapterService, untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, subexpressionIdStack, "until", context); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); var lower = ValidateBounds(matchUntilNode.LowerBounds, validationContext); matchUntilNode.LowerBounds = lower; var upper = ValidateBounds(matchUntilNode.UpperBounds, validationContext); matchUntilNode.UpperBounds = upper; var single = ValidateBounds(matchUntilNode.SingleBound, validationContext); matchUntilNode.SingleBound = single; var convertor = new MatchedEventConvertorImpl( untilMatchEventSpec.TaggedEventTypes, untilMatchEventSpec.ArrayEventTypes, allTagNamesOrdered, context.EventAdapterService); matchUntilNode.Convertor = convertor; // compile new tag lists ISet <string> arrayTags = null; var matchUntilAnalysisResult = EvalNodeUtil.RecursiveAnalyzeChildNodes(matchUntilNode.ChildNodes[0]); foreach (var filterNode in matchUntilAnalysisResult.FilterNodes) { var optionalTag = filterNode.EventAsName; if (optionalTag != null) { if (arrayTags == null) { arrayTags = new HashSet <string>(); } arrayTags.Add(optionalTag); } } if (arrayTags != null) { foreach (var arrayTag in arrayTags) { if (!tags.ArrayEventTypes.ContainsKey(arrayTag)) { tags.ArrayEventTypes.Put(arrayTag, tags.TaggedEventTypes.Get(arrayTag)); tags.TaggedEventTypes.Remove(arrayTag); } } } matchUntilNode.TagsArrayed = GetIndexesForTags(allTagNamesOrdered, arrayTags); } else if (evalNode is EvalFollowedByFactoryNode) { var followedByNode = (EvalFollowedByFactoryNode)evalNode; StreamTypeService streamTypeService = new StreamTypeServiceImpl(context.EngineURI, false); var validationContext = new ExprValidationContext( context.Container, streamTypeService, context.EngineImportService, context.StatementExtensionServicesContext, null, context.SchedulingService, context.VariableService, context.TableService, evaluatorContext, context.EventAdapterService, context.StatementName, context.StatementId, context.Annotations, context.ContextDescriptor, context.ScriptingService, false, false, false, false, null, false); if (followedByNode.OptionalMaxExpressions != null) { IList <ExprNode> validated = new List <ExprNode>(); foreach (var maxExpr in followedByNode.OptionalMaxExpressions) { if (maxExpr == null) { validated.Add(null); } else { var visitor = new ExprNodeSummaryVisitor(); maxExpr.Accept(visitor); if (!visitor.IsPlain) { var errorMessage = "Invalid maximum expression in followed-by, " + visitor.GetMessage() + " are not allowed within the expression"; Log.Error(errorMessage); throw new ExprValidationException(errorMessage); } var validatedExpr = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.FOLLOWEDBYMAX, maxExpr, validationContext); validated.Add(validatedExpr); if ((validatedExpr.ExprEvaluator.ReturnType == null) || (!validatedExpr.ExprEvaluator.ReturnType.IsNumeric())) { var message = "Invalid maximum expression in followed-by, the expression must return an integer value"; throw new ExprValidationException(message); } } } followedByNode.OptionalMaxExpressions = validated; } } if (newTaggedEventTypes != null) { tags.TaggedEventTypes.PutAll(newTaggedEventTypes); } if (newArrayEventTypes != null) { tags.ArrayEventTypes.PutAll(newArrayEventTypes); } }
static void Main() { int[] arrFront = { 5, 4, 3, 2, 1 }; int[] arrBack = { 6, 7, 8, 9, 10 }; // create new Deque using these arrays Deque <int> d = new Deque <int>(arrBack, arrFront); // iterate from first to last Console.Write("The Deque contains : "); foreach (int i in d) { Console.Write("{0} ", i); // 1 to 10 } Console.WriteLine(); // iterate from last to first Console.Write("Or in reverse order : "); foreach (int i in d.Reversed) { Console.Write("{0} ", i); // 10 to 1 } Console.WriteLine(); // permanently reverse the order of the items d.Reverse(); // iterate from first to last again Console.Write("After permanent reversal : "); foreach (int i in d) { Console.Write("{0} ", i); // 10 to 1 } Console.WriteLine(); // add items at front Console.WriteLine("Added 11 and 12 at the front"); d.AddRangeFirst(new int[] { 11, 12 }); // add item at back Console.WriteLine("Added 0 at the back"); d.AddLast(0); Console.WriteLine("The first item is : {0}", d.PeekFirst()); // 12 int num; if (d.TryPeekLast(out num)) { Console.WriteLine("The last item is : {0}", num); // 0 } // pop last item Console.WriteLine("Popped last item"); num = d.PopLast(); // pop first item Console.WriteLine("Popped first item"); d.TryPopFirst(out num); if (d.Contains(11)) { // iterate again Console.Write("The Deque now contains : "); foreach (int i in d) { Console.Write("{0} ", i); // 11 to 1 } Console.WriteLine(); } // peek at last item Console.WriteLine("The last item is : {0}", d.PeekLast()); // 1 // count items Console.WriteLine("The number of items is : {0}", d.Count); // 11 // convert to an array int[] ia = d.ToArray(); // reload to a new Deque adding all items at front so they'll now be reversed d = new Deque <int>(null, ia); Console.Write("The new Deque contains : "); foreach (int i in d) { Console.Write("{0} ", i); // 1 to 11 } Console.WriteLine("\nThe capacity is : {0}", d.Capacity); d.TrimExcess(); Console.WriteLine("After trimming the capacity is now : {0}", d.Capacity); // copy to an existing array ia = new int[d.Count]; d.CopyTo(ia, 0); // clear the Deque (No pun intended!) d.Clear(); Console.WriteLine("After clearing the Deque is now empty : {0}", d.IsEmpty); Console.WriteLine("The third element used to be : {0}", ia[2]); Console.ReadKey(); }
public void TestValuesAndWrapAround() { var d = new Deque<int>(4); d.AddLast(1); // internally it contains [H:1, 2, 3, 4] d.AddLast(2); d.AddLast(3); d.AddLast(4); Assert.IsTrue(d.PeekFirst() == 1 & d.PeekLast() == 4); d.RemoveFirst(); d.RemoveLast(); // now it's [0, H:2, 3, 0] Assert.IsTrue(d.Count == 2 && d.Capacity == 4); Assert.IsTrue(d.PeekFirst() == 2 & d.PeekLast() == 3); d.AddLast(4); d.RemoveFirst(); // now it's [0, 0, H:3, 4] Assert.IsTrue(d.Count == 2 && d.Capacity == 4); Assert.IsTrue(d.PeekFirst() == 3 & d.PeekLast() == 4); d.AddLast(5); d.RemoveFirst(); // now it's [5, 0, 0, H:4] Assert.IsTrue(d.Count == 2 && d.Capacity == 4); Assert.IsTrue(d.PeekFirst() == 4 & d.PeekLast() == 5); d.AddFirst(3); d.AddFirst(2); // now it's [5, H:2, 3, 4] Assert.IsTrue(d.Count == 4 && d.Capacity == 4); Assert.IsTrue(d.PeekFirst() == 2 & d.PeekLast() == 5); d.AddFirst(1); // reallocated to [H:1, 2, 3, 4, 5, 0, 0, 0] d.AddFirst(0); // now it's [1, 2, 3, 4, 5, 0, 0, H:0] Assert.IsTrue(d.Count == 6 && d.Capacity == 8); Assert.IsTrue(d.PeekFirst() == 0 & d.PeekLast() == 5); var arr = d.ToArray(); var exp = new int[] { 0, 1, 2, 3, 4, 5 }; Assert.IsTrue(arr.Length == exp.Length); for (int i = 0; i < arr.Length; i++) { Assert.IsTrue(arr[i] == exp[i]); } }
public void AdvancedTestDequeLast() { var deque = new Deque<String>(); var items = new List<string> { "0", "1", "2", "-", "-", "3", "4", "5", "6", "7", "8", "9" }; Assert.AreEqual(0, deque.Size); Assert.IsTrue(deque.IsEmpty); foreach (var item in items) { if (item != "-") { deque.AddLast(item); } else { if (!deque.IsEmpty) { deque.RemoveLast(); } } } var builder = new StringBuilder(); foreach (var item in deque) { builder.Append(item); } Assert.AreEqual("03456789", builder.ToString()); Assert.AreEqual(8, deque.Size); Assert.IsFalse(deque.IsEmpty); while (!deque.IsEmpty) { deque.RemoveLast(); } Assert.AreEqual(0, deque.Size); Assert.IsTrue(deque.IsEmpty); }
public void Enque_Back(GameObject key) { deQueue.AddLast(key); }
public Http2ControlFrameLimitEncoderTest() { _writer = new Mock <IHttp2FrameWriter>(); _ctx = new Mock <IChannelHandlerContext>(); _channel = new Mock <IChannel>(); _unsafe = new Mock <IChannelUnsafe>(); _config = new Mock <IChannelConfiguration>(); _executor = new Mock <IEventExecutor>(); _numWrites = 0; var configuration = new Mock <IHttp2FrameWriterConfiguration>(); var frameSizePolicy = new Mock <IHttp2FrameSizePolicy>(); _writer.SetupGet(x => x.Configuration).Returns(configuration.Object); configuration.SetupGet(x => x.FrameSizePolicy).Returns(frameSizePolicy.Object); frameSizePolicy.SetupGet(x => x.MaxFrameSize).Returns(Http2CodecUtil.DefaultMaxFrameSize); _writer .Setup(x => x.WriteRstStreamAsync( It.IsAny <IChannelHandlerContext>(), It.IsAny <int>(), It.IsAny <Http2Error>(), It.IsAny <IPromise>())) .Returns <IChannelHandlerContext, int, Http2Error, IPromise>((ctx, streamId, errorCode, p) => { return(HandlePromise(p, 3).Task); }); _writer .Setup(x => x.WriteSettingsAckAsync( It.IsAny <IChannelHandlerContext>(), It.IsAny <IPromise>())) .Returns <IChannelHandlerContext, IPromise>((ctx, p) => { return(HandlePromise(p, 1).Task); }); _writer .Setup(x => x.WritePingAsync( It.IsAny <IChannelHandlerContext>(), It.IsAny <bool>(), It.IsAny <long>(), It.IsAny <IPromise>())) .Returns <IChannelHandlerContext, bool, long, IPromise>((ctx, ack, data, p) => { var promise = HandlePromise(p, 3); if (ack == false) { promise.TryComplete(); } return(promise.Task); }); _writer .Setup(x => x.WriteGoAwayAsync( It.IsAny <IChannelHandlerContext>(), It.IsAny <int>(), It.IsAny <Http2Error>(), It.IsAny <IByteBuffer>(), It.IsAny <IPromise>())) .Returns <IChannelHandlerContext, int, Http2Error, IByteBuffer, IPromise>((ctx, streamId, errCode, debugData, p) => { ReferenceCountUtil.Release(debugData); _goAwayPromises.AddLast(p); return(p.Task); }); IHttp2Connection connection = new DefaultHttp2Connection(false); connection.Remote.FlowController = new DefaultHttp2RemoteFlowController(connection); connection.Local.FlowController = new DefaultHttp2LocalFlowController(connection).FrameWriter(_writer.Object); DefaultHttp2ConnectionEncoder defaultEncoder = new DefaultHttp2ConnectionEncoder(connection, _writer.Object); _encoder = new Http2ControlFrameLimitEncoder(defaultEncoder, 2); DefaultHttp2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(connection, _encoder, (new Mock <IHttp2FrameReader>()).Object); var builder = new Http2ConnectionHandlerBuilder(); builder.FrameListener = (new Mock <IHttp2FrameListener>()).Object; Http2ConnectionHandler handler = builder.Codec(decoder, _encoder).Build(); // Set LifeCycleManager on _encoder and decoder _ctx.SetupGet(x => x.Channel).Returns(_channel.Object); _ctx.SetupGet(x => x.Allocator).Returns(UnpooledByteBufferAllocator.Default); _channel.SetupGet(x => x.Allocator).Returns(UnpooledByteBufferAllocator.Default); _executor.SetupGet(x => x.InEventLoop).Returns(true); _ctx.Setup(x => x.NewPromise()).Returns(() => NewPromise()); _ctx.SetupGet(x => x.Executor).Returns(_executor.Object); _channel.SetupGet(x => x.IsActive).Returns(false); _channel.SetupGet(x => x.Configuration).Returns(_config.Object); _channel.SetupGet(x => x.IsWritable).Returns(true); _channel.SetupGet(x => x.BytesBeforeUnwritable).Returns(long.MaxValue); _config.SetupGet(x => x.WriteBufferHighWaterMark).Returns(int.MaxValue); _config.SetupGet(x => x.MessageSizeEstimator).Returns(DefaultMessageSizeEstimator.Default); ChannelMetadata metadata = new ChannelMetadata(false, 16); _channel.SetupGet(x => x.Metadata).Returns(metadata); _channel.SetupGet(x => x.Unsafe).Returns(_unsafe.Object); handler.HandlerAdded(_ctx.Object); }