private static BlockMap ToBlockMap(bool[] model)
            {
                var result = new BlockMap(model.Length);

                var currentOffset = -1;
                var currentLength = 0;

                for (int i = 0; i < model.Length; ++i)
                {
                    if (model[i])
                    {
                        if (currentOffset < 0)
                        {
                            currentOffset = i;
                        }
                        ++currentLength;
                    }
                    else
                    {
                        if (currentOffset >= 0)
                        {
                            result.AssignBytes(currentOffset, currentLength);
                            currentOffset = -1;
                            currentLength = 0;
                        }
                    }
                }
                if (currentOffset >= 0)
                {
                    result.AssignBytes(currentOffset, currentLength);
                }

                return(result);
            }
        public void ScatterStream_SetCapacity_WhereBlockMapWouldBeTruncated_Throws()
        {
            var size           = 256;
            var buffer         = fixture.InitializeBuffer(size);
            var assignedBlocks = new BlockMap(size);

            assignedBlocks.AssignBytes(0, size / 2);

            var scatterStream = fixture.CreateScatterStream(buffer, assignedBlocks);
            var gatherStream  = fixture.CreateGatherStream(buffer, assignedBlocks);

            var changedSize = size / 2 - 1;

            scatterStream.Capacity = changedSize;
        }
 public static BlockMap WithSuccessor(this BlockMap map, int offset, int count)
 {
     map.AssignBytes(offset + count + 1, count);
     return(map);
 }
 public static BlockMap WithIntersectingPredecessor(this BlockMap map, int offset, int count)
 {
     map.AssignBytes(offset - count + 1, count);
     return(map);
 }
 public static BlockMap WithImmediatePredecessor(this BlockMap map, int offset, int count)
 {
     map.AssignBytes(offset - count, count);
     return(map);
 }
 public static BlockMap WithBlock(this BlockMap map, int offset, int count)
 {
     map.AssignBytes(offset, count);
     return(map);
 }