FilterChain.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2015-present, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 *
 */
#pragma once

#include <folly/Memory.h>
#include <folly/Function.h>
#include <glog/logging.h>
#include <memory>
#include <utility>

namespace proxygen {

template <typename T1, typename T2, void (T1::*set_callback)(T2*),
          bool TakeOwnership, typename Dp = std::default_delete<T1> >
class GenericFilter: public T1, public T2 {
 public:
  using Filter = GenericFilter<T1, T2, set_callback, TakeOwnership, Dp>;
  GenericFilter(bool calls, bool callbacks):
      kWantsCalls_(calls),
      kWantsCallbacks_(callbacks) {}

  ~GenericFilter() override {
    if (TakeOwnership) {
      callbackSource_ = nullptr;
    }
    // For the last filter in the chain, next_ is null, and call_ points
    // to the concrete implementation object.
    auto next = next_ ? next_ : call_;
    drop();
    if (TakeOwnership && next) {
      Dp()(next);
    }
  }

  void append(Filter* nextFilter) {
    nextFilter->next_ = next_;
    nextFilter->prev_ = this;
    nextFilter->call_ = call_;
    nextFilter->callback_ = kWantsCallbacks_ ? this : callback_;
    nextFilter->callSource_ = kWantsCalls_ ? this : callSource_;
    nextFilter->callbackSource_ = callbackSource_;
    if (next_) {
      next_->prev_ = nextFilter;
    }

    if (nextFilter->kWantsCalls_) {
      if (kWantsCalls_) {
        call_ = nextFilter;
      } else {
        callSource_->call_ = nextFilter;
      }
      if (next_) {
        next_->callSource_ = nextFilter;
      }
    }
    if (nextFilter->kWantsCallbacks_) {
      // Find the first filter before this one that wants callbacks
      auto cur = this;
      while (cur->prev_ && !cur->kWantsCallbacks_) {
        cur = cur->prev_;
      }
      cur->callbackSource_ = nextFilter;
      // Make sure nextFilter gets callbacks
      ((nextFilter->callbackSource_)->*(set_callback))(nextFilter);
    }
    next_ = nextFilter;
  }

  const bool kWantsCalls_;
  const bool kWantsCallbacks_;

 protected:
  void setCallbackInternal(T2* cb) {
    setCallbackInternalImpl(cb, this);
  }

  void drop() {
    if (prev_) {
      prev_->next_ = next_;
    }
    if (next_) {
      next_->prev_ = prev_;
    }
    // TODO: could call fn gated by std::enable_if
    if (kWantsCalls_ && callSource_) {
      callSource_->call_ = call_;
      if (call_) {
        auto callFilter = dynamic_cast<Filter*>(call_);
        if (callFilter) {
          callFilter->callSource_ = callSource_;
        }
      }
    }
    // TODO: could call fn gated by std::enable_if
    if (kWantsCallbacks_ && callbackSource_) {
      ((callbackSource_)->*(set_callback))(callback_);
      if (callback_) {
        auto callbackFilter = dynamic_cast<Filter*>(callback_);
        if (callbackFilter) {
          callbackFilter->callbackSource_ = callbackSource_;
        }
      }
    }
    call_ = callbackSource_ = nullptr;
    callback_ = nullptr;
    callSource_ = next_ = prev_ = nullptr;
  }

  // Next "call" filter (call_ == next_ iff next_->kWantsCalls_)
  T1* call_{nullptr};
  // Next "callback" filter (callback_ == prev_ iff prev_->kWantsCallbacks_)
  T2* callback_{nullptr};

 private:

  void setCallbackInternalImpl(T2* cb, T2* sourceSet) {
    if (callback_ != cb) {
      callback_ = cb;
      ((callbackSource_)->*(set_callback))(cb ? sourceSet : nullptr);
    }
  }

  // The next filter in the chain (towards T1 implementation)
  Filter* next_{nullptr};
  // The previous filter in the chain (towards T2 implementation)
  Filter* prev_{nullptr};
  // The first filter before this one in the chain that wants calls.
  // Only valid if kWantsCalls_ is true.
  Filter* callSource_{nullptr};
  // Pointer to the first filter or object after this one in the chain
  // that makes callbacks. Only valid if kWantsCallbacks_ is true.
  T1* callbackSource_{nullptr};

  template <class A, class B, class F, void (A::*fn)(B*), bool Own>
  friend class FilterChain;
};

template <typename T1, typename T2, typename FilterType,
          void (T1::*set_callback)(T2*), bool TakeOwnership>
class FilterChain: private FilterType {
 public:
  explicit FilterChain(std::unique_ptr<T1> destination):
      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_;
  }

  explicit FilterChain(T1* destination):
      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_;
  }

  void setCallback(T2* cb) override { this->setCallbackInternalImpl(cb, cb); }

  T1* call() {
    return this->call_;
  }
  const T1* call() const {
    return this->call_;
  }

  T1* getChainEndPtr() {
    return chainEnd_;
  }
  const T1& getChainEnd() const {
    return *chainEnd_;
  }

  using FilterChainType = GenericFilter<T1, T2, set_callback, TakeOwnership>;
  std::unique_ptr<T1> setDestination(std::unique_ptr<T1> destination) {
    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);
  }

  template<typename C, typename C2, typename... Types>
  typename std::enable_if<std::is_constructible<C>::value>::type addFilters() {
    // Callback <-> F1 <-> F2 ... <-> F_new <-> Destination
    this->append(new C());
    addFilters<C2, Types...>();
  }

  template<typename C>
  typename std::enable_if<std::is_constructible<C>::value>::type addFilters() {
    this->append(new C());
  }

  template<typename C, typename... Types>
  void addFilters(std::unique_ptr<C> cur, Types&&... remaining) {
    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 C, typename... Types>
  void addFilters(C* cur, Types&&... remaining) {
    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 C, typename... Args>
  FilterChain<T1, T2, FilterType, set_callback, TakeOwnership>&
  add(Args&&... args) {
    this->append(new C(std::forward<Args>(args)...));
    return *this;
  }

  const T1* operator->() const { return call(); }
  T1* operator->() { return call(); }

  void foreach(folly::FunctionRef<void(FilterChainType*)> fn) {
    auto cur = this->next_;
    while (cur) {
      auto filter = cur;
      cur = cur->next_;
      fn(filter);
    }
  }

 private:
  void addFilters() {}

  T1* chainEnd_;
};

}