proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership > Class Template Reference

#include <FilterChain.h>

Inheritance diagram for proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >:

Public Types
using	FilterChainType = GenericFilter< T1, T2, set_callback, TakeOwnership >

Public Member Functions
	FilterChain (std::unique_ptr< T1 > destination)
	FilterChain (T1 *destination)
void	setCallback (T2 *cb) override
T1 *	call ()
const T1 *	call () const
T1 *	getChainEndPtr ()
const T1 &	getChainEnd () const
std::unique_ptr< T1 >	setDestination (std::unique_ptr< T1 > destination)
template<typename C , typename C2 , typename... Types>
std::enable_if< std::is_constructible< C >::value >::type	addFilters ()
template<typename C >
std::enable_if< std::is_constructible< C >::value >::type	addFilters ()
template<typename C , typename... Types>
void	addFilters (std::unique_ptr< C > cur, Types &&...remaining)
template<typename C , typename... Types>
void	addFilters (C *cur, Types &&...remaining)
template<typename C , typename... Args>
FilterChain< T1, T2, FilterType, set_callback, TakeOwnership > &	add (Args &&...args)
const T1 *	operator-> () const
T1 *	operator-> ()
void	foreach (folly::FunctionRef< void(FilterChainType *)> fn)

Private Member Functions
void	addFilters ()

Private Attributes
T1 *	chainEnd_

Detailed Description

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>
class proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >

This class can be treated the same as a T1*, however internally it contains a chain of filters for T1 and T2. These filters are inserted between the original callback and destination.

If a filter does not care about one side of the calls, it will pass through the calls, saving a virtual function call. In the example below Filter1 only wants to intercept callbacks, and Filter2 only wants to intercept calls.

 FilterChain        Filter1          Filter2        destination
_____________    _____________    _____________    _____________
|           |    |           |    |           |    |           |
|   call_------------------------>|   call_------->|"call"     | T1
|           |    |           |    |           |    |           |

T2 | callback_ |<--—callback_ |<-----------------—|"callback" | |___________| |___________| |___________| |___________|

This class is templatized on the two interfaces, T1, T2, as well as on the pass through filter implementation, FilterType, the special set callback function, and a boolean indicating whether the chain owns the filters (if false, the filters must delete themselves at the correct time). FilterType must have GenericFilter as an ancestor.

Definition at line 207 of file FilterChain.h.

Member Typedef Documentation

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

using proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::FilterChainType = GenericFilter<T1, T2, set_callback, TakeOwnership>

Definition at line 259 of file FilterChain.h.

Constructor & Destructor Documentation

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::FilterChain ( std::unique_ptr< T1 >  destination )

inlineexplicit

Definition at line 209 of file FilterChain.h.

                                                     :
      FilterType(false, false) {
    static_assert(TakeOwnership, "unique_ptr constructor only available "
                  "if the chain owns the filters.");
    this->call_ = CHECK_NOTNULL(destination.release());
    this->callback_ = nullptr; //must call setCallback() explicitly
    this->callSource_ = this;
    this->callbackSource_ = this->call_;
    this->chainEnd_ = this->call_;
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::FilterChain ( T1 *  destination )

inlineexplicit

Definition at line 220 of file FilterChain.h.

                                       :
      FilterType(false, false) {
    static_assert(!TakeOwnership, "raw pointer constructor only available "
                  "if the chain doesn't own the filters.");
    this->call_ = CHECK_NOTNULL(destination);
    this->callback_ = nullptr; //must call setCallback() explicitly
    this->callSource_ = this;
    this->callbackSource_ = this->call_;
    this->chainEnd_ = this->call_;
  }

Member Function Documentation

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

template<typename C , typename... Args>

FilterChain<T1, T2, FilterType, set_callback, TakeOwnership>& proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::add ( Args &&...  args )

inline

Another way to add filters. This way is similar to 'emplace_front' and returns a reference to itself so you can chain add() calls if you like.

Definition at line 341 of file FilterChain.h.

Referenced by proxygen::HTTPSession::WriteSegment::writeErr().

                      {
    this->append(new C(std::forward<Args>(args)...));
    return *this;
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

template<typename C , typename C2 , typename... Types>

std::enable_if<std::is_constructible<C>::value>::type proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::addFilters ( )

inline

Adds filters with the given types to the front of the chain.

Definition at line 301 of file FilterChain.h.

Referenced by proxygen::HTTPSession::setupCodec().

                                                                      {
    // Callback <-> F1 <-> F2 ... <-> F_new <-> Destination
    this->append(new C());
    addFilters<C2, Types...>();
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

template<typename C >

std::enable_if<std::is_constructible<C>::value>::type proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::addFilters ( )

inline

Base case of above function where we add a single filter.

Definition at line 311 of file FilterChain.h.

                                                                      {
    this->append(new C());
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

template<typename C , typename... Types>

void proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::addFilters ( std::unique_ptr< C >  cur, Types &&...  remaining  )

inline

Adds already constructed filters (inside unique_ptr) to the front of the chain.

Definition at line 320 of file FilterChain.h.

                                                              {
    static_assert(TakeOwnership, "addFilters() can only take "
                  "unique_ptr if the chain owns the filters");
    this->append(cur.release());
    addFilters(std::forward<Types>(remaining)...);
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

template<typename C , typename... Types>

void proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::addFilters ( C *  cur, Types &&...  remaining  )

inline

Definition at line 328 of file FilterChain.h.

                                                {
    static_assert(!TakeOwnership, "addFilters() can only take "
                  "pointers if the chain doesn't own the filters");
    this->append(cur);
    addFilters(std::forward<Types>(remaining)...);
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

void proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::addFilters ( )

inlineprivate

Base case for addFilters() called with no arguments. It doesn't need to be public since trying to add zero filters doesn't make sense from a public API pov.

Definition at line 364 of file FilterChain.h.

{}

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

T1* proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::call ( )

inline

Returns the head of the call chain. Do* not* call T1::set_callback() on this member. To change the callback of this entire filter chain, use the separate setCallback() method.

Definition at line 242 of file FilterChain.h.

Referenced by proxygen::HTTPSession::setupCodec().

             {
    return this->call_;
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

const T1* proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::call ( ) const

inline

Definition at line 245 of file FilterChain.h.

                         {
    return this->call_;
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

void proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::foreach ( folly::FunctionRef< void(FilterChainType *)>  fn )

inline

Definition at line 349 of file FilterChain.h.

Referenced by proxygen::HTTPUpstreamSession::attachThreadLocals().

                                                            {
    auto cur = this->next_;
    while (cur) {
      auto filter = cur;
      cur = cur->next_;
      fn(filter);
    }
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

const T1& proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::getChainEnd ( ) const

inline

Definition at line 255 of file FilterChain.h.

Referenced by proxygen::HTTPSession::getCodec().

                                {
    return *chainEnd_;
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

T1* proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::getChainEndPtr ( )

inline

Returns the concrete implementation at the end of the filter chain.

Definition at line 252 of file FilterChain.h.

Referenced by proxygen::HTTPSessionBase::initCodecHeaderIndexingStrategy().

                       {
    return chainEnd_;
  }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

const T1* proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::operator-> ( ) const

inline

Definition at line 346 of file FilterChain.h.

{ return call(); }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

T1* proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::operator-> ( )

inline

Definition at line 347 of file FilterChain.h.

{ return call(); }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

void proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::setCallback ( T2 *  cb )

inlineoverride

Set the callback for this entire filter chain. Setting this to null will uninstall the callback from the concrete object at the end of the chain.

Definition at line 235 of file FilterChain.h.

Referenced by proxygen::HTTPSession::setupCodec().

{ this->setCallbackInternalImpl(cb, cb); }

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

std::unique_ptr<T1> proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::setDestination ( std::unique_ptr< T1 >  destination )

inline

Definition at line 260 of file FilterChain.h.

Referenced by proxygen::HTTPSession::onNativeProtocolUpgradeImpl().

                                                                  {
    static_assert(TakeOwnership, "unique_ptr setDestination only available "
                  "if the chain owns the filters.");
    // find the last filter in the chain, and the last filter that wants calls,
    // callbacks
    FilterChainType* lastFilter = this;
    FilterChainType* lastCall = this;
    FilterChainType* lastCallback = this;
    while (lastFilter->next_) {
      if (lastFilter->kWantsCalls_) {
        lastCall = lastFilter;
      }
      if (lastFilter->kWantsCallbacks_) {
        lastCallback = lastFilter;
      }
      if (lastFilter->call_ == this->chainEnd_) {
        // Search and replace, the last N non-call filters all point to dest
        lastFilter->call_ = destination.get();
      }
      lastFilter = lastFilter->next_;
    }
    if (lastFilter->kWantsCalls_) {
      lastCall = lastFilter;
    }
    if (lastFilter->kWantsCallbacks_) {
      lastCallback = lastFilter;
    }
    lastFilter->call_ = CHECK_NOTNULL(destination.release());
    lastCall->call_ = lastFilter->call_;
    lastCallback->callbackSource_ = lastFilter->call_;
    auto oldChainEnd = this->chainEnd_;
    this->chainEnd_ = lastFilter->call_;

    this->chainEnd_->setCallback(lastCallback);
    return std::unique_ptr<T1>(oldChainEnd);
  }

Member Data Documentation

template<typename T1, typename T2, typename FilterType, void(T1::*)(T2 *) set_callback, bool TakeOwnership>

T1* proxygen::FilterChain< T1, T2, FilterType, set_callback, TakeOwnership >::chainEnd_

private

Definition at line 366 of file FilterChain.h.

---

The documentation for this class was generated from the following file:

• proxygen/lib/utils/FilterChain.h