using System;

using System.Collections.Generic;

​

public interface IOperator<T, U> where T : IComparable<U>

{

    bool Compare(T a, U b);

}

​

public class EqualityOperator<T, U> : IOperator<T, U> where T : IComparable<U>

{

    public bool Compare(T a, U b) {

      return a.CompareTo(b) == 0;

    }

}

​

public interface IFilter<T, T2> where T : List<T2> {

    T Filter(T input);

}

​

public abstract class ConjunctionFilter<T, T2> : IFilter<T, T2> where T : List<T2> {

    public enum ConjunctionType {

        NONE,

        AND,

        OR

    }

    public ConjunctionType Conjunction {get; set;}

    // Filter the list items

    public abstract T Filter(T input);

}

​

// a single row

public class SingleFilter<T, T1, T2, T3> : ConjunctionFilter<T, T1> where T2 : IComparable<T3> where T : List<T1> {

    public IOperator<T2, T3> storedOperator;

    public string Column;

    public string Value;

    public override T Filter(T input) {

        // do some filtering with the operator

        // storedOperator.Compare(a, b) // a,b for each item int he list

        List<T1> output = new List<T1>();

        return (T)output;

    }

}

​

// a row with subrows

public class MultiFilter<T, T1> : ConjunctionFilter<T, T1> where T : List<T1> {

    List<ConjunctionFilter<T, T1>> subFilters = new List<ConjunctionFilter<T, T1>>();

​

    public override T Filter(T input) {

        // clone list

        List<T1> clonedList = new List<T1>();

        clonedList.AddRange(input);

        // apply filters

        foreach (var filter in subFilters) {

            clonedList = filter.Filter((T)clonedList);

        }

        // merge two lists, respecting the conjucntiontype setting of this filter

        List<T1> output = new List<T1>();

        return (T)output;

    }

}

​

public struct DataEntry {

    public string Name;

    public decimal Budget;

}

​

public class Program

{

    public static void Main()

    {

        MultiFilter<List<DataEntry>, DataEntry> rootFilter;

    }

}