/// <summary>
/// Checks to ensure that the dataset is not null, has the specified number of tables
/// and whether or not each table MUST have rows in it.
/// </summary>
/// <param name="requiredNumberOfTables">
/// The number of tables that dataset must contain
/// </param>
/// <param name="tableMustHaveRowsFlags">
/// A list of boolean flags denoting whether each table in the set MUST have some rows in it.
/// e.g.
///
/// DataSet ds = GetSomeDataSet();
/// ds.IsPopulated(3, true, false, true);
///
/// means that the dataset MUST have 3 tables. The first and third tables MUST have rows in them,
/// the second table may or may not have rows in it.
/// </param>
/// <returns>
/// True if the the tables required to be populated actually are, otherwise false.
/// </returns>
public static bool IsPopulated(this DataSet ds, int requiredNumberOfTables, params bool[] tableMustHaveRowsFlags)
{
_logger.DebugMethodCalled(ds, requiredNumberOfTables, tableMustHaveRowsFlags);
#region Input validation
Insist.IsAtLeast(requiredNumberOfTables, 1, "requiredNumberOfTables");
Insist.IsNotNull(tableMustHaveRowsFlags, "tableMustHaveRowsFlags");
Insist.Equality(tableMustHaveRowsFlags.Length, requiredNumberOfTables, "tableMustHaveRowsFlags", "The number of tableMustHaveRowsFlags must match the number of tables");
#endregion
if (ds == null ||
ds.Tables == null ||
ds.Tables.Count != requiredNumberOfTables)
{
return(false);
}
else
{
for (int i = 0; i < requiredNumberOfTables; i++)
{
if (tableMustHaveRowsFlags[i] == true &&
(
ds.Tables[i].Rows == null ||
ds.Tables[i].Rows.Count == 0
))
{
return(false);
}
}
return(true);
}
}
public static IList <IList <T> > Chunk <T>(this IEnumerable <T> data, int chunkSize)
{
#region Input validation
Insist.IsAtLeast(chunkSize, 1, "chunkSize");
if (!data.Any())
{
return(new List <IList <T> >());
}
#endregion
IList <IList <T> > chunks = new List <IList <T> >();
int currentIndex = 0;
List <T> currentChunk = null;
foreach (T element in data)
{
int offset = currentIndex % chunkSize;
if (offset == 0)
{
currentChunk = new List <T>();
chunks.Add(currentChunk);
}
currentChunk.Add(element);
currentIndex++;
}
return(chunks);
}
/// <summary>
/// Pads the given string with the character specified to the given length.
/// </summary>
/// <param name="str">The string to be padded.</param>
/// <param name="padCharacter">The character to be used as padding.</param>
/// <param name="padToLength">The length of the new, padded string.</param>
/// <param name="mode">The side the padding should be applied to.</param>
/// <returns>The padded string.</returns>
public static string Pad(this string str, char padCharacter, int padToLength, PaddingMode mode)
{
_logger.DebugMethodCalled(str, padCharacter, padToLength, mode);
#region Input Validation
Insist.IsAtLeast(padToLength, 1, "padToLength");
#endregion
bool createPadding = false;
if (str != null)
{
if (str.Length > padToLength)
//No need to do any padding if the string is already long enough
{
createPadding = false;
}
else
//String is too short so padding required.
{
createPadding = true;
}
}
else
//The string is null so we'll set the output string to just the
//padded string
{
createPadding = true;
}
string paddedStr;
if (createPadding)
{
int requiredPadding = padToLength - (str == null ? 0 : str.Length);
string padding = new string(padCharacter, requiredPadding);
switch (mode)
{
case PaddingMode.Left:
paddedStr = padding + (str == null ? string.Empty : str);
break;
case PaddingMode.Right:
paddedStr = (str == null ? string.Empty : str) + padding;
break;
default:
throw new NotSupportedException(String.Format("The padding mode {0} is not supported.", mode));
}
}
else
{
paddedStr = str;
}
return(paddedStr);
}
/// <summary>
/// Generates a random string that is as long as length
/// </summary>
/// <param name="random">
/// The random number generator to use
/// </param>
/// <param name="length">
/// The length of the string to be generated. Returns an empty string if length
/// is zero.
/// </param>
/// <param name="allowNumbers">
/// Whether or not to allow numbers in the generated string
/// </param>
/// <param name="allowSymbols">
/// Whether or not to allow symbols in the string
/// </param>
/// <returns>
/// A random string of the specified length
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown when random is null
/// </exception>
/// <exception cref="System.ArgumentException">
/// Throw when length is less than 0.
/// </exception>
public static string NextString(this Random random, int length, bool allowNumbers, bool allowSymbols)
{
#region Input Validation
Insist.IsNotNull(random, "random");
Insist.IsAtLeast(length, 0, "length");
#endregion
if (length == 0)
{
return(string.Empty);
}
StringBuilder builder = new StringBuilder();
while (builder.Length < length)
{
//+1 because MaxValue is exclusive but minValue is inclusive
int i = random.Next(STARTING_ASCII_CODE, ENDING_ASCII_CODE + 1);
bool isNumber = false;
bool isSymbol = false;
bool canAdd = true;
if ((i >= UPPERCASE_ALPHABET_STARTING_CODE && i <= UPPERCASE_ALPHABET_ENDING_CODE) ||
(i >= LOWERCASE_ALPHABET_STARTING_CODE && i <= LOWERCASE_ALPHABET_ENDING_CODE))
{
canAdd = true;
}
else if (i >= NUMBER_STARTING_CODE && i <= NUMBER_ENDING_CODE)
{
isNumber = true;
}
else
{
isSymbol = true;
}
if (isNumber == true &&
allowNumbers == false)
{
canAdd = false;
}
if (isSymbol == true &&
allowSymbols == false)
{
canAdd = false;
}
if (canAdd)
{
builder.Append((char)i);
}
}
return(builder.ToString());
}
public void IsAtLeast_Thrown_Exception_Has_Correct_Argument_Name()
{
try {
Insist.IsAtLeast(1, 5, ARGUMENT_NAME);
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual(ARGUMENT_NAME, e.ParamName);
}
}
public void IsAtLeast_Thrown_Exception_Has_Correct_Message()
{
try
{
Insist.IsAtLeast(1, 5, ARGUMENT_NAME, MESSAGE);
}
catch (ArgumentException e)
{
Assert.IsTrue(e.Message.Contains(MESSAGE));
}
}
/// <summary>
/// Copies the contents of this Trie to the supplied array at the specified index
/// </summary>
public void CopyTo(KeyValuePair <TKey, TValue>[] array, int arrayIndex)
{
#region Input validation
Insist.IsNotNull(array, "array");
Insist.IsAtLeast(arrayIndex, 0, "arrayIndex");
Insist.IsAtLeast((array.Length - arrayIndex), this.Count, "array", "The number of elements in the collection is greater than the size of the destination array");
#endregion
int currentIndex = 0;
foreach (KeyValuePair <TKey, TValue> kvp in this)
{
array[arrayIndex + currentIndex] = kvp;
currentIndex++;
}
}
/// <summary>
/// Generates a new one time password from the supplied data.
/// </summary>
/// <param name="secretKey">The secret key to use in the HMAC</param>
/// <param name="hmac">The hmac algorithm to use</param>
/// <param name="dt">The date and time to generate a code for</param>
/// <param name="offset">Any offsets that should be applied to the supplie date time</param>
/// <param name="timeStep">The timestep value to use to calculate the current step</param>
/// <param name="otpLength">The required legnth of the returned passcode</param>
/// <returns>A one time password code</returns>
/// <exception cref="System.ArgumentNullException">Thrown if hmac or secret key is null</exception>
/// <exception cref="System.ArgumentException">Thrown if secret key is empty, optLength is
/// not defined value or timeStep is less than 1 second.</exception>
public static string Generate(byte[] secretKey, HMAC hmac, DateTime dt, TimeSpan offset, TimeSpan timeStep, OneTimePasswordLength otpLength)
{
#region Input validation
Insist.IsNotNull(hmac, "hmac");
Insist.IsNotNull(secretKey, "secretKey");
Insist.IsNotEmpty(secretKey, "secretKey");
Insist.IsDefined <OneTimePasswordLength>(otpLength, "optLength");
Insist.IsAtLeast(timeStep.TotalSeconds, 1, "timeStep");
#endregion
dt = dt + offset;
ulong stepNumber = (ulong)Math.Floor((double)dt.ToUnixTime() / (double)timeStep.TotalSeconds);
return(HmacOneTimePassword.Generate(secretKey, stepNumber, hmac, otpLength));
}
/// <summary>
/// Returns the substring of the StringBuilder.
/// </summary>
/// <param name="str">The StringBuilder to get the substring of.</param>
/// <param name="startIndex">The starting index of the substring.</param>
/// <param name="length">The (optional) length of the sub string.</param>
/// <returns>The characters making up the given sub string.</returns>
public static string SubString(this StringBuilder str, int startIndex, int?length)
{
_logger.DebugMethodCalled(str, startIndex, length);
#region Input Validation
Insist.IsNotNull(str, "str");
Insist.IsAtLeast(str.Length, 1, "str", "The substring operation is not valid on a zero length string.");
Insist.IsAtLeast(startIndex, 0, "startIndex");
//Calculate the end index
int endIndex;
if (length.HasValue)
{
endIndex = startIndex + length.Value - 1;
}
else
{
endIndex = (str.Length - 1);
}
if (length.HasValue && endIndex > (str.Length - 1))
{
throw new IndexOutOfRangeException("The end index must be a value less than or equal to the final index of the string builder.");
}
if (length.HasValue && endIndex < startIndex)
{
throw new ArgumentException("The end index must be greater than or equal to the start index.", "length");
}
#endregion
//Get the sub string
char[] chars = new char[(endIndex - startIndex) + 1];
for (int index = startIndex; index <= endIndex; index++)
{
chars[index - startIndex] = str[index];
}
return(new String(chars));
}
/// <summary>
/// Construct a new bloom filter that tracks the specified number of
/// elements with the desired error rate.
/// </summary>
/// <param name="expectedNumberOfElements">
/// The number of items that this bloom filter is expected to track
/// </param>
/// <param name="errorRate">
/// The desired error rate for generating false positives.
/// </param>
/// <exception cref="System.ArgumentException">
/// Thrown if expectedNumberOfElements is less than 0, errorRate is less than 0 or
/// errorRate is greater than 1.
/// </exception>
public BaseBloomFilter(int expectedNumberOfElements, double errorRate)
{
#region Input validation
Insist.IsAtLeast(expectedNumberOfElements, 0, "expectedNumberOfElements");
Insist.IsAtLeast(errorRate, 0, "errorRate");
Insist.IsAtMost(errorRate, 1.0d, "errorRate");
#endregion
_expectedNumberOfElements = expectedNumberOfElements;
_errorRate = errorRate;
_hashAlgorithm = new MurmurHash2();
_numberOfBuckets = (int)Math.Ceiling(1.1d * Math.Abs((((double)_expectedNumberOfElements) * Math.Log(errorRate)) / (Math.Pow(Math.Log(2), 2))));
_numberOfHashes = (int)(Math.Ceiling(0.7d * Math.Abs((double)(_numberOfBuckets / _expectedNumberOfElements))));
_bucketStorage = GetBucketStorage(_numberOfBuckets);
_lock = new ReaderWriterLockSlim();
}
public void IsAtLeast_Value_Within_Bounds_Does_Not_Throw_Exception()
{
Insist.IsAtLeast(10, 5, ARGUMENT_NAME);
}
public void IsAtLeast_Value_Out_Of_Bounds_Throws_Exception()
{
Insist.IsAtLeast(1, 5, ARGUMENT_NAME);
}
/// <summary>
/// Wraps a string onto multiple lines using the supplied argument as the line length.
/// Optionally respects any words so that a line is wrapped on any preceding whitespace for a word
/// that would get split over multiple lines.
/// </summary>
/// <param name="str">
/// The string to split
/// </param>
/// <param name="respectWords">
/// Whether or not to respect words during wrapping. If true then a word will only be split
/// if there is no preceding whitespace. If false then words will be split in half if they
/// span a line boundary.
/// </param>
/// <param name="lineLength">
/// The maximum length each line should be after wrapping
/// </param>
/// <returns>
/// A string that has been wrapped to the supplied line length
/// </returns>
/// <exception cref="System.ArgumentException">
/// Thrown if lineLength is less than or equal to 0
/// </exception>
public static string Wrap(this string str, int lineLength, bool respectWords)
{
_logger.DebugMethodCalled(str, lineLength, respectWords);
#region Input validation
Insist.IsAtLeast(lineLength, 1, "lineLength");
#endregion
#region Shortcuts
if (string.IsNullOrEmpty(str))
{
return(str);
}
if (str.Length <= lineLength)
{
return(str);
}
#endregion
StringBuilder builder = new StringBuilder();
int startingIndex = 0;
int charsLeft = str.Length;
while (charsLeft > 0)
{
//Watch for the end of the string
if (charsLeft <= lineLength)
{
builder.Append(str.Substring(startingIndex));
charsLeft = 0;
}
else
{
int adjustedWrapLength = lineLength;
if (respectWords)
{
while (adjustedWrapLength > 0)
{
if (str[startingIndex + adjustedWrapLength] == '\t' ||
str[startingIndex + adjustedWrapLength] == ' ')
{
//Readjust index so that when we do a substring
//further down we'll also grab the whitespace
//character.
adjustedWrapLength++;
break;
}
adjustedWrapLength--;
}
if (adjustedWrapLength == 0)
//Didnt find any whitespace, just split the
//line at the wrapLength position
{
adjustedWrapLength = lineLength;
}
}
builder.AppendLine(str.Substring(startingIndex, adjustedWrapLength));
startingIndex += adjustedWrapLength;
charsLeft = str.Length - startingIndex;
}
}
return(builder.ToString());
}
