using System;
using System.Collections.Generic;
using System.Diagnostics;
namespace BrainTechLLC.DAL
{
public partial class DBLayer<T> where T : DBLayer<T>, IDBLayer<T>, new()
{
// MONSTER code file - if anyone has an idea how to use generics to eliminate the code redundancy, let me know.
internal static ResultSet<T> InternalQueryInt(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
long numericValue,
List<long> multipleNumbers
)
{
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) == numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) != numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) > numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) < numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) >= numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) <= numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (multipleNumbers.Contains(Convert.ToInt64(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (!multipleNumbers.Contains(Convert.ToInt64(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
internal static ResultSet<T> InternalQueryString(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
string stringValue,
List<string> rgString
)
{
string sconstcomp = (pair._wantTrim) ? stringValue.Trim() : stringValue;
ResultSet<T> foundResults = new ResultSet<T>();
StringComparison scomp = pair._isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval != null) continue;
else if (itemval == null && pair._value != null) continue;
else if (pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp == 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval == null) continue;
else if ((itemval == null && pair._value != null) ||
(itemval != null && pair._value == null))
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp != 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp < 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval != null) continue;
else if (itemval == null && pair._value != null) continue;
else if (pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp <= 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval != null) continue;
else if (itemval == null && pair._value != null) continue;
else if (pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp >= 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp > 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (rgString.Contains(sval))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (!rgString.Contains(sval))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.Contains)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.IndexOf(sconstcomp, scomp) >= 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.DoesntContain)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.IndexOf(sconstcomp, scomp) < 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.EndsWith)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.EndsWith(sconstcomp, scomp))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.StartsWith)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.StartsWith(sconstcomp, scomp))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
internal static ResultSet<T> InternalQueryDateTime(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
DateTime dt,
List<DateTime> rgDateTime
)
{
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) == dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) != dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) > dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) < dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) >= dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) <= dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (rgDateTime.Contains(Convert.ToDateTime(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (!rgDateTime.Contains(Convert.ToDateTime(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
internal static ResultSet<T> InternalQueryDouble(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
double dconst,
List<double> doubleList
)
{
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) == dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) != dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) > dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) < dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) >= dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) <= dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (doubleList.Contains(Convert.ToDouble(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (!doubleList.Contains(Convert.ToDouble(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
internal static ResultSet<T> InternalQueryBoolean(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
bool bconst
)
{
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval != null) continue;
else if (itemval == null && pair._value != null) continue;
else if (pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
if (Convert.ToBoolean(itemval) == bconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval == null) continue;
else if (itemval == null || pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
if (Convert.ToBoolean(itemval) != bconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
return foundResults;
}
/// <summary>
/// Very basic/first-pass code to find a good "search starting point" in a sorted result set.
/// Returns a starting index valid for the comparison type being performed - in other words,
/// if you are searching for values > 500, this method guarantees that all (values > 500) are further
/// along in the list than the starting index it returns.
/// </summary>
/// <param name="results"></param>
/// <param name="numericValue"></param>
/// <param name="pair"></param>
/// <param name="itemCount"></param>
/// <returns></returns>
internal static int IntDetermineStartPoint(ResultSet<T> results, long numericValue, PropNameAndVal pair, int itemCount)
{
// TODO - eliminate (or at least clean up / reduce) repetitive code
int nStartPosition = itemCount / 2;
int nIncrement = itemCount / 8;
int nLastPosition = 0;
int nForward = 0;
bool fPositionOkay = false;
ResultRow<T> resrow;
int nItemLimit = (itemCount > 10) ? (itemCount - 4) : 4;
if (nItemLimit > itemCount) nItemLimit = itemCount;
if (pair._comparisonType == ComparisonType.GreaterThan)
{
while (!fPositionOkay)
{
// working here
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (numericValue < Convert.ToInt64(itemval))
{
// we are high enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit lower in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We've gone too low
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go higher in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
if (pair._comparisonType == ComparisonType.Equals)
{
while (!fPositionOkay)
{
nIncrement *= 2;
// working here
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToInt64(itemval) < numericValue)
{
if (nIncrement < 32) { fPositionOkay = true; }
else
{
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = 0;
fPositionOkay = true;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
while (!fPositionOkay)
{
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (numericValue > Convert.ToInt64(itemval))
{
// we are low enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit higher in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We went too far
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go lower in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
while (!fPositionOkay)
{
// working here
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (numericValue <= Convert.ToInt64(itemval))
{
// we are high enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit lower in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We've gone too low
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go higher in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
while (!fPositionOkay)
{
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (numericValue >= Convert.ToInt64(itemval))
{
// we are low enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit higher in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We went too far
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go lower in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
return nStartPosition;
}
internal static int StringDetermineStartPoint(ResultSet<T> results, string sconstcomp, PropNameAndVal pair, int itemCount)
{
// TODO - eliminate (or at least clean up / reduce) repetitive code
int nStartPosition = itemCount / 2;
int nIncrement = itemCount / 8;
int nLastPosition = 0;
int nForward = 0;
bool fPositionOkay = false;
ResultRow<T> resrow;
int nItemLimit = (itemCount > 10) ? (itemCount - 4) : 4;
if (nItemLimit > itemCount) nItemLimit = itemCount;
StringComparison scomp = pair._isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (pair._comparisonType == ComparisonType.GreaterThan)
{
while (!fPositionOkay)
{
// working here
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) { nStartPosition = itemCount - 1; break; }
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp > 0)
{
// we are high enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit lower in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We've gone too low
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go higher in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
while (!fPositionOkay)
{
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) { nStartPosition = 0; break; }
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp < 0)
{
// we are low enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit higher in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We went too far
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go lower in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
while (!fPositionOkay)
{
// working here
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) { nStartPosition = itemCount - 1; break; }
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp >= 0)
{
// we are high enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit lower in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We've gone too low
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go higher in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
while (!fPositionOkay)
{
resrow = results[nStartPosition];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) { nStartPosition = itemCount - 1; break; }
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp <= 0)
{
// we are low enough
if (nForward == -1) { fPositionOkay = true; }
else
{
// we're okay - try going a bit higher in the list
nForward = 1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition + nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition >= nItemLimit)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
else
{
// We went too far
if (nForward == 1) { nStartPosition = nLastPosition; fPositionOkay = true; }
else
{
// we need to go lower in the list
nForward = -1;
nLastPosition = nStartPosition;
nStartPosition = nStartPosition - nIncrement;
nIncrement = (nIncrement / 2) + 1;
if (nStartPosition <= 4)
{
nStartPosition = nLastPosition;
fPositionOkay = true;
}
}
}
}
}
return nStartPosition;
}
/// <summary>
/// Finds one or more rows matching the specific criteria (long or integer comparison),
/// taking full advantage of the list being sorted.
/// Also capable of handling IN SET and NOT IN SET
/// </summary>
/// <param name="results"></param>
/// <param name="pair"></param>
/// <param name="wantSingleRow"></param>
/// <param name="itemCount"></param>
/// <param name="numericValue"></param>
/// <param name="multipleNumbers"></param>
/// <returns></returns>
internal static ResultSet<T> InternalQueryIntSorted(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
long numericValue,
List<long> multipleNumbers
)
{
int nStartPosition = 0;
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
nStartPosition = IntDetermineStartPoint(results, numericValue, pair, itemCount);
for (int i = nStartPosition; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
long iValue = Convert.ToInt64(itemval);
if (numericValue < iValue) break;
if (iValue == numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (Convert.ToInt64(itemval) != numericValue)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
nStartPosition = IntDetermineStartPoint(results, numericValue, pair, itemCount);
for (int i = nStartPosition - 1; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToInt64(itemval) <= numericValue)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
nStartPosition = IntDetermineStartPoint(results, numericValue, pair, itemCount);
for (int i = nStartPosition; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToInt64(itemval) >= numericValue)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
nStartPosition = IntDetermineStartPoint(results, numericValue, pair, itemCount);
for (int i = nStartPosition; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToInt64(itemval) < numericValue)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
nStartPosition = IntDetermineStartPoint(results, numericValue, pair, itemCount);
for (int i = nStartPosition; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToInt64(itemval) > numericValue)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (multipleNumbers.Contains(Convert.ToInt64(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing integers, one value was null.");
if (!multipleNumbers.Contains(Convert.ToInt64(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
/// <summary>
/// Finds one or more rows matching the specific criteria (string comparison)
/// In most cases, takes advantage of the list being sorted.
/// Capable of handling trimming comparisons, case sensitivity (or lack thereof),
/// IN SET, NOT IN SET, Contains(substring search), DoesntContain(substring), EndsWith, StartsWith
/// </summary>
/// <param name="results"></param>
/// <param name="pair"></param>
/// <param name="wantSingleRow"></param>
/// <param name="itemCount"></param>
/// <param name="stringValue"></param>
/// <param name="rgString"></param>
/// <returns></returns>
internal static ResultSet<T> InternalQueryStringSorted(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
string stringValue,
List<string> rgString
)
{
string sconstcomp = (pair._wantTrim) ? stringValue.Trim() : stringValue;
int nStartPosition = 0;
ResultSet<T> foundResults = new ResultSet<T>();
StringComparison scomp = pair._isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval != null) continue;
else if (itemval == null && pair._value != null) continue;
else if (pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp == 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval == null) continue;
else if ((itemval == null && pair._value != null) ||
(itemval != null && pair._value == null))
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp != 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
nStartPosition = StringDetermineStartPoint(results, sconstcomp, pair, itemCount);
for (int i = nStartPosition; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp <= 0)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
nStartPosition = StringDetermineStartPoint(results, sconstcomp, pair, itemCount);
for (int i = nStartPosition; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp >= 0)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
nStartPosition = StringDetermineStartPoint(results, sconstcomp, pair, itemCount);
for (int i = nStartPosition; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp < 0)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
nStartPosition = StringDetermineStartPoint(results, sconstcomp, pair, itemCount);
for (int i = nStartPosition; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
else
{
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
int nComp = string.Compare(sval, sconstcomp, scomp);
if (nComp > 0)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (rgString.Contains(sval))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (!rgString.Contains(sval))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.Contains)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.IndexOf(sconstcomp, scomp) >= 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.DoesntContain)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.IndexOf(sconstcomp, scomp) < 0)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.EndsWith)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.EndsWith(sconstcomp, scomp))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.StartsWith)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null || itemval == null) continue;
string sval = (pair._wantTrim) ? itemval.ToString().Trim() : itemval.ToString();
if (sval.StartsWith(sconstcomp, scomp))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
/// <summary>
/// Finds one or more rows matching the specific criteria (DateTime comparison)
/// Takes advantage of the list being sorted, but not to the same extent as
/// search on int/string (yet - see note below)
/// </summary>
/// <param name="results"></param>
/// <param name="pair"></param>
/// <param name="wantSingleRow"></param>
/// <param name="itemCount"></param>
/// <param name="dt"></param>
/// <param name="rgDateTime"></param>
/// <returns></returns>
internal static ResultSet<T> InternalQueryDateTimeSorted(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
DateTime dt,
List<DateTime> rgDateTime
)
{
// TODO - implement a get start search index routine for sorted list of DateTimes
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) == dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (Convert.ToDateTime(itemval) != dt)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
{
for (int i = itemCount - 1; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDateTime(itemval) <= dt)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDateTime(itemval) >= dt)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
{
for (int i = itemCount - 1; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDateTime(itemval) < dt)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDateTime(itemval) > dt)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (rgDateTime.Contains(Convert.ToDateTime(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing DateTime, one value was null.");
if (!rgDateTime.Contains(Convert.ToDateTime(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
/// <summary>
/// Finds one or more rows matching the specific criteria (double comparison)
/// Takes advantage of the list being sorted, but not to the same extent as
/// search on int/string (yet - see note below)
/// </summary>
/// <param name="results"></param>
/// <param name="pair"></param>
/// <param name="wantSingleRow"></param>
/// <param name="itemCount"></param>
/// <param name="dconst"></param>
/// <param name="doubleList"></param>
/// <returns></returns>
internal static ResultSet<T> InternalQueryDoubleSorted(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
double dconst,
List<double> doubleList
)
{
// TODO - implement a get start search index routine for sorted list of doubles -
// would be almost identical to method IntDetermineStartPoint
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) == dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (Convert.ToDouble(itemval) != dconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThan)
{
{
for (int i = itemCount - 1; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDouble(itemval) <= dconst)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThan)
{
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDouble(itemval) >= dconst)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
{
for (int i = itemCount - 1; i >= 0; i--)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDouble(itemval) < dconst)
{
for (int n = i + 1; n < itemCount; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.LessThanOrEqualTo)
{
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (Convert.ToDouble(itemval) > dconst)
{
for (int n = 0; n < i; n++) { resrow = results._cachedResultSet._list[n]; foundResults._cachedResultSet.Add(resrow); }
return foundResults;
}
}
}
}
else if (pair._comparisonType == ComparisonType.InSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (doubleList.Contains(Convert.ToDouble(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
else if (pair._comparisonType == ComparisonType.NotInSet)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
Debug.Assert(pair._value != null && itemval != null, "Comparing doubles, one value was null.");
if (!doubleList.Contains(Convert.ToDouble(itemval)))
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
return foundResults;
}
internal static ResultSet<T> InternalQueryBooleanSorted(
ResultSet<T> results,
PropNameAndVal pair,
bool wantSingleRow,
int itemCount,
bool bconst
)
{
ResultSet<T> foundResults = new ResultSet<T>();
if (pair._comparisonType == ComparisonType.Equals)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval != null) continue;
else if (itemval == null && pair._value != null) continue;
else if (pair._value == null) { foundResults._cachedResultSet.Add(resrow); }
else
{
if (Convert.ToBoolean(itemval) == bconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
else if (pair._comparisonType == ComparisonType.NotEqual)
{
for (int i = 0; i < itemCount; i++)
{
ResultRow<T> resrow = results._cachedResultSet._list[i];
object itemval = pair._cachedPropertyDescriptor.GetValue(resrow._result);
if (pair._value == null && itemval == null) continue;
else if (itemval == null || pair._value == null)
{
foundResults._cachedResultSet.Add(resrow);
}
else
{
if (Convert.ToBoolean(itemval) != bconst)
{
foundResults._cachedResultSet.Add(resrow);
}
}
}
}
return foundResults;
}
}
}
Submit an article or tip