/// <summary>
///
/// </summary>
/// <param name="numberOfBlocksToStore"></param>
/// <returns></returns>
/// <exception cref="OverflowException"></exception>
public AddressingSystemBlockSizes GetSizesOfAddressingBlocksSufficientToStoreItems(int numberOfBlocksToStore)
{
MethodArgumentValidator.ThrowIfNegative(numberOfBlocksToStore, "numberOfBlocksToStore");
if (numberOfBlocksToStore == 0)
{
return(new AddressingSystemBlockSizes(0, 0));
}
int lastSingleIndirectBlockSize;
int firstBlockSize = Math.DivRem(numberOfBlocksToStore, _singleIndirectBlockCapacity, out lastSingleIndirectBlockSize);
if (lastSingleIndirectBlockSize > 0)
{
firstBlockSize++;
}
if (lastSingleIndirectBlockSize == 0)
{
lastSingleIndirectBlockSize = _singleIndirectBlockCapacity;
}
if (firstBlockSize > _doubleIndirectBlockCapacity)
{
throw new OverflowException("Невозможно распределить указанное число блоков.");
}
return(new AddressingSystemBlockSizes(firstBlockSize, lastSingleIndirectBlockSize));
}
public AddressingBlockSizesCalculator(int doubleIndirectBlockCapacity, int singleIndirectBlockCapacity)
{
MethodArgumentValidator.ThrowIfNegative(doubleIndirectBlockCapacity, "doubleIndirectBlockCapacity");
MethodArgumentValidator.ThrowIfNegative(singleIndirectBlockCapacity, "singleIndirectBlockCapacity");
_doubleIndirectBlockCapacity = doubleIndirectBlockCapacity;
_singleIndirectBlockCapacity = singleIndirectBlockCapacity;
}
public static void ThrowIfStringIsTooLong(string argument, int maximumStringLength, string argumentName)
{
MethodArgumentValidator.ThrowIfNegative(maximumStringLength, "maximumStringLength");
MethodArgumentValidator.ThrowIfStringIsNullOrEmpty(argument, argumentName);
if (argument.Length > maximumStringLength)
{
throw new ArgumentException("Принимаются только строки длиной не больше следующего числа символов: {0}".FormatWith(maximumStringLength), argumentName);
}
}
private void SetCapacitiesAndIndex(int initialValue, int firstIndexCapacity, int secondIndexCapacity, int thirdIndexCapacity)
{
MethodArgumentValidator.ThrowIfNegative(firstIndexCapacity, "firstIndexCapacity");
MethodArgumentValidator.ThrowIfNegative(secondIndexCapacity, "secondIndexCapacity");
MethodArgumentValidator.ThrowIfNegative(thirdIndexCapacity, "thirdIndexCapacity");
FirstIndexCapacity = firstIndexCapacity;
SecondIndexCapacity = secondIndexCapacity;
ThirdIndexCapacity = thirdIndexCapacity;
_compositeIndex = new CompositeIndex(initialValue, new[] { firstIndexCapacity, secondIndexCapacity, thirdIndexCapacity });
}
/// <summary>
///
/// </summary>
/// <param name="newInteger"></param>
/// <exception cref="InvalidOperationException">Если размер набора целых чисел достиг максимума.</exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public void AddInteger(int newInteger)
{
MethodArgumentValidator.ThrowIfNegative(newInteger, "newInteger");
if (_integers.Count == _maximumCountOfIntegers)
{
throw new InvalidOperationException("В списке чисел не может быть больше следующего числа элементов: {0}.".FormatWith(_maximumCountOfIntegers));
}
// Note: можно было бы тут же и сохранять, обернув класс декоратором, как я сделал в нескольких других местах.
_integers.Add(newInteger);
}
/// <summary>
///
/// </summary>
/// <param name="numberOfItemsToDistribute"></param>
/// <param name="firstBucketRemainingCapacity"></param>
/// <param name="bucketCapacity"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static ReadOnlyCollection <BucketDistribution> Distribute(int numberOfItemsToDistribute, int firstBucketRemainingCapacity, int bucketCapacity)
{
MethodArgumentValidator.ThrowIfNegative(numberOfItemsToDistribute, "numberOfItemsToDistribute");
MethodArgumentValidator.ThrowIfNegative(firstBucketRemainingCapacity, "firstBucketRemainingCapacity");
MethodArgumentValidator.ThrowIfNegative(bucketCapacity, "bucketCapacity");
if (firstBucketRemainingCapacity > bucketCapacity)
{
throw new ArgumentException("Первая из ячеек не может иметь места для еще {0} элемент(-а,-ов), так как каждая ячейка содержит, максимум, {1} элементов".FormatWith(firstBucketRemainingCapacity, bucketCapacity));
}
var distributionResult = new List <BucketDistribution>();
int bucketIndex = 0;
if (firstBucketRemainingCapacity < numberOfItemsToDistribute)
{
if (firstBucketRemainingCapacity != 0)
{
distributionResult.Add(new BucketDistribution(bucketIndex, bucketCapacity - firstBucketRemainingCapacity, firstBucketRemainingCapacity));
numberOfItemsToDistribute -= firstBucketRemainingCapacity;
}
}
else
{
distributionResult.Add(new BucketDistribution(bucketIndex, bucketCapacity - firstBucketRemainingCapacity, numberOfItemsToDistribute));
return(distributionResult.AsReadOnly());
}
int remainder;
int fullyFilledBuckets = Math.DivRem(numberOfItemsToDistribute, bucketCapacity, out remainder);
bucketIndex++;
for (int i = 0; i < fullyFilledBuckets; i++)
{
distributionResult.Add(new BucketDistribution(bucketIndex, 0, bucketCapacity));
bucketIndex++;
}
if (remainder > 0)
{
distributionResult.Add(new BucketDistribution(bucketIndex, 0, remainder));
}
return(distributionResult.AsReadOnly());
}
/// <summary>
///
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public int this[int index]
{
get
{
return(_integers[index]);
}
set
{
MethodArgumentValidator.ThrowIfNegative(value, "value");
if (index >= _integers.Count)
{
throw new ArgumentOutOfRangeException("index");
}
_integers[index] = value;
}
}
/// <summary>
///
/// </summary>
/// <param name="numberOfItemsToStore"></param>
/// <param name="chunkSize"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static int GetNumberOfChunksNeededToStoreData(int numberOfItemsToStore, int chunkSize)
{
MethodArgumentValidator.ThrowIfNegative(numberOfItemsToStore, "numberOfItemsToStore");
if (chunkSize <= 0)
{
throw new ArgumentOutOfRangeException("chunkSize", "Требуется положительное число");
}
int remainder;
int numberOfBlocksNeeded = Math.DivRem(numberOfItemsToStore, chunkSize, out remainder);
if (remainder > 0)
{
numberOfBlocksNeeded++;
}
return(numberOfBlocksNeeded);
}
/// <summary>
///
/// </summary>
/// <param name="integersAsByteArrayLittleEndian"></param>
/// <param name="currentCountOfIntegers"></param>
/// <param name="maximumCountOfIntegers"></param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentNullException"></exception>
public IntegerListConstrained(byte[] integersAsByteArrayLittleEndian, int currentCountOfIntegers, int maximumCountOfIntegers)
{
MethodArgumentValidator.ThrowIfNegative(currentCountOfIntegers, "currentCountOfIntegers");
MethodArgumentValidator.ThrowIfNegative(maximumCountOfIntegers, "maximumCountOfIntegers");
MethodArgumentValidator.ThrowIfNull(integersAsByteArrayLittleEndian, "integersAsByteArrayLittleEndian");
if (currentCountOfIntegers * IntegerSizeInBytes > integersAsByteArrayLittleEndian.Length)
{
throw new ArgumentException("Из массива байт не удастся прочитать следующее число целых: {0}. Проверьте аргументы.".FormatWith(currentCountOfIntegers), "currentCountOfIntegers");
}
if (maximumCountOfIntegers < currentCountOfIntegers)
{
throw new ArgumentException("Максимальное число целых в списке не может быть меньше текущего числа элементов.".FormatWith(currentCountOfIntegers), "currentCountOfIntegers, maximumCountOfIntegers");
}
this.FillInInternalListOfIntegers(integersAsByteArrayLittleEndian, currentCountOfIntegers);
_maximumCountOfIntegers = maximumCountOfIntegers;
}
/// <summary>
///
/// </summary>
/// <param name="newSize"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public ReadOnlyCollection <int> Shrink(int newSize)
{
MethodArgumentValidator.ThrowIfNegative(newSize, "newSize");
if (newSize > _integers.Count)
{
throw new ArgumentOutOfRangeException("newSize", "Новый размер массива должен быть меньше текущего.");
}
var removedItems = new List <int>();
while (_integers.Count != newSize)
{
int lastIntegerIndex = _integers.Count - 1;
removedItems.Add(_integers[lastIntegerIndex]);
_integers.RemoveAt(lastIntegerIndex);
}
return(removedItems.AsReadOnly());
}
/// <summary>
///
/// </summary>
/// <param name="firstIndex"></param>
/// <param name="firstIndexCapacity"></param>
/// <param name="secondIndex"></param>
/// <param name="secondIndexCapacity"></param>
/// <param name="thirdIndex"></param>
/// <param name="thirdIndexCapacity"></param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <exception cref="ArgumentException"></exception>
public DoubleIndirectionCompositeIndex(int firstIndex, int firstIndexCapacity, int secondIndex, int secondIndexCapacity, int thirdIndex, int thirdIndexCapacity)
{
MethodArgumentValidator.ThrowIfNegative(firstIndex, "firstIndex");
MethodArgumentValidator.ThrowIfNegative(secondIndex, "secondIndex");
MethodArgumentValidator.ThrowIfNegative(thirdIndex, "thirdIndex");
MethodArgumentValidator.ThrowIfNegative(firstIndexCapacity, "firstIndexCapacity");
MethodArgumentValidator.ThrowIfNegative(secondIndexCapacity, "secondIndexCapacity");
MethodArgumentValidator.ThrowIfNegative(thirdIndexCapacity, "thirdIndexCapacity");
if (firstIndex >= firstIndexCapacity)
{
throw new ArgumentException("Первый индекс должен быть в пределах от 0 до {0} (не включая {0})".FormatWith(firstIndexCapacity));
}
if (secondIndex >= secondIndexCapacity)
{
throw new ArgumentException("Второй индекс должен быть в пределах от 0 до {0} (не включая {0})".FormatWith(secondIndexCapacity));
}
if (thirdIndex >= thirdIndexCapacity)
{
throw new ArgumentException("Третий индекс должен быть в пределах от 0 до {0} (не включая {0})".FormatWith(thirdIndexCapacity));
}
checked
{
try
{
int initialValue = firstIndex * secondIndexCapacity * thirdIndexCapacity + secondIndex * thirdIndexCapacity +
thirdIndex;
this.SetCapacitiesAndIndex(initialValue, firstIndexCapacity, secondIndexCapacity, thirdIndexCapacity);
}
catch (OverflowException)
{
throw new ArgumentException("Заданная комбинация индексов образует число слишком большое для текущей версии.");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="initialValue"></param>
/// <param name="capacitiesOfIndexes"></param>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public CompositeIndex(int initialValue, IEnumerable <int> capacitiesOfIndexes)
{
MethodArgumentValidator.ThrowIfNegative(initialValue, "initialValue");
MethodArgumentValidator.ThrowIfNull(capacitiesOfIndexes, "capacitiesOfIndexes");
if (capacitiesOfIndexes.Any(number => (number <= 0)))
{
throw new ArgumentException("Массив не должен содержать отрицательных чисел и нулей.", "capacitiesOfIndexes");
}
var ordersList = new List <int>(capacitiesOfIndexes);
if (ordersList.Count < 1)
{
throw new ArgumentException("Набор должен быть непустым.", "capacitiesOfIndexes");
}
_capacitiesOfCompositeIndexes = ordersList.AsReadOnly();
_maximumValue = GetMaximumCapacityForGivenSystemValidatingInput(capacitiesOfIndexes) - 1;
_capacity = GetMaximumCapacityForGivenSystemValidatingInput(capacitiesOfIndexes);
this.AssignNewValue(initialValue);
}
/// <summary>
///
/// </summary>
/// <param name="initialValue"></param>
/// <param name="firstIndexCapacity"></param>
/// <param name="secondIndexCapacity"></param>
/// <param name="thirdIndexCapacity"></param>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <exception cref="ArgumentException"></exception>
public DoubleIndirectionCompositeIndex(int initialValue, int firstIndexCapacity, int secondIndexCapacity, int thirdIndexCapacity)
{
MethodArgumentValidator.ThrowIfNegative(initialValue, "initialValue");
this.SetCapacitiesAndIndex(initialValue, firstIndexCapacity, secondIndexCapacity, thirdIndexCapacity);
}