protected void AddMetadataBlock(long start, long length) { MetadataBlock new_block = new MetadataBlock(start, length); for (int i = 0; i < metadata_blocks.Count; i++) { var block = metadata_blocks[i]; if (new_block.OverlapsWith(block)) { block.Add(new_block); i++; while (i < metadata_blocks.Count) { var next_block = metadata_blocks[i]; if (block.OverlapsWith(next_block)) { block.Add(next_block); metadata_blocks.Remove(next_block); } else { return; } } return; } else if (new_block.Before(block)) { metadata_blocks.Insert(i, new_block); return; } } metadata_blocks.Add(new_block); }
public bool OverlapsWith(MetadataBlock block) { if (block.Start >= Start && block.Start <= Start + Length) { return(true); } if (Start >= block.Start && Start <= block.Start + block.Length) { return(true); } return(false); }
/// <summary> /// Adds a range to be treated as metadata. /// </summary> /// <param name="start"> /// A <see cref="System.Int64"/> with the start index of the metadata block /// </param> /// <param name="length"> /// A <see cref="System.Int64"/> with the length of the metadata block /// </param> protected void AddMetadataBlock(long start, long length) { MetadataBlock new_block = new MetadataBlock(start, length); // We keep the list sorted and unique. Therefore, we add the new block to // the list and join overlapping blocks if necessary. // iterate through all existing blocks. for (int i = 0; i < metadata_blocks.Count; i++) { var block = metadata_blocks[i]; // if one block overlaps with the new one, join them. if (new_block.OverlapsWith(block)) { block.Add(new_block); // Since we joined two blocks, they may overlap with // other blocks which follows in the list. Therfore, // we iterate through the tail of the list and join // blocks which are now contained. i++; while (i < metadata_blocks.Count) { var next_block = metadata_blocks[i]; if (block.OverlapsWith(next_block)) { block.Add(next_block); metadata_blocks.Remove(next_block); } else { return; } } return; // if the new block is 'smaller' than the one in the list, // just add it to the list. } else if (new_block.Before(block)) { metadata_blocks.Insert(i, new_block); return; } } // if the new block is 'bigger' than all other blocks, at it to the end. metadata_blocks.Add(new_block); }
public void Add(MetadataBlock block) { if (block.Start >= Start && block.Start <= Start + Length) { Length = Math.Max(Length, block.Start + block.Length - Start); return; } if (Start >= block.Start && Start <= block.Start + block.Length) { Length = Math.Max(block.Length, Start + Length - block.Start); Start = block.Start; return; } throw new ArgumentException(String.Format("blocks do not overlap: {0} and {1}", this, block)); }
/// <summary> /// Adds the given block to the current instance, if this is possible. /// </summary> /// <param name="block"> /// A <see cref="MetadataBlock"/> with the block to add. /// </param> public void Add(MetadataBlock block) { if (block.Start >= Start && block.Start <= Start + Length) { Length = Math.Max(Length, block.Start + block.Length - Start); return; } if (Start >= block.Start && Start <= block.Start + block.Length) { Length = Math.Max(block.Length, Start + Length - block.Start); Start = block.Start; return; } throw new ArgumentException($"blocks do not overlap: {this} and {block}"); }
/// <summary> /// Checks, if the one block is before the other. That means, /// if the current instance ends before the given block starts. /// </summary> /// <param name="block"> /// A <see cref="MetadataBlock"/> to compare with. /// </param> /// <returns> /// A <see cref="System.Boolean"/> which is true if the current /// instance is before the given block. /// </returns> public bool Before(MetadataBlock block) { return(Start + Length < block.Start); }
/// <summary> /// Adds a range to be treated as metadata. /// </summary> /// <param name="start"> /// A <see cref="System.Int64"/> with the start index of the metadata block /// </param> /// <param name="length"> /// A <see cref="System.Int64"/> with the length of the metadata block /// </param> protected void AddMetadataBlock(long start, long length) { MetadataBlock new_block = new MetadataBlock (start, length); // We keep the list sorted and unique. Therefore, we add the new block to // the list and join overlapping blocks if necessary. // iterate through all existing blocks. for (int i = 0; i < metadata_blocks.Count; i++) { var block = metadata_blocks[i]; // if one block overlaps with the new one, join them. if (new_block.OverlapsWith (block)) { block.Add (new_block); // Since we joined two blocks, they may overlap with // other blocks which follows in the list. Therfore, // we iterate through the tail of the list and join // blocks which are now contained. i++; while (i < metadata_blocks.Count) { var next_block = metadata_blocks[i]; if (block.OverlapsWith (next_block)) { block.Add (next_block); metadata_blocks.Remove (next_block); } else { return; } } return; // if the new block is 'smaller' than the one in the list, // just add it to the list. } else if (new_block.Before (block)) { metadata_blocks.Insert (i, new_block); return; } } // if the new block is 'bigger' than all other blocks, at it to the end. metadata_blocks.Add (new_block); }
/// <summary> /// Checks if the given block overlaps with this instance. /// </summary> /// <param name="block"> /// A <see cref="MetadataBlock"/> with the block to check /// overlapping. /// </param> /// <returns> /// A <see cref="System.Boolean"/> which is true, if the given /// block overlapps with the current instance. /// </returns> /// <remarks> /// Overlapping means here also that blocks directly follow. /// </remarks> public bool OverlapsWith(MetadataBlock block) { if (block.Start >= Start && block.Start <= Start + Length) return true; if (Start >= block.Start && Start <= block.Start + block.Length) return true; return false; }
/// <summary> /// Checks, if the one block is before the other. That means, /// if the current instance ends before the given block starts. /// </summary> /// <param name="block"> /// A <see cref="MetadataBlock"/> to compare with. /// </param> /// <returns> /// A <see cref="System.Boolean"/> which is true if the current /// instance is before the given block. /// </returns> public bool Before(MetadataBlock block) { return (Start + Length < block.Start); }
/// <summary> /// Adds the given block to the current instance, if this is possible. /// </summary> /// <param name="block"> /// A <see cref="MetadataBlock"/> with the block to add. /// </param> public void Add(MetadataBlock block) { if (block.Start >= Start && block.Start <= Start + Length) { Length = Math.Max (Length, block.Start + block.Length - Start); return; } if (Start >= block.Start && Start <= block.Start + block.Length) { Length = Math.Max (block.Length, Start + Length - block.Start); Start = block.Start; return; } throw new ArgumentException (String.Format ("blocks do not overlap: {0} and {1}", this, block)); }