public SearchCondition(int pageNo, int pageSize, IRecordFilter filter, IEnumerable <IRecordSorter> sorters)
{
if (pageNo < 1)
{
throw new ArgumentOutOfRangeException(nameof(pageNo));
}
if (pageSize > EasyFormConsts.MAX_PAGE_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(pageSize));
}
PageNo = pageNo;
PageSize = pageSize;
Filter = filter;
Sorters = sorters;
}
public RecordFilterDriver(IRecordFilter filter)
{
_filter = filter;
_recordAccepter = new RecordAccepter();
// some filters (ToTable, ToCount, ...) can bless the
// input to be sorted (the responsibility falls on the
// user to be correct). If the filter implements
// ISortHint we ask the filter if it has a hint.
// if True: set _passThruInputSorting = false;
// set _sorting.IsSorted = ISortHint.IsSorted
// set _sorting.IsSortedAscending = ISortHint.IsSortedAscending
//
// if False: set _passThruInputSorting = filter.KeyOrderIsPreserved;
if (filter is SortHintingFilter && ((SortHintingFilter)filter).HaveHint) {
_passThruInputSorting = false;
_sorting.IsSorted = ((SortHintingFilter)filter).IsSorted;
_sorting.IsSortedAscending = ((SortHintingFilter)filter).IsSortedAscending;
}
else {
// if keyOrder preserved then just pass thru
_passThruInputSorting = filter.KeyOrderIsPreserved;
}
_filterType = _filter.GetType().ToString();
if (_filterType.StartsWith("Microsoft.TMSN.Data.")) {
_filterType = _filterType.Remove(0, 20);
}
ProcessTreeComment = "[filter:" + _filterType + "]";
}
public SearchCondition(int pageNo, int pageSize, IRecordFilter filter, IRecordSorter sorter)
: this(pageNo, pageSize, filter, new List <IRecordSorter> {
sorter
})
{
}
public static void exportRMS(FormInstance parent, System.Type type, System.String grouperName, IStorageUtility storage, IRecordFilter filter)
{
FormInstance entities = RestoreUtils.exportRMS(storage, type, grouperName, filter);
RestoreUtils.mergeDataModel(parent, entities, ".");
}
public override bool MoveNext()
{
// initialize
if (_input == null) {
_input = (InternalRecordSource)_inputList[0];
}
// get at least one record into the accepter
while (_recordAccepter.Empty && _notDone) {
_notDone = _input.MoveNext();
// run the current record through the filter
if (_notDone) {
// build the filter and put in place
if (_filter == null) {
_filter = _GetFilter(_input.CurrentRecord.GetType().ToString(), _assemblyLocations);
// we already determined if the filter's KeyOrderIsPreserved
// make sure we were right
if (_passThruInputSorting != _filter.KeyOrderIsPreserved) {
throw new Exception("user filter error: improper KeyOrderIsPreserved detection");
}
}
// put a try catch around user code
try {
_filter.ProcessRecord(_input.CurrentRecord, _recordAccepter);
}
catch {
_caughtErrors++;
if (_caughtErrors == 1 || (_caughtErrors % 1000 == 0)) {
Console.WriteLine(_caughtErrors + " caught " + _filterType + " error(s) d");
}
}
_notDone = !_recordAccepter.IsDone; // filter may elect to finish early
}
// there is a finish call because the filter might have state
// this gives it a chance to output one last record.
else {
try {
_filter.Finish(_recordAccepter);
}
catch {
_caughtErrors++;
}
}
}
// grab a record from the accepter
bool notDone = _recordAccepter.MoveNext();
if (!notDone) return false;
CurrentRecord = _recordAccepter.CurrentRecord;
return true;
}
public static FormInstance exportRMS(IStorageUtility storage, System.Type type, System.String parentTag, IRecordFilter filter)
{
if (!typeof(Externalizable).IsAssignableFrom(type) || !typeof(Restorable).IsAssignableFrom(type))
{
return(null);
}
FormInstance dm = newDataModel(parentTag);
IStorageIterator ri = storage.iterate();
while (ri.hasMore())
{
System.Object obj = ri.nextRecord();
if (filter == null || filter.filter(obj))
{
FormInstance objModel = ((Restorable)obj).exportData();
mergeDataModel(dm, objModel, topRef(dm));
}
}
return(dm);
}
public DataDestination(IDataWriterFactory dataWriterFactory, IRecordFilter recordFilter)
{
this.DataWriterFactory = dataWriterFactory;
this.RecordFilter = recordFilter;
}
public DataDestination(IDataWriter dataWriter, IRecordFilter recordFilter)
{
this.DataWriter = dataWriter;
this.RecordFilter = recordFilter;
}
/// <summary>
/// Filters a RecordSource using a user provided filter
/// </summary>
/// <param name="input">The input record source</param>
/// <param name="filter">The user provided recordFilter</param>
/// <returns>A RecordSource for further processing</returns>
public RecordSource Filter(RecordSource input, IRecordFilter filter)
{
if (filter is ISetRecordSource) {
// if this filter implements IRecordSourceAccess then
// we use it to set the RecordSource so the filter
// itself will have access to it.
((ISetRecordSource)filter).Source = input;
}
RecordFilterDriver filterDriver = new RecordFilterDriver(filter);
filterDriver.AddInput(input.InternalSource);
RecordSource source2Bfiltered = new RecordSource(this);
source2Bfiltered.InternalSource = filterDriver;
return source2Bfiltered;
}
public ExpandedDataDestination(IRecordExpander recordExpander, IRecordFilter recordFilter, params IDataDestination[] dataDestinations)
{
this.RecordExpander = recordExpander;
this.DataDestinations = dataDestinations;
this.RecordFilter = recordFilter;
}
