/// <summary> /// Creates an IIR filter from zeros and poles. The zeros and poles must be made up of real and complex conjugate pairs. /// </summary> public IirFilter(ZeroPoleGain zeroPoleGain) { Debug.Assert(zeroPoleGain.Zeros.Length == zeroPoleGain.Poles.Length); this.zeroPoleGain = zeroPoleGain; transferFunction = FilterModifiers.ConvertSosToTransferFunction(sosGain); sosGain = FilterModifiers.ConvertZeroPoleToSosFilter(zeroPoleGain); this.sections = new FilterChain(sosGain.Sections); this.order = sosGain.Sections.Sum(x => x.Order); //Check whether this is linear phase double[] b = transferFunction.B; isLinearPhase = true; for (int i = 0; i < b.Length; i++) { if (b[i] != b[b.Length - 1 - i] && b[i] != -b[b.Length - 1 - i]) { isLinearPhase = false; break; } } return; }
public void TestFilterChainT1() { var chain = new FilterChain <string>(); var data = "123"; var isCall = false; chain.Add((inData, next) => { if (inData == data) { isCall = true; } next(inData); }); chain.Add((in1Data, next) => { next(in1Data); }); var completeCall = false; chain.Do(data, (in1) => { completeCall = true; }); Assert.AreEqual(2, chain.FilterList.Length); Assert.AreEqual(true, isCall); Assert.AreEqual(true, completeCall); }
public static FilterBase GetFilter(XmlNode settingsNode, FilterChain parentChain) { if (settingsNode.Attributes["name"] == null) { throw new Exception(String.Format("Filter \"{0}\" in chain \"{1}\" has no \"name\" attribute", settingsNode.Name, parentChain.Name)); } FilterBase thisFilter = (FilterBase)Utils.CreateObject("Blend.Ellis.Filters." + Utils.ConvertToMixedCase(settingsNode.Name)); //If we're still null, then this filter doesn't exist. Life is hard that way. People are mean, dogs bite, and cheeseburgers make you fat... if (thisFilter == null) { throw new Exception(String.Format("Cannot load filter \"{0}\" in chain \"{1}\"", settingsNode.Name)); } //Load up its settings SettingsIndex settings = new SettingsIndex(); foreach (XmlAttribute attribute in settingsNode.Attributes) { settings.Add(attribute.Name, attribute.Value); } thisFilter.Settings = settings; thisFilter.Name = settingsNode.Attributes["name"].Value; //Run the initialization thisFilter.Initialize(); return thisFilter; }
public void TestNullThen() { var chain1 = new FilterChain <string>(); chain1.Add((str, next) => { }); chain1.Add((str, next) => { }); ExceptionAssert.DoesNotThrow(() => { chain1.Do(null); }); var chain2 = new FilterChain <string, string>(); chain2.Add((str, str1, next) => { }); chain2.Add((str, str1, next) => { }); ExceptionAssert.DoesNotThrow(() => { chain2.Do(null, null); }); var chain3 = new FilterChain <string, string, string>(); chain3.Add((str, str1, str2, next) => { }); chain3.Add((str, str1, str2, next) => { }); ExceptionAssert.DoesNotThrow(() => { chain3.Do(null, null, null); }); }
public void TestFilterChainT1T2T3() { var chain = new FilterChain <string, string, string>(); var data1 = "123"; var data2 = "222"; var data3 = "333"; var isCall = false; chain.Add((in1Data, in2Data, in3Data, next) => { if (in1Data == data1 && in2Data == data2 && in3Data == data3) { isCall = true; } next(in1Data, in2Data, in3Data); }); chain.Add((in1Data, in2Data, in3Data, next) => { next(in1Data, in2Data, in3Data); }); var completeCall = false; chain.Do(data1, data2, data3, (in1, in2, in3) => { completeCall = true; }); Assert.AreEqual(2, chain.FilterList.Length); Assert.AreEqual(true, isCall); Assert.AreEqual(true, completeCall); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public void doFilter(final ServletRequest req, final ServletResponse resp, FilterChain chain) throws java.io.IOException, ServletException //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: public override void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final boolean isContentTypeJson = CONTENT_TYPE_JSON_PATTERN.matcher(req.getContentType() == null ? "" : req.getContentType()).find(); bool isContentTypeJson = CONTENT_TYPE_JSON_PATTERN.matcher(req.ContentType == null ? "" : req.ContentType).find(); if (isContentTypeJson) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.io.PushbackInputStream requestBody = new java.io.PushbackInputStream(req.getInputStream()); PushbackInputStream requestBody = new PushbackInputStream(req.InputStream); int firstByte = requestBody.read(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final boolean isBodyEmpty = firstByte == -1; bool isBodyEmpty = firstByte == -1; requestBody.unread(firstByte); HttpServletRequestWrapper wrappedRequest = new HttpServletRequestWrapperAnonymousInnerClass(this, (HttpServletRequest) req, requestBody, isBodyEmpty); chain.doFilter(wrappedRequest, resp); } else { chain.doFilter(req, resp); } }
/// <summary> /// Reads a file filtering its content through the filter chain. /// </summary> /// <param name="fileName">The file to read.</param> /// <param name="filterChain">Chain of filters to apply when reading, or <see langword="null" /> is no filters should be applied.</param> /// <param name="inputEncoding">The encoding used to read the file.</param> /// <remarks> /// If <paramref name="inputEncoding" /> is <see langword="null" />, /// then the system's ANSI code page will be used to read the file. /// </remarks> public static string ReadFile(string fileName, FilterChain filterChain, Encoding inputEncoding) { string content = null; // determine character encoding to use Encoding encoding = (inputEncoding != null) ? inputEncoding : Encoding.Default; // read file using (StreamReader sr = new StreamReader(fileName, encoding, true)) { if (filterChain == null || filterChain.Filters.Count == 0) { content = sr.ReadToEnd(); } else { Filter baseFilter = filterChain.GetBaseFilter( new PhysicalTextReader(sr)); StringWriter sw = new StringWriter(); while (true) { int character = baseFilter.Read(); if (character == -1) { break; } sw.Write((char)character); } content = sw.ToString(); } } return(content); }
/// <summary> /// Moves a file filtering its content through the filter chain. /// </summary> /// <param name="sourceFileName"> /// The file to move. /// </param> /// <param name="destFileName"> /// The file to move move to. /// </param> /// <param name="filterChain"> /// Chain of filters to apply when moving, or <see langword="null" /> is no /// filters should be applied. /// </param> /// <param name="inputEncoding"> /// The encoding used to read the soure file. /// </param> /// <param name="outputEncoding"> /// The encoding used to write the destination file. /// </param> public static void MoveFile( string sourceFileName, string destFileName, FilterChain filterChain, Encoding inputEncoding, Encoding outputEncoding) { // If the source file does not exist, throw an exception. if (!File.Exists(sourceFileName)) { throw new BuildException( String.Format("Cannot move file: Source File {0} does not exist", sourceFileName)); } // if no filters have been defined, and no input or output encoding // is set, we can just use the File.Move method if (FilterChain.IsNullOrEmpty(filterChain) && inputEncoding == null && outputEncoding == null) { File.Move(sourceFileName, destFileName); } else { CopyFile(sourceFileName, destFileName, filterChain, inputEncoding, outputEncoding); File.Delete(sourceFileName); } }
private void LoadFile(FilterChain filterChain) { string content = null; try { content = FileUtils.ReadFile(File.FullName, filterChain, Encoding); } catch (IOException ex) { throw new BuildException("The properties file could not be read.", Location, ex); } PropertyDictionary properties = Project.Properties; PropertyTask propertyTask = new PropertyTask(); propertyTask.Parent = this; propertyTask.Project = Project; using (StringReader sr = new StringReader(content)) { string line = sr.ReadLine(); int current_line = 0; while (line != null) { current_line++; // skip empty lines and comments if (String.IsNullOrEmpty(line) || line.StartsWith("#")) { line = sr.ReadLine(); continue; } int equals_pos = line.IndexOf('='); if (equals_pos == -1) { throw new BuildException(string.Format(CultureInfo.InvariantCulture, "Invalid property defined on line {0}.", current_line), Location); } string name = line.Substring(0, equals_pos).Trim(); string value = line.Substring(equals_pos + 1, line.Length - equals_pos - 1).Trim(); string expandedValue = properties.ExpandProperties(value, Location); propertyTask.PropertyName = name; propertyTask.Value = expandedValue; propertyTask.Execute(); line = sr.ReadLine(); } } }
private IFilter <MediaInstance> ConstructFilter(SearchMediaData searchMediaData, IGraph <Tag> tagGraph) { var tagFilter = new TagFilter(searchMediaData.IncludedTags, searchMediaData.ExcludedTags, tagGraph); var timeRangeFilter = new TimeRangeFilter(searchMediaData.TimeRangeStart, searchMediaData.TimeRangeEnd); var privateMediaFilter = new PrivateMediaFilter(searchMediaData.UserId); var filterChain = new FilterChain <MediaInstance>(tagFilter, timeRangeFilter, privateMediaFilter); return(filterChain); }
public Apu() { Pulse1 = new PulseGenerator(1); Pulse2 = new PulseGenerator(2); Triangle = new TriangleGenerator(); Noise = new NoiseGenerator(); Dmc = new DmcGenerator(); filterChain = new FilterChain(); }
/// <summary> /// /// </summary> /// <param name="sourceFile"></param> /// <param name="targetFile"></param> /// <param name="filterChain"></param> public void ProcessFile(string sourceFile, string targetFile, FilterChain filterChain) { if (File.Exists(sourceFile)) { //-------------------------------------------------------------------------- // Get handler for the file type //-------------------------------------------------------------------------- IColorFileHandler <string> schemeHandler; IColorFileHandler <Bitmap> bitmapHandler; try { schemeHandler = _schemeHandlerRegister.GetHandlerForFile(sourceFile); bitmapHandler = _bitmapHandlerRegister.GetHandlerForFile(sourceFile); } catch (Exception e) { Console.WriteLine($"Multiple file processing units found for: {sourceFile}"); return; } if (schemeHandler == null && bitmapHandler == null) { Console.WriteLine($"{sourceFile} is not supported color scheme format"); return; } if (schemeHandler != null && bitmapHandler != null) { Console.WriteLine($"Multiple file processing units found for: {sourceFile}"); return; } //-------------------------------------------------------------------------- // Process file //-------------------------------------------------------------------------- if (bitmapHandler != null) { var processor = new ColorFileProcessor <Bitmap>(bitmapHandler); processor.ProcessFile(sourceFile, targetFile, filterChain); } else if (schemeHandler != null) { var processor = new ColorFileProcessor <string>(schemeHandler); processor.ProcessFile(sourceFile, targetFile, filterChain); } else { Console.WriteLine($"{sourceFile} is not supported color scheme format"); return; } } else { Console.Error.WriteLine(sourceFile + " does not exist"); } }
public static LiquidExpressionResult Eval( LiquidExpression expression, IEnumerable <Option <ILiquidValue> > leaves, ITemplateContext templateContext) { // calculate the first part of the expression var objResult = expression.Expression == null? LiquidExpressionResult.Success(new None <ILiquidValue>()) : expression.Expression.Eval(templateContext, leaves); if (objResult.IsError) { return(objResult); } // Compose a chain of filters, making sure type-casting // is done between them. //IEnumerable<Tuple<FilterSymbol, IFilterExpression>> filterExpressionTuples; // try // { var filterExpressionTuples = expression.FilterSymbols.Select(symbol => new Tuple <FilterSymbol, Try <IFilterExpression> >(symbol, InstantiateFilter(templateContext, symbol))) .ToList(); //} //catch (Exception ex) //{ // return LiquidExpressionResult.Error(ex.Message); //} if (filterExpressionTuples.Any(x => x.Item2.IsFailure)) { // just return the first error. return(LiquidExpressionResult.Error(filterExpressionTuples.First().Item2.Exception.Message)); } var erroringFilternames = filterExpressionTuples.Where(x => x.Item2 == null).Select(x => x.Item1).ToList(); if (erroringFilternames.Any()) { //throw new Exception("Missing filters..."); //return ConstantFactory.CreateError<LiquidString>(); return(LiquidExpressionResult.Error("Missing filters: " + String.Join(", ", erroringFilternames.Select(x => x.Name)))); } var filterChain = FilterChain.CreateChain( objResult.GetType(), templateContext, filterExpressionTuples.Select(x => x.Item2.Value)); // apply the composed function to the object var result = filterChain(objResult.SuccessResult); return(result); }
public int ReplaceStringCount(String refID) { if (!this.Project.DataTypeReferences.Contains(refID)) { throw new BuildException(String.Format("The refid {0} is not defined.", refID)); } FilterChain RefFilterChain = (FilterChain)this.Project.DataTypeReferences[refID]; return(RefFilterChain.Filters.Count); }
private void RequestHandler(object sender, EventArgs e) { HttpApplication httpApplication = (HttpApplication)sender; if (httpApplication.Request.RawUrl.IndexOf("/") > 0) { FilterChain chain = new FilterChain(new HttpUrlFilter()); chain.DoFilter(httpApplication.Request, httpApplication.Response); httpApplication.Context.RemapHandler(handler); } }
/// <exception cref="System.IO.IOException"/> /// <exception cref="Javax.Servlet.ServletException"/> public void DoFilter(ServletRequest request, ServletResponse response, FilterChain chain) { if (authorized) { chain.DoFilter(request, response); } else { ((HttpServletResponse)response).SendError(HttpServletResponse.ScForbidden); } }
private void buildChainOfFilters(out FilterChain o_ImageFilter) { NegativeFilter negativeFilter = new NegativeFilter(); RedFilter redFilter = new RedFilter(); GreenFilter greenFilter = new GreenFilter(); BlueFilter blueFilter = new BlueFilter(); negativeFilter.SetNextChain(redFilter); redFilter.SetNextChain(greenFilter); greenFilter.SetNextChain(blueFilter); o_ImageFilter = negativeFilter; }
/// <exception cref="System.IO.IOException"/> /// <exception cref="Javax.Servlet.ServletException"/> public virtual void DoFilter(ServletRequest req, ServletResponse res, FilterChain chain) { HttpServletResponse httpRes = (HttpServletResponse)res; httpRes.SetHeader("Cache-Control", "no-cache"); long now = Runtime.CurrentTimeMillis(); httpRes.AddDateHeader("Expires", now); httpRes.AddDateHeader("Date", now); httpRes.AddHeader("Pragma", "no-cache"); chain.DoFilter(req, res); }
/// <summary> /// Moves a file filtering its content through the filter chain. /// </summary> /// <param name="sourceFileName">The file to move.</param> /// <param name="destFileName">The file to move move to.</param> /// <param name="filterChain">Chain of filters to apply when moving, or <see langword="null" /> is no filters should be applied.</param> /// <param name="inputEncoding">The encoding used to read the soure file.</param> /// <param name="outputEncoding">The encoding used to write the destination file.</param> public static void MoveFile(string sourceFileName, string destFileName, FilterChain filterChain, Encoding inputEncoding, Encoding outputEncoding) { // if no filters have been defined, and no input or output encoding // is set, we can just use the File.Move method if ((filterChain == null || filterChain.Filters.Count == 0) && inputEncoding == null && outputEncoding == null) { File.Move(sourceFileName, destFileName); } else { CopyFile(sourceFileName, destFileName, filterChain, inputEncoding, outputEncoding); File.Delete(sourceFileName); } }
public void AddReplaceString(String refID, String oldValue, String newValue) { if (!this.Project.DataTypeReferences.Contains(refID)) { throw new BuildException(String.Format("The refid {0} is not defined.", refID)); } FilterChain RefFilterChain = (FilterChain)this.Project.DataTypeReferences[refID]; ReplaceString ReplaceStringFilter = new ReplaceString(); ReplaceStringFilter.From = oldValue; ReplaceStringFilter.To = newValue; RefFilterChain.Filters.Add(ReplaceStringFilter); }
public void NoFilterChainCallT1() { var chain = new FilterChain <string>(); var isCall = false; chain.Do("", (i) => { isCall = !isCall; }); chain.Do(""); Assert.AreEqual(true, isCall); }
/// <exception cref="System.IO.IOException"/> /// <exception cref="Javax.Servlet.ServletException"/> protected override void DoFilter(FilterChain filterChain, HttpServletRequest request , HttpServletResponse response) { bool requestCompleted = false; UserGroupInformation ugi = null; AuthenticationToken authToken = (AuthenticationToken)request.GetUserPrincipal(); if (authToken != null && authToken != AuthenticationToken.Anonymous) { // if the request was authenticated because of a delegation token, // then we ignore proxyuser (this is the same as the RPC behavior). ugi = (UserGroupInformation)request.GetAttribute(DelegationTokenAuthenticationHandler .DelegationTokenUgiAttribute); if (ugi == null) { string realUser = request.GetUserPrincipal().GetName(); ugi = UserGroupInformation.CreateRemoteUser(realUser, handlerAuthMethod); string doAsUser = GetDoAs(request); if (doAsUser != null) { ugi = UserGroupInformation.CreateProxyUser(doAsUser, ugi); try { ProxyUsers.Authorize(ugi, request.GetRemoteHost()); } catch (AuthorizationException ex) { HttpExceptionUtils.CreateServletExceptionResponse(response, HttpServletResponse.ScForbidden , ex); requestCompleted = true; } } } UgiTl.Set(ugi); } if (!requestCompleted) { UserGroupInformation ugiF = ugi; try { request = new _HttpServletRequestWrapper_269(this, ugiF, request); base.DoFilter(filterChain, request, response); } finally { UgiTl.Remove(); } } }
static void Main(string[] args) { if (args.Length < 0) { return; } PeakMeter peakMeter1 = new PeakMeter(); Amplifier amplifier = new Amplifier(AudioTools.dBFSToLinearf(12f)); PeakLimiter limiter = new PeakLimiter(20, 20, AudioTools.dBFSToLinearf(-3.0f)); PeakMeter peakMeter2 = new PeakMeter(); FilterChain filterChain = new FilterChain(); filterChain.Filters.Add(peakMeter1); filterChain.Filters.Add(amplifier); filterChain.Filters.Add(limiter); filterChain.Filters.Add(peakMeter2); WaveFileReader waveFileReader = new WaveFileReader(args[0]); waveFileReader.Position = 0; byte[] byteBuffer = new byte[10 * 1024]; float [] floatBuffer = null; int bytesRead = 0, samplesAvailable = 0; filterChain.Init(waveFileReader.WaveFormat.SampleRate, waveFileReader.WaveFormat.Channels); int processed = 0; while (true) { bytesRead = waveFileReader.Read(byteBuffer, 0, 10 * 1024); if (bytesRead == 0) { break; } AudioBufferConverter.ConvertByteArrayToFloatArray(byteBuffer, bytesRead, waveFileReader.WaveFormat.BitsPerSample, ref floatBuffer, ref samplesAvailable); filterChain.ProcessFrames(floatBuffer, samplesAvailable); processed += bytesRead; } System.Console.WriteLine("processed: " + processed); System.Console.WriteLine("peak1: " + peakMeter1.GlobalPeakSinceStartdBFS); System.Console.WriteLine("peak2: " + peakMeter2.GlobalPeakSinceStartdBFS); System.Console.ReadKey(); }
/// <summary> /// Ends receive operation. /// </summary> /// <param name="buf">the buffer received in last receive operation</param> protected void EndReceive(IoBuffer buf) { if (ReadSuspended) { _pendingReceivedMessage = buf; } else { FilterChain.FireMessageReceived(buf); if (Socket.Connected) { BeginReceive(); } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldPassThroughRequestsWithNullServletPath() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldPassThroughRequestsWithNullServletPath() { // given HttpServletRequest request = mock(typeof(HttpServletRequest)); when(request.ServletPath).thenReturn(null); HttpServletResponse response = mock(typeof(HttpServletResponse)); FilterChain filterChain = mock(typeof(FilterChain)); // when (new StaticContentFilter()).DoFilter(request, response, filterChain); // then verifyZeroInteractions(response); verify(filterChain).doFilter(request, response); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws java.io.IOException, ServletException public virtual void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final javax.servlet.http.HttpServletRequest request = (javax.servlet.http.HttpServletRequest) req; HttpServletRequest request = (HttpServletRequest)req; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final javax.servlet.http.HttpServletResponse response = (javax.servlet.http.HttpServletResponse) resp; HttpServletResponse response = (HttpServletResponse)resp; if ("GET".Equals(request.Method) && !request.RequestURI.EndsWith("xml")) { response.setHeader("Cache-Control", "no-cache"); } chain.doFilter(req, resp); }
public void ProcessFile(string sourceFile, string targetFile, FilterChain filters) { Console.WriteLine("Applying filters:"); var data = _handler.ReadFile(sourceFile); T filteredData; try { filteredData = ApplyFilters(data, filters); } catch (Exception ex) { Console.WriteLine(GetType().FullName + " : " + ex.Message); throw; } _handler.WriteFile(filteredData, targetFile); }
public void It_Should_Cast_MisMatched_Filters() { // Arrange var filters = new List <IFilterExpression> { new UpCaseFilter(), new PlusFilter(LiquidNumeric.Create(123)), }; // Act var castedFilters = FilterChain.InterpolateCastFilters(filters).ToList(); // Assert Assert.That(castedFilters.Count, Is.EqualTo(3)); Assert.That(castedFilters[1], Is.TypeOf(typeof(CastFilter <LiquidString, LiquidNumeric>))); }
/// <summary> /// 过滤站点html /// </summary> /// <param name="html"></param> /// <param name="filter"></param> /// <returns></returns> private static string FilterHtml(string html, string filter) { if (filter == null || filter == "") { return(html); } FilterChain chain = LoadFilter(filter); if (chain.Count() > 0) { html = chain.DoFilter(html); } return(html); }
public void It_Should_Compose_Functions_Together() { // Arrange var removeFilter = new RemoveFilter(LiquidString.Create("123")); var upCase = new UpCaseFilter(); var filterList = new List <IFilterExpression> { removeFilter, upCase }; var compositeFilterFn = FilterChain.CreateChain(new TemplateContext(), filterList); // Act var result = compositeFilterFn(LiquidString.Create("test123")).SuccessValue <LiquidString>(); // Assert Assert.That(result.Value, Is.EqualTo("TEST")); }
//Empty /// <exception cref="System.IO.IOException"/> /// <exception cref="Javax.Servlet.ServletException"/> public virtual void DoFilter(ServletRequest req, ServletResponse resp, FilterChain chain) { ProxyUtils.RejectNonHttpRequests(req); HttpServletRequest httpReq = (HttpServletRequest)req; HttpServletResponse httpResp = (HttpServletResponse)resp; if (Log.IsDebugEnabled()) { Log.Debug("Remote address for request is: {}", httpReq.GetRemoteAddr()); } if (!GetProxyAddresses().Contains(httpReq.GetRemoteAddr())) { string redirectUrl = FindRedirectUrl(); string target = redirectUrl + httpReq.GetRequestURI(); ProxyUtils.SendRedirect(httpReq, httpResp, target); return; } string user = null; if (httpReq.GetCookies() != null) { foreach (Cookie c in httpReq.GetCookies()) { if (WebAppProxyServlet.ProxyUserCookieName.Equals(c.GetName())) { user = c.GetValue(); break; } } } if (user == null) { if (Log.IsDebugEnabled()) { Log.Debug("Could not find " + WebAppProxyServlet.ProxyUserCookieName + " cookie, so user will not be set" ); } chain.DoFilter(req, resp); } else { AmIpPrincipal principal = new AmIpPrincipal(user); ServletRequest requestWrapper = new AmIpServletRequestWrapper(httpReq, principal); chain.DoFilter(requestWrapper, resp); } }
/// <summary> /// Starts this session. /// </summary> public void Start() { if (ReadSuspended) { return; } if (_pendingReceivedMessage != null) { if (!Object.ReferenceEquals(_pendingReceivedMessage, dummy)) { FilterChain.FireMessageReceived(_pendingReceivedMessage); } _pendingReceivedMessage = null; BeginReceive(); } }