public void FindHead()
{
var predicate1 = SearchPredicate <EntitySearchHead> .Create(EntitySearchHead.Name, "archer");
predicate1.OrPredicate = SearchPredicate <EntitySearchHead> .Create(EntitySearchHead.State, "intoxicated");
var result = SearchPredicateExtensions.FindHead(predicate1, EntitySearchHead.State);
Assert.Equal(1, result.Count);
Assert.Equal(EntitySearchHead.State, result[0].Term.Head);
}
private static string PredicateToWhereText <TSearchHeadEnum>(
SearchPredicate <TSearchHeadEnum> predicate
, Func <SearchTerm <TSearchHeadEnum>, string> termToWhereText) where TSearchHeadEnum : struct, IConvertible
{
var whereText = termToWhereText(predicate.Term);
if (predicate.HasOrPredicate)
{
var orText = PredicateToWhereText(predicate.OrPredicate, termToWhereText); //yes resharper, it is recursive
whereText = AsLogicalOr(whereText, orText);
}
return(whereText);
}
public void File_Is_X_Days_Old()
{
const int daysOld = 5;
var sCriteria = new SearchCriteria(TimePeriod.Days, daysOld,
true, false, null,
null, 100);
var sPredicate = new SearchPredicate(sCriteria);
var sFinder = new FileFinder(@"J:\temp\Excel_Testing", sPredicate);
foreach (var filePath in sFinder.SearchDirectory())
{
_testOutputHelper.WriteLine(filePath);
}
Assert.True(true);
}
public void File_Has_String_In_Name(string[] nameFilter, int expectedFiles)
{
//string[] extFilter = {".xlsx"};
var fileFound = 0;
var sCriteria = new SearchCriteria(TimePeriod.Days, 0,
true, false, null,
nameFilter, 100);
var sPredicate = new SearchPredicate(sCriteria);
var sFinder = new FileFinder(@"J:\temp\Excel_Testing", sPredicate);
foreach (var filePath in sFinder.SearchDirectory())
{
_testOutputHelper.WriteLine(filePath);
fileFound++;
}
Assert.True(fileFound == expectedFiles);
}
public TreeNode <T> searchNode(SearchPredicate search_predicate, T value)
{
if (search_predicate(this, value))
{
return(this);
}
else
{
TreeNode <T> temp = null;
foreach (TreeNode <T> node in _children)
{
temp = node.searchNode(search_predicate, value);
}
if (temp != null)
{
return(temp);
}
else
{
return(null);
}
}
}
/// <summary>
/// Searches the specified collection.
/// TType - the type of object passed on to SearchPredicate
/// PType - the type of object that the SearchPredicate would return
/// </summary>
/// <param name="collection">The collection.</param>
/// <param name="itemToSearch">The item to search.</param>
/// <param name="searchValue">The search value.</param>
public static TType Search <TType, PType>(List <TType> collection, PType itemToSearch, SearchPredicate <TType, PType> searchValue)
{
#if Syncfusion2_0 || NETCORE
return((TType)(collection.Find(delegate(TType t)
{
return itemToSearch.ToString() == searchValue(t).ToString();
})));
#elif Syncfusion3_5
var result = from TType t in collection
where searchValue(t).ToString( ) == itemToSearch.ToString( )
select t;
if (result != null)
{
return(result.SingleOrDefault <TType>( ));
}
return(default(TType));
#endif
}
protected override IEnumerable <FileSystemItem> EnumerateItemsImpl(UPath path, SearchOption searchOption, SearchPredicate searchPredicate)
{
throw new NotImplementedException();
}
public SearchPredicator(SearchPredicate <T> predicate)
{
this.predicate = predicate;
}
protected override IEnumerable <FileSystemItem> EnumerateItemsImpl(UPath path, SearchOption searchOption, SearchPredicate searchPredicate)
{
return(_fs.GetDirectoryEntry(path).EnumerateItems(searchOption));
}
/*************************************************************************
* Standard BST search
*************************************************************************/
public bool TryFind(SearchPredicate <TEl> predicate, out TEl element)
{
return(TryFind(new SearchPredicator <TEl>(predicate), out element));
}
public void Insert(TPoint2D point)
{
var count = Points.Size;
//always insert first two points
if (count != 1)
{
var farRight = point.X > RightMost.X;
var farLeft = point.X < LeftMost.X;
var withinBounds = !farRight && !farLeft;
//don't insert when point lies inside the range of the convex hull but on the wrong side
if (withinBounds)
{
var orientation = Geometry2D.Orient(LeftMost.AsVector(), RightMost.AsVector(), point.AsVector());
var pointLiesAbove = orientation == 1;
if (pointLiesAbove != IsUpper)
{
return;
}
}
TPoint2D startPoint, endPoint;
Points.TryFind(p => UpdatePredicate(point, p, true), out startPoint);
Points.TryFind(p => UpdatePredicate(point, p, false), out endPoint);
//point outside of hull
if (startPoint != null || endPoint != null)
{
if (startPoint != RightMost && endPoint != LeftMost)
{
SearchPredicate <TPoint2D> inRangePredicate = p =>
{
if (startPoint != null && p.X <= startPoint.X)
{
return(1);
}
if (endPoint != null && p.X >= endPoint.X)
{
return(-1);
}
return(0);
};
//delete everything after start up to end
TPoint2D element;
Points.TryFind(inRangePredicate, out element);
while (element != null)
{
Points.Delete(element);
Points.TryFind(inRangePredicate, out element);
}
}
}
//point inside of hull
else
{
return;
}
}
Points.Insert(point, pointWithSameX =>
{
if (IsUpper)
{
return(point.Y > pointWithSameX.Y);
}
return(point.Y < pointWithSameX.Y);
});
}
