public ImageFigure(Image Image, Rectangle Source, Rectangle Destination, Filter Filter)
 {
     this.Image = Image;
     this.Source = Source;
     this.Destination = Destination;
     this.Filter = Filter;
 }

 public ChannelParams(AnalogInChannelsEnum channelName, Filter channelFilter, ProgrammableGainAmplifier channelPGA, AnalogInLatch channelLatch)
 {
     _channelName = channelName;
     ChannelFilter = channelFilter;
     ChannelPGA = channelPGA;
     CommonLatch = channelLatch;
 }

        public void GetFiltersSortsFiltersByOrderFirstThenScope()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var actionFilter = new Filter(new Object(), FilterScope.Action, null);
            var controllerFilter = new Filter(new Object(), FilterScope.Controller, null);
            var globalFilter = new Filter(new Object(), FilterScope.Global, null);
            var earlyActionFilter = new Filter(new Object(), FilterScope.Action, -100);
            var lateGlobalFilter = new Filter(new Object(), FilterScope.Global, 100);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor))
                .Returns(new[] { actionFilter, controllerFilter, globalFilter, earlyActionFilter, lateGlobalFilter });

            // Act
            Filter[] result = collection.GetFilters(context, descriptor).ToArray();

            // Assert
            Assert.Equal(5, result.Length);
            Assert.Same(earlyActionFilter, result[0]);
            Assert.Same(globalFilter, result[1]);
            Assert.Same(controllerFilter, result[2]);
            Assert.Same(actionFilter, result[3]);
            Assert.Same(lateGlobalFilter, result[4]);
        }

        public FiltersModule()
        {
            Get["/Filters"] = parameters =>
            {
                FiltersModel model = new FiltersModel();
                model.Filters.Add(new Filter(1, "test filter 1", true, 1, 1, 1, 0));
                model.Filters.Add(new Filter(2, "filter 2", true, 1, 5, 1, 1));
                model.Filters.Add(new Filter(2, "filter 3", false, 1, 5, 1, 1));
                model.Filters.Add(new Filter(2, "filter 4", true, 1, 5, 1, 1));
                model.Filters.Add(new Filter(2, "filter 5", false, 1, 5, 1, 1));

                return View["Index", model];
            };

            Get["/Filters/Edit"] = parameters =>
            {
                EditFilterModel model = new EditFilterModel();

                Filter filter = new Filter(1, "filter 1", true, 0, 0, 0, 0);
                filter.Codecs.Add("XViD");
                model.Filter = filter;

                return View["EditFilter", model];
            };

            Post["/Filters/Delete"] = parameters =>
            {
                return true;
            };
        }

 public Filter UpdateFilter(Filter filter, string dataSourceId)
 {
     var flt = Mapper.Map<Filter, DynamoDb.Filter>(filter);
     flt.DataSourceId = dataSourceId;
     this.Context.Save(flt);
     return filter;
 }

        public void ShouldDeserializeComplexWorkflowConfiguration3()
        {
            var workFlow = new Workflow();
            workFlow.Configuration = "{\"default_filter\":{\"queue\":\"WQccc\"},\"filters\":[{\"expression\":\"1==1\",\"friendly_name\":\"Prioritizing Filter\",\"targets\":[{\"priority\":\"1\",\"queue\":\"WQccc\",\"timeout\":\"300\"}]}]}";

            var workFlowConfiguration = new WorkflowConfiguration();
            var filter = new Filter
            {
                FriendlyName = "Prioritizing Filter",
                Expression = "1==1",
                Targets = new List<Target>() { 
                    new Target { 
                        Queue="WQccc",
                        Priority="1",
                        Timeout="300"
                    }
                }
            };

            workFlowConfiguration.Filters.Add(filter);
            workFlowConfiguration.DefaultFilter = new Target() { Queue = "WQccc" };

            var config = workFlow.WorkflowConfiguration;

            Assert.AreEqual(workFlowConfiguration.ToString(), config.ToString());
        }

 internal static void getAdvanceFilterResult(string SelectedValue, Filter filter, ref List<Listing> output)
 {
     switch (filter)
     {
         case Filter.Type:
             getbyFilterType(SelectedValue, ref output);
             break;
         case Filter.Status:
             getbyFilterStatus(SelectedValue, ref output);
             break;
         case Filter.SAP:
             getbyFilterSAPStatus(SelectedValue, ref output);
             break;
         case Filter.Title:
             int SelectedID = Convert.ToInt32(SelectedValue);
             getbyFilterTitle(SelectedID, ref output);
             break;
         case Filter.NotDefined:
             getbyFilterWorkflow(SelectedValue, ref output);
             break;
         case Filter.Supervisors:
             getByFilterSupervisor(SelectedValue, ref output);
             break;
     }
 }

        private JObject GetCompanies(int rows, int page, string sidx, string sord, Filter filters)
        {
            IQueryable<Company> items = Companies.SortBy(filters, sidx, sord);

            int totalItems = items.Count();
            //in a real app Count should probably be retrieved asynchronously
            //int totalItems = await items.CountAsync();
            int totalPages = totalItems / rows;
            if (totalItems % rows > 0)
            {
                totalPages++;
            }

            items = items.Skip((page - 1) * rows).Take(rows);

            List<Company> listOfItems = items.ToList();
            //List<Company> listOfItems = await items.ToListAsync();

            dynamic result = new JObject();
            result.total = totalPages;
            result.records = totalItems;
            result.page = page;
            result.rows = new JArray(listOfItems.Select(c =>
                {
                    dynamic o = new JObject();
                    o.id = c.CompanyID;
                    o.cell = new JArray(c.CompanyID, c.Name, c.Address);
                    return o;
                }).ToArray());

            return result;
        }

 public ManyToManyRelationship(string name, bool isUserDefined, OneToManyRelationship primaryRelationship, ManyToOneRelationship foreignRelationship, Filter filter)
     : base(name, isUserDefined, primaryRelationship.Parent, primaryRelationship.Parent, primaryRelationship.PrimaryColumns, foreignRelationship.ForeignRelationship.Parent, foreignRelationship.ForeignRelationship.PrimaryColumns, filter)
 {
     _intermediatePrimaryRelationship = primaryRelationship;
     _intermediateForeignRelationship = foreignRelationship;
     ResetDefaults();
 }

        public Word GetWordByNameCategoryAndWordPackID(string Name, int CategoryID, int WordPackID)
        {
            Filter[] Filters = new Filter[]
            {
                new Filter(FilterType.And, new Field[]
                    {
                        NameField, 
                        CategoryIDField,
                        WordPackIDField
                    },
                    new string[]
                    {
                        "Name",
                        "CategoryID",
                        "WordPackID"
                    },
                    new object[]
                    {
                        Name,
                        CategoryID,
                        WordPackID
                    })
            };

            var Words = GetObjectsByFilters(Filters);
            Word word = Words.Cast<Word>().ToList().FirstOrDefault();

            if (word == null)
            {
                word = new Word(0, Name, CategoryID, WordPackID);
            }

            return word;
        }

        public static Continuation LastModified(this ICacheSteps _,
            Filter<DateTime> lastModifiedFilter)
        {
            return step => ctx =>
              {
            DateTime lastModified, d;

            var ifModifiedHeader = ctx.Request.Headers["If-Modified-Since"];

            // if a valid date has been given as a validator
            if (!string.IsNullOrEmpty(ifModifiedHeader) &&
              DateTime.TryParseExact(ifModifiedHeader, "R", CultureInfo.CurrentCulture,
              DateTimeStyles.RoundtripKind, out d)) {

              // run the filter and check the modified date,
              lastModified = lastModifiedFilter(ctx, d);

              // automatically returning 304 Not Modified if date indicates not modified
              if (roughCompare(lastModified.ToUniversalTime(), d.ToUniversalTime()) <= 0)
            step = fu.Compose(
              fu.Http.Header("Last-Modified", lastModified.ToString("R")),
              fu.Http.NotModified())
              (fu.EndAct);
            }
            else {
              lastModified = lastModifiedFilter(ctx, DateTime.MinValue);
            }

            fu.Http.Header("Last-Modified", lastModified.ToString("R"))
              (step)(ctx);
              };
        }

        public static Task<Get> get(int owner_id, long offset = 0, byte count = 100, Filter filter = Filter.owner)
        {
            return Task.Run<Get>(() =>
            {
                try
                {
                    //Собираем параметры
                    StringBuilder data = new StringBuilder();
                    data.Append("&owner_id=" + owner_id);
                    data.Append("&offset=" + offset);
                    data.Append("&filter=" + filter.ToString());
                    data.Append("&extended=1");

                    if (count > 0 && count <= 100)
                        data.Append("&count=" + count);


                    //Получаем и возвращаем результаты
                    string json = Regex.Replace(result.get("wall.get", data.ToString(), true), "^{\"response\":{\"wall\":\\[([0-9]+),{\"(.*)}$", "{\"count\":$1,\"wall\":[{\"$2");
                    return JsonConvert.DeserializeObject<Get>(json);
                }
                catch (Newtonsoft.Json.JsonReaderException) { }
                catch { }

                //Ошибка
                return new Get();
            });
        }

 /// <summary>
 /// Fills the list provided with the element matching the filter provided
 /// </summary>
 /// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
 /// <param name="filter">The filter to apply</param>
 public override void fill(List<Utils.INamable> retVal, Filter.AcceptableChoice filter)
 {
     if (filter(Value))
     {
         retVal.Add(Value);
     }
 }

 private void cmbCardFilter_SelectedIndexChanged(object sender, EventArgs e)
 {
     switch (cmbCardFilter.SelectedIndex)
     {
         case 0:
             //"全部"
             CardFilter = (x) => { return true; };
             break;
         case 1:
             //"随从"
             CardFilter = (x) => { return x.卡牌种类 == CardBasicInfo.资源类型枚举.随从; };
             break;
         case 2:
             //"法术"
             CardFilter = (x) => { return x.卡牌种类 == CardBasicInfo.资源类型枚举.法术; };
             break;
         case 3:
             // "武器"
             CardFilter = (x) => { return x.卡牌种类 == CardBasicInfo.资源类型枚举.武器; };
             break;
         default:
             break;
     }
     SetCardListView();
 }

        static List<int> Filtered(int[] array1, Filter filter1, Filter filter2)
        {
            List<int> filtered1 = new List<int>();
                foreach (var item in array1)
                {
                    if (filter1(item))
                    {
                        filtered1.Add(item);
                    }
                }

                List<int> filtered2 = new List<int>();
                foreach (var item in array1)
                {
                    if (filter2(item))
                    {
                        filtered2.Add(item);
                    }
                }
                List<int> filtered = new List<int>();
                var array3 = filtered1.ToArray();
                var array2 = filtered2.ToArray();
                for (int i = 0; i < array3.Length; i++)
                {
                    filtered.Add(array3[i] * array2[i]);
                }

                return filtered;
        }

        public override IDictionary<long, Dictionary<string, string>> Export(IList<Trade> inTrades, Filter inFilter, Stream stream, Market market, IList<Exception> exceps)
        {
            var task = _task;
            var filter = task.Filter;
            var date = market.Date(_effectiveTime);
            var trades = Env.Current.Trade.GetTrades2(filter, date, _effectiveTime);
          
            using (var writer = new StreamWriter(stream))
            {
                WriteHeader(writer);
                foreach (var trade in trades)
                {
                    if (trade.Product == null)
                    {
                        exceps.Add(new ApplicationException(String.Format("Trade {0} is invalid.  Missing product.", trade.Id)));
                        continue;
                    }
                    if(trade.TradeTime > _effectiveTime)
                    {
                        continue;
                    }

                    string line = WriteTrade(trade, date, _effectiveTime, exceps);
                    if (!Utilities.IsNullOrEmpty(line))
                    {
                        writer.WriteLine(line);
                    }
                }
            }
            return null;
        }

 public MemoryRecord(string _group, double _rxfreq, string _name, DSPMode _dsp_mode, bool _scan,
     string _tune_step, FMTXMode _repeater_mode, double _fm_tx_offset_mhz, bool _ctcss_on, double _ctcss_freq,
     int _power, int _deviation, bool _split, double _txfreq, Filter _filter, int _filterlow, int _filterhigh, 
     string _comments, AGCMode _agc_mode, int _agc_thresh)
 {
     group = _group;
     rx_freq = _rxfreq;
     name = _name;
     dsp_mode = _dsp_mode;
     scan = _scan;
     tune_step = _tune_step;
     repeater_mode = _repeater_mode;
     rptr_offset = _fm_tx_offset_mhz;
     ctcss_on = _ctcss_on;
     ctcss_freq = _ctcss_freq;
     power = _power;
     deviation = _deviation;
     split = _split;
     tx_freq = _txfreq;
     rx_filter = _filter;
     rx_filter_low = _filterlow;
     rx_filter_high = _filterhigh;
     comments = _comments;
     agc_mode = _agc_mode;
     agct = _agc_thresh;
 }

        public Logik()
        {
            Database = new DatabaseAdgang();
            DAQdata = new IndhentDAQData();
            NulpunktObjekt = new Nulpunktsjustering();
            KalibreringObjekt = new Kalibrering();
            FilterObj = new Filter();
            AnalyseKlasse = new Analyse();

            updateUI = new Thread(() => updateListe());

            UILISTE = new List<double>();
            observers = new List<IObserver>();
            FiltreretListe = new List<double>();
            databasetal = new List<double>();
            minKø = new Queue<double>(100);

            beregnetNværdi = 0.0;
            counter = 0;
            kalibreringKoef = KalibreringObjekt.Kalibrer();

            DAQdata.Attach(this);

            for (int i = 0; i < 299; i++)
            {
                UILISTE.Add(0);
            }
        }

        public IEnumerable<HistoryItem> Build(WorkflowObject workflowObject, Filter actEntryFilter)
        {
            var clarifyDataSet = _session.CreateDataSet();

            var workflowObjectInfo = WorkflowObjectInfo.GetObjectInfo(workflowObject.Type);
            var workflowGeneric = clarifyDataSet.CreateGenericWithFields(workflowObjectInfo.ObjectName);
            workflowGeneric.AppendFilter(workflowObjectInfo.IDFieldName, StringOps.Equals, workflowObject.Id);

            var inverseActivityRelation = workflowObjectInfo.ActivityRelation;
            var activityRelation = _schemaCache.GetRelation("act_entry", inverseActivityRelation).InverseRelation;

            var actEntryGeneric = workflowGeneric.Traverse(activityRelation.Name);
            actEntryGeneric.AppendSort("entry_time", false);

            if (actEntryFilter != null)
            {
                actEntryGeneric.Filter.AddFilter(actEntryFilter);
            }

            var templateDictionary = _templatePolicyConfiguration.RenderPolicies(workflowObject);

            //query generic hierarchy and while using act entry templates transform the results into HistoryItems
            var assembler = _container.With(templateDictionary).With(workflowObject).GetInstance<HistoryItemAssembler>();
            return assembler.Assemble(actEntryGeneric);
        }

 /// <summary>
 /// Create <see cref="RangeFacetCounts"/> </summary>
 protected internal RangeFacetCounts(string field, Range[] ranges, Filter fastMatchFilter)
 {
     this.field = field;
     this.ranges = ranges;
     this.fastMatchFilter = fastMatchFilter;
     counts = new int[ranges.Length];
 }