public InstrumentationModelBuilderFactory(ICommandLine commandLine, IFilter filter, ILog logger, IEnumerable<ITrackedMethodStrategy> trackedMethodStrategies)
 {
     _commandLine = commandLine;
     _filter = filter;
     _logger = logger;
     MethodStrategies = trackedMethodStrategies;
 }

        /// <summary>
        /// This method returns the query string for 'GetFeature'.
        /// </summary>
        /// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
        /// <param name="labelProperty"></param>
        /// <param name="boundingBox">The bounding box of the query</param>
        /// <param name="filter">An instance implementing <see cref="IFilter"/></param>
        public string GetFeatureGETRequest(WfsFeatureTypeInfo featureTypeInfo, string labelProperty, BoundingBox boundingBox, IFilter filter)
        {
            string qualification = string.IsNullOrEmpty(featureTypeInfo.Prefix)
                                       ? string.Empty
                                       : featureTypeInfo.Prefix + ":";
            string filterString = string.Empty;

            if (filter != null)
            {
                filterString = filter.Encode();
                filterString = filterString.Replace("<", "%3C");
                filterString = filterString.Replace(">", "%3E");
                filterString = filterString.Replace(" ", "");
                filterString = filterString.Replace("*", "%2a");
                filterString = filterString.Replace("#", "%23");
                filterString = filterString.Replace("!", "%21");
            }

            var filterBuilder = new StringBuilder();
            filterBuilder.Append("&filter=%3CFilter%20xmlns=%22" + NSOGC + "%22%20xmlns:gml=%22" + NSGML +
                                 "%22%3E%3CBBOX%3E%3CPropertyName%3E");
            filterBuilder.Append(qualification).Append(featureTypeInfo.Geometry.GeometryName);
            filterBuilder.Append("%3C/PropertyName%3E%3Cgml:Box%20srsName=%22" + featureTypeInfo.SRID + "%22%3E");
            filterBuilder.Append("%3Cgml:coordinates%3E");
            filterBuilder.Append(XmlConvert.ToString(boundingBox.Left) + ",");
            filterBuilder.Append(XmlConvert.ToString(boundingBox.Bottom) + "%20");
            filterBuilder.Append(XmlConvert.ToString(boundingBox.Right) + ",");
            filterBuilder.Append(XmlConvert.ToString(boundingBox.Top));
            filterBuilder.Append("%3C/gml:coordinates%3E%3C/gml:Box%3E%3C/BBOX%3E");
            filterBuilder.Append(filterString);
            filterBuilder.Append("%3C/Filter%3E");

            return "?SERVICE=WFS&Version=1.0.0&REQUEST=GetFeature&TYPENAME=" + qualification + featureTypeInfo.Name +
                   "&SRS =" + featureTypeInfo.SRID + filterBuilder;
        }

 public ConsoleAppender(ISubmitConsoleLogEntry consoleLogEntrySubmitter, bool forceConsoleOutput, IFilter filter, IColorSchema colorSchema)
 {
     m_consoleLogEntrySubmitter = consoleLogEntrySubmitter;
     m_colorSchema = colorSchema;
     m_filter = filter;
     if (forceConsoleOutput)
     {
         m_isConsoleOutputAvaliable = true;
     }
     else
     {
         if (IsRunningOnMono)
         {
             m_isConsoleOutputAvaliable = true;
         }
         else // Windows
         {
             IntPtr iStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
             if (iStdOut == IntPtr.Zero)
             {
                 m_isConsoleOutputAvaliable = false;
             }
             else
             {
                 m_isConsoleOutputAvaliable = true;
             }
         }
     }
 }

		private static void WriteProperty(JsonWriter writer, IFilter filter, string field, object value)
		{
			if ((field.IsNullOrEmpty() || value == null))
				return;
			writer.WritePropertyName(field);
			writer.WriteValue(value);
		}

 /// <summary>
 /// Createa a new <see cref="DynamicApiActionInfo"/> object.
 /// </summary>
 /// <param name="actionName">Name of the action in the controller</param>
 /// <param name="verb">The HTTP verb that is used to call this action</param>
 /// <param name="method">The method which will be invoked when this action is called</param>
 public DynamicApiActionInfo(string actionName, HttpVerb verb, MethodInfo method, IFilter[] filters = null)
 {
     ActionName = actionName;
     Verb = verb;
     Method = method;
     Filters = filters ?? new IFilter[] { }; //Assigning or initialzing the action filters.
 }

		/// <summary>
		/// Hll ＝ Hrr, Hlr ＝ Hrlの場合。
		/// </summary>
		/// <param name="ll">特性 Hll を持つフィルタ</param>
		/// <param name="lr">特性 Hlr を持つフィルタ</param>
		public CrossStereoFilter(IFilter ll, IFilter lr)
		{
			this.ll = ll;
			this.lr = lr;
			this.rl = (IFilter)lr.Clone();
			this.rr = (IFilter)ll.Clone();
		}

		public FilteredSerializationDataProvider(string connectionStringName, IFilter filter)
			: base(connectionStringName)
		{
			Assert.ArgumentNotNull(filter, "filter");

			_filter = filter;
		}

        private void ApplyFilter(IFilter filter)
        {
            try
            {
                // set wait cursor
                this.Cursor = Cursors.WaitCursor;

                // apply filter to the image
                Bitmap newImage = filter.Apply((Bitmap)this.Image.Image);

                if (backup == null)
                {
                    backup = this.Image.Image;
                }

                this.Image.Image = newImage;

            }
            catch (ArgumentException)
            {
                MessageBox.Show("Selected filter can not be applied to the image", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                this.Cursor = Cursors.Default;
            }
        }

        protected virtual bool MatchesFilterConditions(LoggingEvent loggingEvent, IFilter filter)
        {
            if (filter.MinLevel != LoggingEventLevel.None && loggingEvent.Level < filter.MinLevel)
                return false;

            if (filter.MaxLevel != LoggingEventLevel.None && loggingEvent.Level > filter.MaxLevel)
                return false;

            if (!filter.LogKeyContains.IsNullOrEmpty() && loggingEvent.LogKey.IndexOf(filter.LogKeyContains, StringComparison.OrdinalIgnoreCase) < 0)
                return false;

            if (!filter.LogKeyStartsWith.IsNullOrEmpty() && !loggingEvent.LogKey.StartsWith(filter.LogKeyStartsWith, StringComparison.OrdinalIgnoreCase))
                return false;

            if (!filter.TextContains.IsNullOrEmpty() && loggingEvent.Text.IndexOf(filter.TextContains, StringComparison.OrdinalIgnoreCase) < 0)
                return false;

            if (!filter.TextStartsWith.IsNullOrEmpty() && !loggingEvent.Text.StartsWith(filter.TextStartsWith, StringComparison.OrdinalIgnoreCase))
                return false;

            if (filter.MinValue.HasValue && loggingEvent.Value.HasValue && loggingEvent.Value.Value < filter.MinValue.Value)
                return false;

            if (filter.MaxValue.HasValue && loggingEvent.Value.HasValue && loggingEvent.Value.Value > filter.MaxValue.Value)
                return false;

            if (!filter.TagsContains.IsNullOrEmpty())
            {
                var requiredTags = TagHelpers.Clean(filter.TagsContains);
                if (!requiredTags.All(x => loggingEvent.Tags.Contains(x, StringComparer.OrdinalIgnoreCase)))
                    return false;
            }

            return true;
        }

 public CecilSymbolManager(ICommandLine commandLine, IFilter filter, ILog logger, IEnumerable<ITrackedMethodStrategy> trackedMethodStrategies)
 {
     _commandLine = commandLine;
     _filter = filter;
     _logger = logger;
     _trackedMethodStrategies = trackedMethodStrategies ?? new ITrackedMethodStrategy[0];
 }

        private void SetFilter(string propertyName, IFilter filter)
        {
            if (updateFilterTimer != null)
            {
                updateFilterTimer.Dispose();
                updateFilterTimer = null;
            }

            if (filters.ContainsKey(propertyName))
            {
                if (filter == null)
                    filters.Remove(propertyName);
                else
                    filters[propertyName] = filter;
            }
            else
            {
                if (filter != null)
                    filters.Add(propertyName, filter);
            }

            updateFilterTimer = new Timer((s) => 
            {
                var scheduler = (TaskScheduler)s;
                updateFilterTimer.Dispose();
                updateFilterTimer = null;

                Task.Factory.StartNew(() => Source.SetFilter(filters.Select(f => new PropertyFilter(f.Key, f.Value)).ToArray(), CancellationToken.None), CancellationToken.None, TaskCreationOptions.None, scheduler);
            }, TaskScheduler.FromCurrentSynchronizationContext(), TimeSpan.FromMilliseconds(200), TimeSpan.FromTicks(0));
        }

 public InstrumentationModelBuilderFactory(ICommandLine commandLine, IFilter filter, ILog logger, ITrackedMethodStrategyManager trackedMethodStrategyManager)
 {
     _commandLine = commandLine;
     _filter = filter;
     _logger = logger;
     _trackedMethodStrategyManager = trackedMethodStrategyManager;
 }

 /// <summary>
 /// 初始化一个新的<see cref="DynamicApiActionInfo"/>实例
 /// </summary>
 /// <param name="actionName">Action 名称</param>
 /// <param name="verb">HTTP Verb</param>
 /// <param name="method">一个方法信息，随着 Action 的调用而调用</param>
 /// <param name="filters">用于 Controller Action 的动态筛选器</param>
 public DynamicApiActionInfo(string actionName, HttpVerbs verb, MethodInfo method, IFilter[] filters = null)
 {
     ActionName = actionName;
     Verb = verb;
     Method = method;
     Filters = filters ?? new IFilter[] { };
 }

 public FilterValue(string title, IFilter filter, IFilter selectAttributeFilter, MLFilterCriterion criterion)
 {
   _title = title;
   _filter = filter;
   _selectAttributeFilter = selectAttributeFilter;
   _criterion = criterion;
 }

 public override ICollection<FilterValue> GetAvailableValues(IEnumerable<Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
 {
   IContentDirectory cd = ServiceRegistration.Get<IServerConnectionManager>().ContentDirectory;
   if (cd == null)
     throw new NotConnectedException("The MediaLibrary is not connected");
   HomogenousMap valueGroups = cd.GetValueGroups(MediaAspect.ATTR_RECORDINGTIME, null, ProjectionFunction.DateToYear,
       necessaryMIATypeIds, filter, true);
   IList<FilterValue> result = new List<FilterValue>(valueGroups.Count);
   int numEmptyEntries = 0;
   foreach (KeyValuePair<object, object> group in valueGroups)
   {
     int? year = (int?) group.Key;
     if (year.HasValue)
     {
       result.Add(new FilterValue(year.Value.ToString(),
           new BooleanCombinationFilter(BooleanOperator.And, new IFilter[]
             {
                 new RelationalFilter(MediaAspect.ATTR_RECORDINGTIME, RelationalOperator.GE, new DateTime(year.Value, 1, 1)),
                 new RelationalFilter(MediaAspect.ATTR_RECORDINGTIME, RelationalOperator.LT, new DateTime(year.Value + 1, 1, 1)),
             }), null, (int) group.Value, this));
     }
     else
       numEmptyEntries += (int) group.Value;
   }
   if (numEmptyEntries > 0)
     result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(MediaAspect.ATTR_RECORDINGTIME), null, numEmptyEntries, this));
   return result;
 }

		private static void SerializeProperty(JsonWriter writer, JsonSerializer serializer , IFilter filter, string field, object value)
		{
			if ((field.IsNullOrEmpty() || value == null))
				return;
			writer.WritePropertyName(field);
			serializer.Serialize(writer, value);
		}

 // Apply filter on the image
 private static void ApplyFilter(IFilter filter, ref Bitmap image)
 {
     if (filter is IFilterInformation)
     {
         IFilterInformation filterInfo = (IFilterInformation)filter;
         if (!filterInfo.FormatTransalations.ContainsKey(image.PixelFormat))
         {
             if (filterInfo.FormatTransalations.ContainsKey(PixelFormat.Format24bppRgb))
             {
                 MessageBox.Show("The selected image processing routine may be applied to color image only.",
                                 "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
             }
             else
             {
                 MessageBox.Show(
                     "The selected image processing routine may be applied to grayscale or binary image only.\n\nUse grayscale (and threshold filter if required) before.",
                     "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
             }
             return;
         }
     }
     try
     {
         // apply filter to the image
         image = filter.Apply(image);
     }
     catch
     {
         MessageBox.Show("Error occured applying selected filter to the image", "Error", MessageBoxButtons.OK,
                         MessageBoxIcon.Error);
     }
 }

 public SerfidCore(IListener listener, IFilter filter, IStorage storage, IUser user)
 {
     _listener = listener;
     _filter = filter;
     _storage = storage;
     _user = user;
 }

        private static void FillFilterParameterAttributes(FilterSerializerData filterSerializerData, IFilter filter, Type filterType, FilterBindingContext context)
        {
            var propertyInfos = filterType.GetProperties().ToList();

            foreach (var propertyInfo in propertyInfos)
            {
                var filterParameterAttribute = AttributeRetrieval.GetAttribute<FilterParameterAttribute>(propertyInfo);
                if (filterParameterAttribute == null)
                {
                    continue;
                }

                //get the value set or bound to the parameter
                var value = GetFilterSerializationBindingValue(filterParameterAttribute, propertyInfo, context, filter);

                //run validation on the parameter to ensure that it meets all standards
                RunFilterSerializationValidation(filterType, propertyInfo, value);

                //run formatter on the validated value
                var filterPropertyFormattedValue = RunFilterSerializationFormat(filterParameterAttribute, filterType, propertyInfo, value);

                var filterPropertyIsDefault = filterParameterAttribute.Default != null
                                              && value != null
                                              && filterParameterAttribute.Default.Equals(value);

                filterSerializerData.Parameters.Add(new FilterSerializerDataParameter
                {
                    Name = filterParameterAttribute.Name,
                    Value = filterPropertyFormattedValue,
                    Parameter = filterParameterAttribute,
                    IsDefault = filterPropertyIsDefault
                });
            }
        }

 public override ICollection<FilterValue> GetAvailableValues(IEnumerable<Guid> necessaryMIATypeIds, IFilter selectAttributeFilter, IFilter filter)
 {
   IServerConnectionManager serverConnectionManager = ServiceRegistration.Get<IServerConnectionManager>();
   IServerController serverController = serverConnectionManager.ServerController;
   if (serverController == null)
     throw new NotConnectedException("The MediaLibrary is not connected");
   IDictionary<string, string> systemNames = new Dictionary<string, string>();
   foreach (MPClientMetadata client in serverController.GetAttachedClients())
     systemNames.Add(client.SystemId, client.LastClientName);
   systemNames.Add(serverConnectionManager.HomeServerSystemId, serverConnectionManager.LastHomeServerName);
   IContentDirectory cd = ServiceRegistration.Get<IServerConnectionManager>().ContentDirectory;
   if (cd == null)
     return new List<FilterValue>();
   HomogenousMap valueGroups = cd.GetValueGroups(ProviderResourceAspect.ATTR_SYSTEM_ID, null, ProjectionFunction.None, necessaryMIATypeIds, filter, true);
   IList<FilterValue> result = new List<FilterValue>(valueGroups.Count);
   int numEmptyEntries = 0;
   foreach (KeyValuePair<object, object> group in valueGroups)
   {
     string name = group.Key as string ?? string.Empty;
     name = name.Trim();
     if (name == string.Empty)
       numEmptyEntries += (int) group.Value;
     else
     {
       string systemName;
       if (systemNames.TryGetValue(name, out systemName) && !string.IsNullOrEmpty(systemName))
         name = systemName;
       result.Add(new FilterValue(name,
           new RelationalFilter(ProviderResourceAspect.ATTR_SYSTEM_ID, RelationalOperator.EQ, group.Key), null, (int) group.Value, this));
     }
   }
   if (numEmptyEntries > 0)
     result.Insert(0, new FilterValue(Consts.RES_VALUE_EMPTY_TITLE, new EmptyFilter(ProviderResourceAspect.ATTR_SYSTEM_ID), null, numEmptyEntries, this));
   return result;
 }