void Tick(object sender, EventArgs e) { if (currentGame == null) { return; } graphicItems.Clear(); BlockList blocks = new BlockList(); lock (playerLock) foreach (GamePlayer player in currentGame.gamePlayers.getPlayers()) { blocks.Add(new PlayerBlock(FrontBuffer, player.color, player.position)); } lock (x) foreach (Enemy enemy in enemies) { blocks.Add(new EnemyBlock(FrontBuffer, enemy.getColor(), enemy.position)); } lock (bulletLock) foreach (Bullet bullet in bullets) { blocks.Add(new BulletBlock(FrontBuffer, bullet.color, bullet.position)); } if (goldenTooth != null) { blocks.Add(new GoldenToothBlock(FrontBuffer, goldenTooth.position)); } graphicItems.Add(blocks); graphicItems.Add(new PlayerScore(TopBuffer, currentGame.bestScore)); if (showScoreTable) { graphicItems.Add(new ScoreTable(TopBuffer, currentGame.gamePlayers)); } if (BackBuffer != null) { using (var graphic = Graphics.FromImage(FrontBuffer)) { graphic.Clear(Color.Transparent); } using (var graphic = Graphics.FromImage(TopBuffer)) { graphic.Clear(Color.Transparent); } } Invalidate(); graphicItems.ForEach(x => x.Draw()); if (FrontBuffer != null) { FrontBuffer = RotateImage(FrontBuffer, angle); } }
/// <summary> /// Occurs when the tag field has been changed. /// </summary> /// <param name="e">An <see cref="EventArgs"/> that contains the event data.</param> protected override void OnTagFieldChanged(EventArgs e) { //Reinitialize List BlockList.Clear(); foreach (ITagBlock tagBlock in TagField.BlockList) { BlockList.Add(new TagBlockModel() { Owner = Owner, TagBlock = tagBlock }); } //Check if (BlockList.Count > 0) { SelectedBlockIndex = 0; } else { SelectedBlockIndex = -1; } //Notify Expanded = BlockList.Count > 0; NotifyPropertyChanged(nameof(HasBlocks)); //Base procedures base.OnTagFieldChanged(e); }
private void AddBlock() { //Count int count = BlockList.Count; //Add Block tagBlock = TagField.Add(out bool success); if (success) { //Add BlockList.Add(new TagBlockModel() { Owner = Owner, TagBlock = tagBlock }); //Notify Changes if (count == 0) { NotifyPropertyChanged(nameof(HasBlocks)); } //Set SelectedBlockIndex = TagField.BlockList.IndexOf(tagBlock); NotifyValueChanged(); } }
private static void AssertBlock(BlockBase block) { var blockList = new BlockList { block }; foreach (var inputNode in block.InputNodes) { var signalBlock = new GenerateSignalBlock { TemplateName = "Binary", Start = 0, Finish = 4, SamplingRate = 1, IgnoreLastSample = true }; signalBlock.OutputNodes[0].ConnectTo(inputNode); blockList.Add(signalBlock); } blockList.ExecuteAll(); var clone = block.CloneWithLinks(); foreach (var outputNode in clone.OutputNodes) { Assert.IsNotNull(outputNode.Object[0].Samples); } Assert.IsNotNull(block.Name); Assert.IsNotNull(block.Description); Assert.IsNotNull(block.ProcessingType); }
public static BlockList Serdes(int blockNumber, BlockList blockList, ISerializer s) { if (s == null) { throw new ArgumentNullException(nameof(s)); } blockList ??= new BlockList(); if (s.IsCommenting()) { s.Begin(blockNumber.ToString(CultureInfo.InvariantCulture)); } if (s.IsReading()) { int j = 0; while (!s.IsComplete()) { blockList.Add(Block.Serdes(j, null, s)); j++; } } else { s.List(null, blockList, blockList.Count, Block.Serdes); } if (s.IsCommenting()) { s.End(); } return(blockList); }
/// <summary> /// Add a set of objects and text to the sets /// </summary> /// <param name="tag">tag should be unique (if not, it won't complain)</param> /// <param name="worldpositions">Vector array of worldpositions for each object</param> /// <param name="matrix">Array of matrix giving information for positioning each label</param> /// <param name="bitmaps">Array of bitmaps for labels associated with each object. Bitmaps are owned by caller</param> /// <param name="pos">Start position in array to start processing from</param> /// <param name="arraylength">Amount to use in the array, or -1 for all</param> public void Add(Object tag, Vector4[] worldpositions, Matrix4[] matrix, Bitmap[] bitmaps, int pos = 0, int arraylength = -1) { System.Diagnostics.Debug.Assert(tag != null); List <GLObjectsWithLabels.BlockRef> blocklist = new List <GLObjectsWithLabels.BlockRef>(); if (set.Count == 0) { //System.Diagnostics.Debug.WriteLine($"No sets found, Create 0"); AddSet(); } if (arraylength == -1) // this means use length of array { arraylength = worldpositions.Length; } int endpos = set.Last().Add(worldpositions, matrix, bitmaps, blocklist, pos, arraylength); while (endpos >= 0) // if can't add { //System.Diagnostics.Debug.WriteLine($"Create another set {set.Count} for {endpos}"); AddSet(); endpos = set.Last().Add(worldpositions, matrix, bitmaps, blocklist, endpos, arraylength); // add the rest from endpos } blocklist[0].tag = tag; // first entry only gets tag BlockList.Add(blocklist); // in order, add block list TagsToBlocks[tag] = blocklist; Objects += arraylength; }
public double Run(double[] data, int detailLevel) { var sb = new StringBuilder(); for (int i = 0; i < data.Length; i++) { sb.Append(data[i]); if (i < data.Length - 1) { sb.Append(","); } } string datastring = sb.ToString(); var textBlock = new ImportFromTextBlock { Text = datastring, ColumnSeparator = ",", SignalStart = 0, SignalNameInFirstColumn = false }; var dwtBlock = new DWTBlock { WaveletName = "db10", Level = detailLevel, ExtensionMode = SignalExtension.ExtensionMode.ZeroPadding }; var b = new BlockList(); b.Add(textBlock); b.Add(dwtBlock); textBlock.ConnectTo(dwtBlock); b.ExecuteAll(); int length = dwtBlock.OutputNodes[dwtBlock.OutputNodes.Count - 1].Object[detailLevel - 1].Samples.Length; double val = dwtBlock.OutputNodes[dwtBlock.OutputNodes.Count - 1].Object[detailLevel - 1].Samples[length - 1]; return(val); }
public void SaveBlock() { string currentHash = Helper.GetSha256Hash(CurrentBlock); CurrentBlock.Hash = Helper.GetSha256Hash(CurrentBlock); BlockList.Add(CurrentBlock); //dodanie aktualnego bloku CurrentBlock = new Block(currentHash); //nowy blok }
public GameWorld(int width, int height, ContentManager Content) { screenWidth = width; screenHeight = height; random = new Random(); gameState = GameState.Menu; inputHelper = new InputHelper(); block = Content.Load<Texture2D>("block"); reset = Content.Load<Texture2D>("reset"); font = Content.Load<SpriteFont>("SpelFont"); font2 = Content.Load<SpriteFont>("SpriteFont1"); font3 = Content.Load<SpriteFont>("SpriteFont2"); playButton = Content.Load<Texture2D>("Play"); optionsButton = Content.Load<Texture2D>("Options"); backButton = Content.Load<Texture2D>("Back"); polytris = Content.Load<Texture2D>("Polytris"); grid = new TetrisGrid(block); level = 1; levelspeed = 1; score = 0; i = (int)random.Next(7) + 1; i2 = (int)random.Next(7) + 1; blockcounter = 1; blocks = new BlockList(block, Content); //Voegen de verschillende blockobjecten toe aan de lijst block1 = new Block1(block, Content); blocks.Add(block1, 1); block2 = new Block2(block, Content); blocks.Add(block2, 2); block3 = new Block3(block, Content); blocks.Add(block3, 3); block4 = new Block4(block, Content); blocks.Add(block4, 4); block5 = new Block5(block, Content); blocks.Add(block5, 5); block6 = new Block6(block, Content); blocks.Add(block6, 6); block7 = new Block7(block, Content); blocks.Add(block7, 7); //Voegen de verschillende blockobjecten toe aan een tweede lijst voor het tekenen van het volgende blokje block1res = new Block1(block, Content); blocks.AddToReserve(block1res, 1); block2res = new Block2(block, Content); blocks.AddToReserve(block2res, 2); block3res = new Block3(block, Content); blocks.AddToReserve(block3res, 3); block4res = new Block4(block, Content); blocks.AddToReserve(block4res, 4); block5res = new Block5(block, Content); blocks.AddToReserve(block5res, 5); block6res = new Block6(block, Content); blocks.AddToReserve(block6res, 6); block7res = new Block7(block, Content); blocks.AddToReserve(block7res, 7); options = new Options(block, reset, backButton, width, height, font, blocks); menu = new Menu(playButton, optionsButton, polytris, width, height); gameOver = new GameOver(backButton, width, height); }
public Pattern(int blockId, int metadata) { BlockList.Add(new BlockDataEntry() { Id = (byte)blockId, Metadata = (byte)metadata, HasMetadata = true }); OriginalPattern = $"{blockId}:{metadata}"; }
public double Run(double[] data, int detailLevel) { var sb = new StringBuilder(); for (int i = 0; i < data.Length; i++) { sb.Append(data[i]); if (i < data.Length - 1) sb.Append(","); } string datastring = sb.ToString(); var textBlock = new ImportFromTextBlock { Text = datastring, ColumnSeparator = ",", SignalStart = 0, SignalNameInFirstColumn = false }; var dwtBlock = new DWTBlock { WaveletName = "db10", Level = detailLevel, ExtensionMode = SignalExtension.ExtensionMode.ZeroPadding }; var b = new BlockList(); b.Add(textBlock); b.Add(dwtBlock); textBlock.ConnectTo(dwtBlock); b.ExecuteAll(); int length = dwtBlock.OutputNodes[dwtBlock.OutputNodes.Count-1].Object[detailLevel - 1].Samples.Length; double val = dwtBlock.OutputNodes[dwtBlock.OutputNodes.Count-1].Object[detailLevel - 1].Samples[length - 1]; return val; }
public virtual void TestAddRejectsBadIndexes() { BlockList<int> list = new BlockList<int>(4); list.AddItem(Sharpen.Extensions.ValueOf(41)); try { list.Add(-1, Sharpen.Extensions.ValueOf(42)); } catch (IndexOutOfRangeException badIndex) { NUnit.Framework.Assert.AreEqual((-1).ToString(), badIndex.Message); } try { list.Add(4, Sharpen.Extensions.ValueOf(42)); } catch (IndexOutOfRangeException badIndex) { NUnit.Framework.Assert.AreEqual(4.ToString(), badIndex.Message); } }
public static List<double> FFTTransform(List<double> serie) { //Declaring the blocks var inputSeriesBlock = new InputSeriesBlock(); inputSeriesBlock.SetSeries(serie); var outputSeriesBlock = new OutputSeriesBlock(); var fFTBlock = new FFTBlock { Mode = ManagedFFTModeEnum.UseLookupTable }; //Connecting the blocks inputSeriesBlock.OutputNodes[0].ConnectTo(fFTBlock.InputNodes[0]); fFTBlock.OutputNodes[1].ConnectTo(outputSeriesBlock.InputNodes[0]); //Appending the blocks to a block list and execute all var blockList = new BlockList(); blockList.Add(inputSeriesBlock); blockList.Add(fFTBlock); blockList.Add(outputSeriesBlock); blockList.ExecuteAll(); return outputSeriesBlock.GetSeries(); }
private bool ExtractInitData(string s) { string[] delim = { "var initData = {};", "initData.globalLocale =" }; string[] delim2 = { "initData." }; string[] delim3 = { " = " }; char[] delim4 = { ' ', ';', '\n', ' '}; string[] s1 = s.Split(delim, StringSplitOptions.None); if (s1.Length < 3) { return(false); } string s2 = s1[1]; string[] datum = s2.Split(delim2, StringSplitOptions.RemoveEmptyEntries); string product = datum[1].Split(delim3, StringSplitOptions.None)[1]; string meta = datum[2].Split(delim3, StringSplitOptions.None)[1]; string grade = datum[3].Split(delim3, StringSplitOptions.None)[1]; product = product.TrimEnd(delim4); meta = meta.TrimEnd(delim4); grade = grade.TrimEnd(delim4); _product = JsonConvert.DeserializeObject <Product>(product); _meta = JsonConvert.DeserializeObject <Meta>(meta); _grades = JsonConvert.DeserializeObject <Grade[]>(grade); GradeList.Clear(); BlockList.Clear(); Grade defaultGrade = new Grade(); defaultGrade.gradeId = 0; defaultGrade.name = "전체"; Meta.Draw.BlockInfo defaultBlock = new Meta.Draw.BlockInfo(); defaultBlock.blockId = 0; defaultBlock.blockName = "전체"; GradeList.Add(defaultGrade); BlockList.Add(defaultBlock); foreach (Grade item in _grades) { GradeList.Add(item); } foreach (Meta.Draw.BlockInfo item in _meta.draw.blockInfo) { BlockList.Add(item); } return(true); }
//Add Block to List public void AddBlock(Block block, bool sync = false) { if (sync) { BlockList.Add(block); } else { block.PreviousHash = GetLatestBlock().Hash; block.Mining(DiffString); block.Index = BlockList.Count; BlockList.Add(block); } }
public void OpenFileByPath(string filename) { try { Cursor = Cursors.WaitCursor; if (!Path.IsPathRooted(filename)) { filename = Path.Combine(WaveletStudio.Utils.AssemblyDirectory, filename); } var documentModel = new DocumentSerializer().Load(filename); documentModel.OnSaveChanged = OnSavedChanged; var diagramForm = Designer.Document.Elements.Count > 0 ? new DiagramForm() : this; diagramForm.Cursor = Cursors.WaitCursor; diagramForm.DocumentModel = documentModel; diagramForm.Designer.SetDocument(documentModel.Document); diagramForm.CurrentFile = filename; diagramForm.Show(); diagramForm.Focus(); diagramForm.ConfigureDesigner(); diagramForm.ZoomTrackBar.Value = Convert.ToInt32(Designer.Document.Zoom * 10); AddRecentFile(filename, diagramForm.Designer); var blockList = new BlockList(); foreach (var element in diagramForm.Designer.Document.Elements) { if (element is DiagramBlock == false) { continue; } var block = (BlockBase)((DiagramBlock)element).State; block.CurrentDirectory = CurrentDirectory; blockList.Add(block); } blockList.ExecuteAll(); diagramForm.Cursor = Cursors.Default; } catch (Exception exception) { MessageBox.Show(string.Format("{0}:{1}{2}", DesignerResources.FileCouldntBeOpened, Environment.NewLine, exception.Message), DesignerResources.Error, MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { Cursor = Cursors.Default; } }
// Returns false if any key was previously used or is not relesed public static bool AllKeysReleased(params Keys[] keys) { if (keys.Any(k => BlockList.Contains(k))) { return(false); } return(keys.All(k => { if (!KeyState.IsKeyUp(k) || !PreviousKeyState.IsKeyDown(k)) { return false; } BlockList.Add(k); return true; })); }
// Returns false if all keys were previously used or are down public static bool AnyKeysUp(params Keys[] keys) { if (keys.All(k => BlockList.Contains(k))) { return(false); } return(keys.Any(k => { if (!KeyState.IsKeyUp(k)) { return true; } BlockList.Add(k); return false; })); }
public override void Refresh() { CheckRunningStatus(); ResultList.Clear(); TargetProject.ResultList.ForEach(v => ResultList.Add(new InstrumentViewModel() { TargetObject = v, GetCurrentDataSource = () => { return(CurrentDataSource); } })); BlockList.Clear(); TargetProject.BlockList.ForEach(v => BlockList.Add(new InstrumentViewModel() { TargetObject = v, GetCurrentDataSource = () => { return(CurrentDataSource); } })); OnPropertyChanged("FinishPercent"); OnPropertyChanged("IsRunning"); OnPropertyChanged("ProcessInfo"); OnPropertyChanged("CanStart"); OnPropertyChanged("CanPause"); OnPropertyChanged("CanStop"); base.Refresh(); }
private IReadOnlyList <TryCatchBlock> TranslateSehBlocks(IMethod method, IMethodContext context, IList <SEHBlock> blocks, ILStream code) { var list = new List <TryCatchBlock>(); var handlers = new BlockList(); TryCatchBlock tryBlock = null; int n = blocks.Count; for (int i = 0; i < n; ++i) { var block = blocks[i]; tryBlock = EnshureTryBlock(blocks, i, tryBlock, code, block, list); var handler = CreateHandlerBlock(method, context, code, block); int entryIndex = code.GetOffsetIndex(block.HandlerOffset); int exitIndex = GetIndex(code, block.HandlerOffset, block.HandlerLength); handler.EntryPoint = code[entryIndex]; handler.ExitPoint = code[exitIndex]; tryBlock.Handlers.Add(handler); handlers.Add(handler); } //set parents for (int i = 0; i < list.Count; ++i) { var block = list[i]; var parent = FindParent(list, block); if (parent != null) { parent.Add(block); list.RemoveAt(i); --i; } } foreach (var block in list) { SetupInstructions(code, block); } return(list.AsReadOnlyList()); }
public Expression DecompileBooleanExpression(BlockExpression be) { if (be == null) { return(null); } TypeReconstructorAndExpressionSimplifier tr = new TypeReconstructorAndExpressionSimplifier(); be = tr.VisitBlockExpression(be) as BlockExpression; if (be == null) { return(null); } Block b = be.Block; #region Make sure the block expression has the right shape foreach (Statement s in b.Statements) { Block b_prime = s as Block; Debug.Assert(b_prime != null); Debug.Assert(HelperMethods.IsBasicBlock(b_prime)); } #endregion Block firstBlock = (Block)b.Statements[0]; block2Index = new TrivialHashtable(b.Statements.Count); blocks = new BlockList(b.Statements.Count); for (int i = 0, n = b.Statements.Count; i < n; i++) { block2Index[b.Statements[i].UniqueKey] = i; blocks.Add(b.Statements[i] as Block); } Expression e = DecompileBooleanExpression(firstBlock); // BUGBUG: this isn't a good place to do this because then it gets done for all contracts, // not just postconditions!! Plus, we could just leave Result in the contracts and let the // BPL translation recognize it. //ReplaceResult repResult = new ReplaceResult(this.localToUseForResult, this.contractNodes.ResultTemplate, // this.contractNodes.ParameterTemplate); //e = repResult.VisitExpression(e); return(e); }
public override void LoadInfo() { if (TargetProject == null) { return; } ConditionList.Clear(); TargetProject.ConditionList.ForEach(v => ConditionList.Add(new ConditionViewModel() { TargetObject = v })); PredicateList.Clear(); TargetProject.PredicateList.ForEach(v => PredicateList.Add(new ConditionViewModel() { TargetObject = v })); InstrumentList.Clear(); TargetProject.InstrumentList.ForEach(v => InstrumentList.Add(v)); ResultList.Clear(); TargetProject.ResultList.ForEach(v => ResultList.Add(new InstrumentViewModel() { TargetObject = v, GetCurrentDataSource = () => { return(CurrentDataSource); } })); TargetProject.BlockList.ForEach(v => BlockList.Add(new InstrumentViewModel() { TargetObject = v, GetCurrentDataSource = () => { return(CurrentDataSource); } })); CurrentDataSource = TargetProject.CurrentDataSource; IsChanged = false; if (TargetSummaryVM != null) { TargetSummaryVM.Refresh(); } }
/// <summary> /// Adds the child block. /// </summary> /// <param name="kid">The block to add as child.</param> public void Add(Block kid) { kid.Parent = this; _kids.Add(kid); }
public virtual void TestAddSlowPath() { BlockList<string> list = new BlockList<string>(4); string fooStr = "foo"; string barStr = "bar"; string foobarStr = "foobar"; string firstStr = "first"; string zeroStr = "zero"; list.AddItem(fooStr); list.AddItem(barStr); list.AddItem(foobarStr); NUnit.Framework.Assert.AreEqual(3, list.Count); list.Add(1, firstStr); NUnit.Framework.Assert.AreEqual(4, list.Count); NUnit.Framework.Assert.AreSame(fooStr, list[0]); NUnit.Framework.Assert.AreSame(firstStr, list[1]); NUnit.Framework.Assert.AreSame(barStr, list[2]); NUnit.Framework.Assert.AreSame(foobarStr, list[3]); list.Add(0, zeroStr); NUnit.Framework.Assert.AreEqual(5, list.Count); NUnit.Framework.Assert.AreSame(zeroStr, list[0]); NUnit.Framework.Assert.AreSame(fooStr, list[1]); NUnit.Framework.Assert.AreSame(firstStr, list[2]); NUnit.Framework.Assert.AreSame(barStr, list[3]); NUnit.Framework.Assert.AreSame(foobarStr, list[4]); }
/// <summary> /// Called once after we handled all blocks (by MakeFlat) /// </summary> private void AdjustBranches() { for (int i = 0; i<this.branchInstructions.Count; i++) { Branch branch = (Branch)this.branchInstructions[i]; branch.Target = RemapBlock(branch.Target); } // Clone target list for (int i = 0; i<this.switchInstructions.Count; i++) { SwitchInstruction sw = (SwitchInstruction)this.switchInstructions[i]; BlockList targets = sw.Targets; BlockList newTargets = new BlockList(targets.Count); sw.Targets = newTargets; for (int j = 0; j<targets.Count; j++) { Block b = targets[j]; newTargets.Add(RemapBlock(b)); } } }
public static void Add(Block block) { BlockList.Add(block); }
public void Add() { Current = new HttpChunk(); BlockList.Add(Current); }
/// <summary> /// Creates a block containing the given tryBlock and catchBlocks and /// returns it. The method is modified by having new ExceptionHandlers /// added to it which points to the right places in the blocks. /// The type of exception caught by each catch block should be the type /// of the corresponding local l. /// </summary> /// <param name="m">The method in which the try-catch block will be /// inserted into.</param> /// <param name="tryBody">A block of statements that will be the body /// of the try-catch statement.</param> /// <param name="catchBodies">A sequence of blocks; each one contains the /// statements that will be the body of a catch clause on the try-catch statement. /// </param> /// <param name="l">The local into which the exception will be /// assigned. Presumably, the body of the catch clause does something /// with this local.</param> /// <returns>A single block which must be inserted into m by the client. /// </returns> internal static Block CreateTryCatchBlock(Method m, Block tryBody, Block catchBody, Local l) { BlockList bs = new BlockList(1); bs.Add(catchBody); LocalList ls = new LocalList(1); ls.Add(l); return CreateTryCatchBlock(m, tryBody, bs, ls); }
public override Method VisitMethod(Method method) { if (method == null) return null; if (method.IsNormalized) return method; if (method.CciKind != CciMemberKind.Regular) { method.Attributes.Add(new AttributeNode(new MemberBinding(null, SystemTypes.CciMemberKindAttribute.GetConstructor(SystemTypes.CciMemberKind)), new ExpressionList(new Literal(method.CciKind, SystemTypes.CciMemberKind)), AttributeTargets.Method)); } method.IsNormalized = true; method.Attributes = this.VisitAttributeList(method.Attributes); if (method.ReturnAttributes == null) method.ReturnAttributes = new AttributeList(); else method.ReturnAttributes = this.VisitAttributeList(method.ReturnAttributes); AttributeList al = this.ExtractAttributes(method.Attributes, AttributeTargets.ReturnValue); for (int i = 0, n = al == null ? 0 : al.Count; i < n; i++){ method.ReturnAttributes.Add(al[i]); } method.SecurityAttributes = this.VisitSecurityAttributeList(method.SecurityAttributes); if (method.Attributes != null && method.Attributes.Count > 0) { SecurityAttributeList secAttrs = method.SecurityAttributes; this.ExtractSecurityAttributes(method.Attributes, ref secAttrs); method.SecurityAttributes = secAttrs; } if (method.SecurityAttributes != null && method.SecurityAttributes.Count > 0) method.Flags |= MethodFlags.HasSecurity; Method savedMethod = this.currentMethod; This savedThisParameter = this.currentThisParameter; Local savedReturnLocal = this.currentReturnLocal; Block savedReturnLabel = this.currentReturnLabel; Local savedClosureLocal = this.currentClosureLocal; Block savedContractPrelude = this.currentContractPrelude; BlockList savedContractExceptionalTerminationChecks = this.currentContractExceptionalTerminationChecks; Local savedcurrentExceptionalTerminationException = this.currentExceptionalTerminationException; Block savedContractNormalTerminationCheck = this.currentContractNormalTerminationCheck; Block savedParentBlock = null; this.currentMethod = method; this.currentThisParameter = method.ThisParameter; if (method.ThisParameter != null) { method.ThisParameter.DeclaringMethod = method; if (method.DeclaringType != null && method.DeclaringType.IsValueType) method.ThisParameter.Type = method.DeclaringType.GetReferenceType(); } this.currentReturnLabel = new Block(new StatementList()); this.currentClosureLocal = null; this.currentContractPrelude = new Block(new StatementList()); this.currentContractExceptionalTerminationChecks = new BlockList(); this.currentExceptionalTerminationException = new Local(Identifier.For("SS$caught_exception"), SystemTypes.Exception); this.currentContractNormalTerminationCheck = new Block(new StatementList()); if (TypeNode.StripModifiers(method.ReturnType) == SystemTypes.Void) this.currentReturnLocal = null; else this.currentReturnLocal = new Local(Identifier.For("return value"), method.ReturnType); method.Parameters = this.VisitParameterList(method.Parameters); method.TemplateArguments = this.VisitTypeReferenceList(method.TemplateArguments); method.TemplateParameters = this.VisitTypeParameterList(method.TemplateParameters); TypeNodeList tpars = method.TemplateParameters; if (!method.IsGeneric){ for (int i = 0, n = tpars == null ? 0 : tpars.Count; i < n; i++){ TypeNode tpar = tpars[i]; if (tpar == null) continue; tpar.Name = new Identifier(method.Name+":"+tpar.Name, tpar.SourceContext); tpar.DeclaringType = method.DeclaringType; method.DeclaringType.Members.Add(tpar); } } if (method.Template == null) { // skip this part for instance methods. Block closureInit = null; bool methodHasClosure = method.Scope != null && method.Scope.CapturedForClosure; if (methodHasClosure) this.SetUpClosureClass(method); // Normalizer.VisitRequiresList needs to be called in case it wants to generate // some default preconditions (that are not injected by Checker in order to not // have these preconditions seen by any static checking tools). If there is // no contract on this method, then it won't get called, so create a dummy // contract and Requires list just so it will get a chance to do its stuff. if (method.Contract == null) { method.Contract = new MethodContract(method); method.Contract.Requires = new RequiresList(); } if (!methodHasClosure || (method is InstanceInitializer)) { // ctors will construct the closure class instance after they call another ctor, since they need to pass in "this" as a parameter to the closure class constructor method.Contract = this.VisitMethodContract(method.Contract); method.Body = this.VisitBlock(method.Body); }else{ method.Contract = this.VisitMethodContract(method.Contract); Block b = this.CreateClosureClassInstance(method); method.Body = this.VisitBlock(method.Body); savedParentBlock = method.Body; closureInit = b; if (method.Body != null){ closureInit.SourceContext = method.Body.SourceContext; method.Body.HasLocals = true; } } { #region If this method has a contract, then modify its body to add the contracts at the right point if (method.Body != null && method.Body.Statements != null){ if (this.currentContractExceptionalTerminationChecks.Count > 0){ // then wrap the body into a try catch with these checks as the catch blocks Block b = new Block(new StatementList(this.currentContractExceptionalTerminationChecks.Count)); b.HasLocals = true; for (int i = 0, n = this.currentContractExceptionalTerminationChecks.Count; i < n; i++) { b.Statements.Add(this.currentContractExceptionalTerminationChecks[i]); } #region Rethrow caught exception // last "functional" thing in the block is re-throw whatever exception we caught. Throw t = new Throw(); t.NodeType = NodeType.Rethrow; b.Statements.Add(t); #endregion LocalList ls = new LocalList(1); this.currentExceptionalTerminationException.DeclaringBlock = b; ls.Add(this.currentExceptionalTerminationException); BlockList bs = new BlockList(1); bs.Add(b); Block newBody = CreateTryCatchBlock(method, method.Body, bs, ls); //Block newBody = CreateTryCatchBlock(method,method.Body,this.currentContractExceptionalTerminationChecks,this.currentContractExceptionalLocals); method.Body = newBody; } if (this.currentContractPrelude.Statements.Count > 0){ Block newBody = new Block(new StatementList(3)); // Wrap the contract prelude in a block with a dummy catch block. // It has a special handler type that lets downstream tools know // this block was not part of the original code. Throw t = new Throw(); t.NodeType = NodeType.Rethrow; this.currentContractPrelude = CreateTryCatchBlock( method, this.currentContractPrelude, // try body new Block(new StatementList(t)), // catch: just rethrow new Local(Identifier.For("SS$Contract Marker"), SystemTypes.ContractMarkerException) ); newBody.Statements.Add(closureInit); closureInit = null; newBody.Statements.Add(this.currentContractPrelude); newBody.Statements.Add(method.Body); method.Body = newBody; } } } #endregion if (closureInit != null){ closureInit.Statements.Add(method.Body); method.Body = closureInit; } if (method.Body != null && method.Body.Statements != null){ Return r = new Return(); r.Expression = this.currentReturnLocal; Block returnBlock = new Block(new StatementList()); returnBlock.Statements.Add(this.currentReturnLabel); { InstanceInitializer ctor = method as InstanceInitializer; if (ctor != null && method.DeclaringType.Contract != null && method.DeclaringType.Contract.FrameField != null && !ctor.IsDeferringConstructor){ // then add a Pack to the end // BUGBUG: if the programmer has indicated that this default shouldn't apply, then don't do this! SourceContext rightBrace = new SourceContext(method.SourceContext.Document, method.SourceContext.EndPos - 1, method.SourceContext.EndPos); returnBlock.Statements.Add( new ExpressionStatement( new MethodCall(new MemberBinding(new MethodCall(new MemberBinding(method.ThisParameter, method.DeclaringType.Contract.FramePropertyGetter), null, NodeType.Call, OptionalModifier.For(SystemTypes.NonNullType, SystemTypes.Guard)), SystemTypes.Guard.GetMethod(Identifier.For("EndWriting"))), null, NodeType.Call, SystemTypes.Void), rightBrace )); } if (this.currentContractNormalTerminationCheck.Statements.Count > 0){ // Wrap the contract normal termination checks in a block with a dummy catch block. // It has a special handler type that lets downstream tools know this block was not // part of the original code. Throw t = new Throw(); t.NodeType = NodeType.Rethrow; this.currentContractNormalTerminationCheck = CreateTryCatchBlock( method, this.currentContractNormalTerminationCheck, // try body new Block(new StatementList(t)), // catch: just rethrow new Local(Identifier.For("SS$Contract Marker"),SystemTypes.ContractMarkerException) ); returnBlock.Statements.Add(this.currentContractNormalTerminationCheck); } } if (this.currentReturnLocal != null){ Local displayReturnLocal = new Local(Identifier.For("SS$Display Return Local"), method.ReturnType); returnBlock.Statements.Add(new AssignmentStatement(displayReturnLocal, this.currentReturnLocal)); returnBlock.HasLocals = true; } returnBlock.Statements.Add(r); if (method.Body.SourceContext.Document != null){ r.SourceContext = method.SourceContext; r.SourceContext.StartPos = method.Body.SourceContext.EndPos-1; } if (savedParentBlock != null){ if (savedParentBlock.Statements == null) savedParentBlock.Statements = new StatementList(1); savedParentBlock.Statements.Add(returnBlock); }else method.Body.Statements.Add(returnBlock); } if (method.ImplementedInterfaceMethods != null && method.ImplementedInterfaceMethods.Count > 0 && method.ImplementedInterfaceMethods[0] != null){ string typeName = method.ImplementedInterfaceMethods[0].DeclaringType.GetFullUnmangledNameWithTypeParameters(); method.Name = new Identifier(typeName + "." + method.Name.ToString(), method.Name.SourceContext); } if (method.HasCompilerGeneratedSignature && method.Parameters != null){ if (method.Parameters.Count == 1 && (method.Parameters[0].Attributes == null || method.Parameters[0].Attributes.Count == 0)) method.Parameters[0].Attributes = this.ExtractAttributes(method.Attributes, AttributeTargets.Parameter); else if (method.Parameters.Count == 2 && (method.Parameters[1].Attributes == null || method.Parameters[1].Attributes.Count == 0)) method.Parameters[1].Attributes = this.ExtractAttributes(method.Attributes, AttributeTargets.Parameter); } } this.currentMethod = savedMethod; this.currentThisParameter = savedThisParameter; this.currentReturnLocal = savedReturnLocal; this.currentReturnLabel = savedReturnLabel; this.currentClosureLocal = savedClosureLocal; this.currentContractPrelude = savedContractPrelude; this.currentContractExceptionalTerminationChecks = savedContractExceptionalTerminationChecks; this.currentExceptionalTerminationException = savedcurrentExceptionalTerminationException; this.currentContractNormalTerminationCheck = savedContractNormalTerminationCheck; return method; }
private List<double> processOneSeries(List<double> serie) { //Declaring the blocks var inputSeriesBlock = new InputSeriesBlock(); inputSeriesBlock.SetSeries(serie); var dWTBlock = new DWTBlock { WaveletName = "Daubechies 10 (db10)", Level = 1, Rescale = false, ExtensionMode = WaveletStudio.SignalExtension.ExtensionMode.AntisymmetricWholePoint }; var outputSeriesBlock = new OutputSeriesBlock(); //Connecting the blocks inputSeriesBlock.OutputNodes[0].ConnectTo(dWTBlock.InputNodes[0]); dWTBlock.OutputNodes[1].ConnectTo(outputSeriesBlock.InputNodes[0]); //Appending the blocks to a block list and execute all var blockList = new BlockList(); blockList.Add(inputSeriesBlock); blockList.Add(dWTBlock); blockList.Add(outputSeriesBlock); blockList.ExecuteAll(); return outputSeriesBlock.GetSeries(); }
public virtual Differences VisitBlockList(BlockList list1, BlockList list2, out BlockList changes, out BlockList deletions, out BlockList insertions){ changes = list1 == null ? null : list1.Clone(); deletions = list1 == null ? null : list1.Clone(); insertions = list1 == null ? new BlockList() : list1.Clone(); //^ assert insertions != null; Differences differences = new Differences(); for (int j = 0, n = list2 == null ? 0 : list2.Count; j < n; j++){ //^ assert list2 != null; Block nd2 = list2[j]; if (nd2 == null) continue; insertions.Add(null); } TrivialHashtable savedDifferencesMapFor = this.differencesMapFor; this.differencesMapFor = null; TrivialHashtable matchedNodes = new TrivialHashtable(); for (int i = 0, k = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){ //^ assert list1 != null && changes != null && deletions != null; Block nd1 = list1[i]; if (nd1 == null) continue; Differences diff; int j; Block nd2 = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out diff, out j); if (nd2 == null || diff == null){Debug.Assert(nd2 == null && diff == null); continue;} matchedNodes[nd1.UniqueKey] = nd1; matchedNodes[nd2.UniqueKey] = nd2; changes[i] = diff.Changes as Block; deletions[i] = diff.Deletions as Block; insertions[i] = diff.Insertions as Block; insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation Debug.Assert(diff.Changes == changes[i] && diff.Deletions == deletions[i] && diff.Insertions == insertions[i]); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; } //Find deletions for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){ //^ assert list1 != null && changes != null && deletions != null; Block nd1 = list1[i]; if (nd1 == null) continue; if (matchedNodes[nd1.UniqueKey] != null) continue; changes[i] = null; deletions[i] = nd1; insertions[i] = null; differences.NumberOfDifferences += 1; } //Find insertions for (int j = 0, n = list1 == null ? 0 : list1.Count, m = list2 == null ? 0 : list2.Count; j < m; j++){ //^ assert list2 != null; Block nd2 = list2[j]; if (nd2 == null) continue; if (matchedNodes[nd2.UniqueKey] != null) continue; insertions[n+j] = nd2; //Records nd2 as an insertion into list1, along with its position in list2 differences.NumberOfDifferences += 1; //REVIEW: put the size of the tree here? } if (differences.NumberOfDifferences == 0){ changes = null; deletions = null; insertions = null; } this.differencesMapFor = savedDifferencesMapFor; return differences; }
protected virtual Expression CoerceFromTypeUnion(Expression source, TypeUnion sourceType, TypeNode targetType, bool explicitCoercion, TypeNode originalTargetType, TypeViewer typeViewer){ if (source == null || sourceType == null || targetType == null) return null; if (targetType == SystemTypes.Object) return this.CoerceTypeUnionToObject(source, typeViewer); int cErrors = (this.Errors != null) ? this.Errors.Count : 0; if (explicitCoercion){ Method coercion = this.UserDefinedExplicitCoercionMethod(source, sourceType, targetType, false, originalTargetType, typeViewer); if (coercion != null && coercion.ReturnType == targetType && coercion.Parameters != null && coercion.Parameters[0] != null && this.ImplicitCoercionFromTo(sourceType, coercion.Parameters[0].Type, typeViewer)) return this.ImplicitCoercion(new MethodCall(new MemberBinding(null, coercion), new ExpressionList(source), NodeType.Call, coercion.ReturnType), targetType, typeViewer); } Method getTag = TypeViewer.GetTypeView(typeViewer, sourceType).GetMethod(StandardIds.GetTag); if (getTag == null) return null; Method getValue = TypeViewer.GetTypeView(typeViewer, sourceType).GetMethod(StandardIds.GetValue); if (getValue == null) return null; Local src = new Local(sourceType); Local srcOb = new Local(SystemTypes.Object, source.SourceContext); Local tgt = new Local(targetType); Expression callGetTag = new MethodCall(new MemberBinding(new UnaryExpression(src, NodeType.AddressOf), getTag), null); Expression callGetValue = new MethodCall(new MemberBinding(new UnaryExpression(src, NodeType.AddressOf), getValue), null); TypeNodeList types = sourceType.Types; int n = types == null ? 0 : types.Count; Block endOfSwitch = new Block(); StatementList statements = new StatementList(5+n); statements.Add(new AssignmentStatement(src, source)); statements.Add(new AssignmentStatement(srcOb, callGetValue)); BlockList cases = new BlockList(n); statements.Add(new SwitchInstruction(callGetTag, cases)); bool hadCoercion = false; Block eb = new Block(new StatementList(1)); Construct c = new Construct(new MemberBinding(null, SystemTypes.InvalidCastException.GetConstructor()), null, SystemTypes.InvalidCastException); eb.Statements.Add(new Throw(c)); for (int i = 0; i < n; i++){ TypeNode t = types[i]; if (t == null) continue; if (!explicitCoercion && !this.ImplicitCoercionFromTo(t, targetType, typeViewer)) return null; Expression expr = this.ExplicitCoercion(srcOb, t, typeViewer); if (expr == null) return null; expr = this.ExplicitCoercion(expr, targetType, typeViewer); if (expr == null) { cases.Add(eb); statements.Add(eb); } else { Block b = new Block(new StatementList(2)); hadCoercion = true; expr.SourceContext = srcOb.SourceContext; b.Statements.Add(new AssignmentStatement(tgt, expr)); b.Statements.Add(new Branch(null, endOfSwitch)); cases.Add(b); statements.Add(b); } } if (this.Errors != null) { for (int ie = cErrors, ne = this.Errors.Count; ie < ne; ie++) { this.Errors[ie] = null; } } if (!hadCoercion) return null; statements.Add(endOfSwitch); statements.Add(new ExpressionStatement(tgt)); return new BlockExpression(new Block(statements)); //TODO: wrap this in a CoerceTypeUnion node so that source code can be reconstructed easily }
public virtual void BuildAxisClosureUnion(Expression source, AxisBuildState state, SwitchAccessor swa, bool yieldResult, Block block, BlockScope scope) { TypeUnion tu = source.Type as TypeUnion; Debug.Assert(tu != null, "Switch accessor must have type union"); if (!this.IsLocal(source)) { Expression loc = this.NewClosureLocal(source.Type, scope); block.Statements.Add(new AssignmentStatement(loc, source)); source = loc; } // determine type union tag and value Method mgetvalue = this.GetTypeView(tu).GetMethod(StandardIds.GetValue); MethodCall mcgetvalue = new MethodCall(new MemberBinding(source, mgetvalue), null); mcgetvalue.Type = mgetvalue.ReturnType; Local locValue = new Local(SystemTypes.Object); block.Statements.Add(new AssignmentStatement(locValue, mcgetvalue)); Method mgettag = this.GetTypeView(tu).GetMethod(StandardIds.GetTag); MethodCall mcgettag = new MethodCall(new MemberBinding(source, mgettag), null); mcgettag.Type = mgettag.ReturnType; Local locTag = new Local(SystemTypes.UInt32); block.Statements.Add(new AssignmentStatement(locTag, mcgettag)); // switch on type union tag BlockList blocks = new BlockList(swa.Accessors.Count); Block endBlock = new Block(null); foreach( int id in swa.Accessors.Keys ) { Accessor acc = (Accessor) swa.Accessors[id]; Block caseBlock = new Block(new StatementList(3)); blocks.Add(caseBlock); block.Statements.Add(new Branch(new BinaryExpression(locTag, new Literal(id, SystemTypes.Int32), NodeType.Eq), caseBlock)); Expression locvar = this.NewClosureLocal(swa.Type.Types[id], scope); caseBlock.Statements.Add(new AssignmentStatement(locvar, this.Unbox(locValue, locvar.Type))); this.BuildAxisClosureExpression(locvar, state, acc, yieldResult, caseBlock, scope); caseBlock.Statements.Add(new Branch(null, endBlock)); } block.Statements.Add(new Branch(null, endBlock)); for( int i = 0, n = blocks.Count; i < n; i++ ) { block.Statements.Add(blocks[i]); } block.Statements.Add(endBlock); }
public virtual void VisitTypeswitchCaseList(TypeswitchCaseList oldCases, BlockList targets, StatementList statements, Block nextStatement, Local temp){ for (int i = 0, n = oldCases.Count; i < n; i++){ TypeswitchCase tcase = oldCases[i]; StatementList stats = new StatementList(3); Block b = new Block(stats); if (tcase != null){ Expression expr = null; if (tcase.LabelType.IsValueType) expr = new AddressDereference(new BinaryExpression(temp, new Literal(tcase.LabelType, SystemTypes.Type), NodeType.Unbox), tcase.LabelType); else expr = new BinaryExpression(temp, new Literal(tcase.LabelType, SystemTypes.Type), NodeType.Castclass); stats.Add(new AssignmentStatement(this.VisitTargetExpression(tcase.LabelVariable), expr)); stats.Add(this.VisitBlock(tcase.Body)); } stats.Add(new Branch(null, nextStatement)); statements.Add(b); targets.Add(b); } }
public void Spawn(IBlock spawnable) { BlockList.Add(spawnable); }
public virtual void TestAddToEnd() { BlockList<int> list = new BlockList<int>(4); int cnt = BlockList<int>.BLOCK_SIZE * 3; for (int i = 0; i < cnt; i++) { list.AddItem(Sharpen.Extensions.ValueOf(42 + i)); } NUnit.Framework.Assert.AreEqual(cnt, list.Count); for (int i_1 = 0; i_1 < cnt; i_1++) { NUnit.Framework.Assert.AreEqual(Sharpen.Extensions.ValueOf(42 + i_1), list[i_1]); } list.Clear(); NUnit.Framework.Assert.AreEqual(0, list.Count); NUnit.Framework.Assert.IsTrue(list.IsEmpty()); for (int i_2 = 0; i_2 < cnt; i_2++) { list.Add(i_2, Sharpen.Extensions.ValueOf(42 + i_2)); } NUnit.Framework.Assert.AreEqual(cnt, list.Count); for (int i_3 = 0; i_3 < cnt; i_3++) { NUnit.Framework.Assert.AreEqual(Sharpen.Extensions.ValueOf(42 + i_3), list[i_3]); } }
private SwitchInstruction ParseSwitchInstruction() { int numTargets = this.GetInt32(); int offset = this.counter + numTargets * 4; BlockList targetList = new BlockList(); for(int i = 0; i < numTargets; i++) { int targetAddress = this.GetInt32() + offset; targetList.Add(Reader.GetOrCreateBlock(this.blockMap, targetAddress)); } return new SwitchInstruction(PopOperand(), targetList); }
public static List<double> WaveletTransform(List<double> serie) { //Declaring the blocks var inputSeriesBlock = new InputSeriesBlock(); inputSeriesBlock.SetSeries(serie); var dWTBlock = new DWTBlock { WaveletName = "coif4", Level = 1, Rescale = false, ExtensionMode = SignalExtension.ExtensionMode.AntisymmetricWholePoint }; var outputSeriesBlock = new OutputSeriesBlock(); //Connecting the blocks inputSeriesBlock.OutputNodes[0].ConnectTo(dWTBlock.InputNodes[0]); // dWTBlock.OutputNodes[1].ConnectTo(dWTBlock2.InputNodes[0]); dWTBlock.OutputNodes[1].ConnectTo(outputSeriesBlock.InputNodes[0]); //Appending the blocks to a block list and execute all var blockList = new BlockList(); blockList.Add(inputSeriesBlock); blockList.Add(dWTBlock); //blockList.Add(dWTBlock2); blockList.Add(outputSeriesBlock); blockList.ExecuteAll(); return outputSeriesBlock.GetSeries(); }
public virtual BlockList VisitBlockList(BlockList blockList, BlockList changes, BlockList deletions, BlockList insertions){ if (changes == null || deletions == null || insertions == null) return blockList; int n = blockList == null ? 0 : blockList.Count; if (n > changes.Count){Debug.Assert(false); n = changes.Count;} if (n > deletions.Count){Debug.Assert(false); n = deletions.Count;} if (n > insertions.Count){Debug.Assert(false); n = insertions.Count;} if (blockList != null) for (int i = 0; i < n; i++) blockList[i] = this.VisitBlock(blockList[i], changes[i], deletions[i], insertions[i]); BlockList result = new BlockList(insertions.Count-n); for (int i = n, m = insertions.Count; i < m; i++) result.Add(insertions[i]); return result; }
public virtual void Deserialize(Player player, string currentPattern) { // See documentation: https://worldedit.enginehub.org/en/latest/usage/general/patterns/ if (currentPattern.StartsWith("x")) { currentPattern = currentPattern.Remove(0, 1); // remove starting x } OriginalPattern = currentPattern.Trim(); var patternsEx = new Regex(@",(?![^\[]*])"); foreach (string pattern in patternsEx.Split(currentPattern.Trim())) { Log.Debug($"Matching {pattern}"); var blockDataEntry = new BlockDataEntry(); var regex = new Regex(@"(?<pattern>((?<weight>\d+)%)?((?<blockId>\d+)|(?<blockName>(minecraft:)?\w+)){1}(:(?<meta>\d+))?(\[(?<states>[a-zA-Z0-9_=,]*)])?)*"); var stateEx = new Regex(@"(?<name>\w+)\=(?<value>\w+)"); Match match = regex.Match(pattern.Trim()); if (match.Success) { foreach (Group matchGroup in match.Groups) { if (matchGroup.Name == "weight" && matchGroup.Success) { Log.Debug($"Matched weight group {matchGroup.Value}"); if (int.TryParse(matchGroup.Value.Trim(), out int weight)) { blockDataEntry.Weight = weight; } } else if (matchGroup.Name == "blockName" && matchGroup.Success) { Log.Debug($"Matched blockName group {matchGroup.Value}"); blockDataEntry.Id = BlockFactory.GetBlockIdByName(matchGroup.Value.Trim()); } if (matchGroup.Name == "blockId" && matchGroup.Success) { Log.Debug($"Matched blockId group {matchGroup.Value}"); if (int.TryParse(matchGroup.Value.Trim(), out int id)) { blockDataEntry.Id = id; } } else if (matchGroup.Name == "meta" && matchGroup.Success) { Log.Debug($"Matched meta group {matchGroup.Value}"); if (byte.TryParse(matchGroup.Value.Trim(), out byte metadata)) { blockDataEntry.Metadata = metadata; blockDataEntry.HasBlockStates = true; } } else if (matchGroup.Name == "states" && matchGroup.Success) { Log.Debug($"Matched states group {matchGroup.Value}"); // Parse block states var stateMatches = stateEx.Matches(matchGroup.Value.Trim()); { foreach (Match stateMatch in stateMatches) { Log.Debug($"State:{stateMatch.Value}"); blockDataEntry.BlockStates.Add(new BlockStateEntry() { Name = stateMatch.Groups.Values.First(g => g.Name == "name").Value, Value = stateMatch.Groups.Values.First(g => g.Name == "value").Value }); blockDataEntry.HasBlockStates = true; } } } } } else { throw new Exception("Deprecated code used to be here."); } BlockList.Add(blockDataEntry); } int acc = 0; foreach (var entry in BlockList.OrderBy(entry => entry.Weight)) { acc += entry.Weight; entry.Accumulated = acc; } BlockList = BlockList.OrderBy(entry => entry.Accumulated).ToList(); }