EventBaseManager.h

Go to the documentation of this file.

/*
 * Copyright 2014-present Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <list>
#include <set>

#include <folly/ThreadLocal.h>
#include <folly/io/async/EventBase.h>

namespace folly {

class EventBaseManager {
 public:
  // XXX Constructing a EventBaseManager directly is DEPRECATED and not
  // encouraged. You should instead use the global singleton if possible.
  EventBaseManager() {}

  ~EventBaseManager() {}

  explicit EventBaseManager(const std::shared_ptr<EventBaseObserver>& observer)
      : observer_(observer) {}

  static EventBaseManager* get();

  EventBase* getEventBase() const;

  EventBase* getExistingEventBase() const {
    EventBaseInfo* info = localStore_.get();
    if (info == nullptr) {
      return nullptr;
    }
    return info->eventBase;
  }

  void setEventBase(EventBase* eventBase, bool takeOwnership);

  void clearEventBase();

  template <typename FunctionType>
  void withEventBaseSet(const FunctionType& runnable) {
    // grab the mutex for the caller
    std::lock_guard<std::mutex> g(*&eventBaseSetMutex_);
    // give them only a const set to work with
    const std::set<EventBase*>& constSet = eventBaseSet_;
    runnable(constSet);
  }

 private:
  struct EventBaseInfo {
    EventBaseInfo(EventBase* evb, bool owned) : eventBase(evb), owned_(owned) {}

    EventBaseInfo() : eventBase(new EventBase), owned_(true) {}

    EventBase* eventBase;
    bool owned_;
    ~EventBaseInfo() {
      if (owned_) {
        delete eventBase;
      }
    }
  };

  // Forbidden copy constructor and assignment opererator
  EventBaseManager(EventBaseManager const&);
  EventBaseManager& operator=(EventBaseManager const&);

  void trackEventBase(EventBase* evb) {
    std::lock_guard<std::mutex> g(*&eventBaseSetMutex_);
    eventBaseSet_.insert(evb);
  }

  void untrackEventBase(EventBase* evb) {
    std::lock_guard<std::mutex> g(*&eventBaseSetMutex_);
    eventBaseSet_.erase(evb);
  }

  mutable folly::ThreadLocalPtr<EventBaseInfo> localStore_;

  // set of "active" EventBase instances
  // (also see the mutex "eventBaseSetMutex_" below
  // which governs access to this).
  mutable std::set<EventBase*> eventBaseSet_;

  // a mutex to use as a guard for the above set
  std::mutex eventBaseSetMutex_;

  std::shared_ptr<folly::EventBaseObserver> observer_;
};

} // namespace folly