public PresortBestSplitter(ICriterion criterion,
                            uint max_features,
                            uint min_samples_leaf,
                            Random random_state)
     : base(criterion, max_features, min_samples_leaf, random_state)
 {
 }

		private static SqlString[] GetColumnNamesUsingPropertyName(
			ICriteriaQuery criteriaQuery, 
			ICriteria criteria, 
			string propertyName, 
			object value, 
			ICriterion critertion)
		{
			string[] columnNames = criteriaQuery.GetColumnsUsingProjection(criteria, propertyName);
			IType propertyType = criteriaQuery.GetTypeUsingProjection(criteria, propertyName);

			if (value != null && !(value is System.Type) && !propertyType.ReturnedClass.IsInstanceOfType(value))
			{
				throw new QueryException(string.Format(
											"Type mismatch in {0}: {1} expected type {2}, actual type {3}",
											critertion.GetType(), propertyName, propertyType.ReturnedClass, value.GetType()));
			}

			if (propertyType.IsCollectionType)
			{
				throw new QueryException(string.Format(
											"cannot use collection property ({0}.{1}) directly in a criterion,"
											+ " use ICriteria.CreateCriteria instead",
											criteriaQuery.GetEntityName(criteria), propertyName));
			}
			return Array.ConvertAll<string, SqlString>(columnNames, delegate(string col)
			{
				return new SqlString(col);
			});
		}

 public CriteriaQuery(ICriterion  criteria)
 {
     if (criteria != null)
     {
         this.criterion = criteria;
         this.criterion.SetQuery(this);
     }
 }

 private IEnumerable<FileSystemItem> FindChildren(FileSystemPath path, ICriterion criterion)
 {
     return Session.CreateCriteria<FileSystemItem>()
         .Add(Restrictions.Eq("Path.Parent", path.ToString()))
         .Add(criterion)
         .AddOrder(Order.Asc("Path.Name"))
         .SetCacheable(true)
         .List<FileSystemItem>();
 }

 public SplitterBase(ICriterion criterion,
                 uint max_features,
                 uint min_samples_leaf,
                 Random random_state)
 {
     this.criterion = criterion;
     this.max_features = max_features;
     this.min_samples_leaf = min_samples_leaf;
     this.random_state = random_state ?? new Random();
 }

		/// <summary>
		/// Adds a collection of ICriterion to an ICriteria.
		/// </summary>
		/// <param name="criteria">The ICriteria that will be modified.</param>
		/// <param name="criterions">The collection of Criterion.</param>
		internal static void AddCriterionToCriteria(ICriteria criteria, ICriterion[] criterions)
		{
			if (criterions != null)
			{
				foreach (ICriterion cond in criterions)
				{
					criteria.Add(cond);
				}
			}
		}

		public void CountQuery_ByTypeAndCriteria()
		{
			Prepare();
			ICriterion[] criterionArray = new ICriterion[] 
            { 
                Expression.Eq("Category", "c")
            };
			CountQuery cq = new CountQuery(typeof(Post), criterionArray);
			int recordCount = (int)ActiveRecordMediator.ExecuteQuery(cq);
			Assert.AreEqual(2, recordCount);
		}

        public static SqlFunctionExpression GetFunctionCriteria(MethodCallExpression call, ICriterion criterion,
            SqlFunctionExpression rightFunction)
        {
            System.Type[] paramTypes = null;
            object[] paramValues = GetMethodParameterValues(call, out paramTypes);

            int propertyPosition = 0;
            string methodName = QueryUtil.GetMethodName(call, out propertyPosition);

            return new SqlFunctionExpression(methodName, call.Method.ReturnType, paramValues, paramTypes, criterion,
                                             propertyPosition, rightFunction);
        }

 public SqlFunctionExpression(String functionName, System.Type returnType, Object[] paramValues,
     System.Type[] paramTypes, ICriterion innerCriterion, int propertyPosition,
     SqlFunctionExpression rightFunction)
 {
     FunctionName = functionName;
     ReturnType = returnType;
     ParameterValues = paramValues;
     ParameterTypes = paramTypes;
     InnerCriterion = innerCriterion;
     PropertyPosition = propertyPosition;
     RightFunction = rightFunction;
 }

 public static IList Find(ICriterion crit, Type type, PagerInfo pi)
 {
     ISession s = Sessions.GetSession();
     try
     {
         ICriteria c = s.CreateCriteria(type);
         if (crit != null ) c.Add(crit);
         if (pi != null )
         {
             c.SetFirstResult(pi.FirstResult);
             c.SetMaxResults(pi.MaxResults);
         }
         return c.List();
     }
     finally
     {
         s.Close();
     }
 }

 public KPGridJsonProperties(bool isSearch, int page, int rows,
                             string propertyOrder, string orderTypeJason,
                             string filterJson,  KPSessionJQGrid sessionJQGrid, string propertyCompany,
                             ICriterion initialFilter, Order initialOrder, object[] colModel)
 {
     IsSearch = isSearch;
     Page = page;
     Rows = rows;
     PropertyOrder = propertyOrder;
     OrderTypeJson = orderTypeJason;
     User = sessionJQGrid.SecuritySession.Login;
     Company = sessionJQGrid.SecuritySession.FrwCompany;
     PropertyCompanyEntity = propertyCompany;
     FilterJson = filterJson;
     ColModel = Array.ConvertAll<object, string>(colModel, Convert.ToString);
     List<JqGridColumnCustom> jqGridColumnCustomList = new List<JqGridColumnCustom>();
     foreach (string item in ColModel)
         jqGridColumnCustomList.Add(KPJsonJqGrid.GetColumnCustom(item));
     ColumnsCustom = jqGridColumnCustomList.ToArray();
     InitialFilter = initialFilter;
     InitialOrder = initialOrder;
 }

        public KPJqGridControl(string primaryKey, HiddenField hiddenKey, Type typeEntity, KPItemModelCollection KPitemsModel,
                              KPJqGridDoubleClickActionEnum DoubleClickAction, ICriterion filter, Order order)
        {
            #region Filter/Order
            this.InitialFilter = filter;
            this.InitialOrder = order;
            #endregion

            this.HiddenKey = hiddenKey == null ? new HiddenField() : hiddenKey;
            this.Caption = String.Empty;
            this.PrimaryKey = primaryKey;
            this.UrlService = System.Web.VirtualPathUtility.ToAbsolute("~/WCF/EntityService.svc/GetEntityFilter");
            this.TypeEntity = typeEntity;
            this.KPItemsModel = KPitemsModel;
            this.DoubleClickAction = DoubleClickAction;

            this.RowNum = KPJqGridRowNumEnum.RowsView_10;
            this.OrderRecords = KPJqGridTypeOrderEnum.ASC;
            this.ViewTotalRecordsLabel = true;
            this.Height = 100;
            this.Width = 300;
        }

		public static SqlString[] GetColumnNamesForSimpleExpression(
			string propertyName,
			IProjection projection,
			ICriteriaQuery criteriaQuery,
			ICriteria criteria,
			IDictionary<string, IFilter> enabledFilters,
			ICriterion criterion,
			object value)
		{
			if (projection == null)
			{
				return GetColumnNamesUsingPropertyName(
					criteriaQuery, 
					criteria, 
					propertyName,
					value, 
					criterion);
			}
			else
			{
				return GetColumnNamesUsingProjection(projection, criteriaQuery, criteria, enabledFilters);
			}
		}

 public AddCriterionEvent(ICriterion criterion)
 {
     this.criterion = criterion;
 }

		/// <summary>
		/// Returns all instances found for the specified type
		/// using criteria and IStatelessSession.
		/// </summary>
		/// <param name="type">The target type.</param>
		/// <param name="criterias">The criteria expression</param>
		/// <param name="sortItems">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
		/// <param name="firstRow">The number of the first row to retrieve.</param>
		/// <param name="maxRows">The maximum number of results retrieved.</param>
		/// <returns>The <see cref="Array"/> of results.</returns>
		public virtual Array FindAllStateless(Type type, ICriterion[] criterias, Order[] sortItems, int firstRow, int maxRows)
		{
			using (IStatelessSession session = GetStatelessSession())
			{
				try
				{
					ICriteria criteria = session.CreateCriteria(type);

					if (criterias != null)
					{
						foreach (ICriterion cond in criterias)
						{
							criteria.Add(cond);
						}
					}

					if (sortItems != null)
					{
						foreach (Order order in sortItems)
						{
							criteria.AddOrder(order);
						}
					}

					if (firstRow != int.MinValue) criteria.SetFirstResult(firstRow);
					if (maxRows != int.MinValue) criteria.SetMaxResults(maxRows);
					IList result = criteria.List();

					Array array = Array.CreateInstance(type, result.Count);
					result.CopyTo(array, 0);

					return array;
				}
				catch (Exception ex)
				{
					throw new DataException("Could not perform FindAllStateless for " + type.Name, ex);
				}
			}
		}

 public void Add(ICriterion criteria) {
    _criteria.Add(criteria);
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="AndExpression"/> class
		/// that combines two <see cref="ICriterion"/>.
		/// </summary>
		/// <param name="lhs">The <see cref="ICriterion"/> to use as the left hand side.</param>
		/// <param name="rhs">The <see cref="ICriterion"/> to use as the right hand side.</param>
		public AndExpression(ICriterion lhs, ICriterion rhs) : base(lhs, rhs)
		{
		}

		public ConditionalProjection(ICriterion criterion, IProjection whenTrue, IProjection whenFalse)
		{
			this.whenTrue = whenTrue;
			this.whenFalse = whenFalse;
			this.criterion = criterion;
		}

 public static Array Where(Type t, ICriterion[] criteria, Order[] order)
 {
     return FindAll(t, order, criteria);
 }

 public static Object FindFirst(Type t, ICriterion[] criteria)
 {
     return FindOne(t, criteria);
 }