Core.h

Go to the documentation of this file.

/*
 * Copyright 2016-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 <folly/Function.h>
#include <folly/Synchronized.h>
#include <folly/futures/Future.h>

#include <atomic>
#include <memory>
#include <mutex>
#include <unordered_set>
#include <utility>
#include <vector>

namespace folly {
namespace observer_detail {

class ObserverManager;

class Core : public std::enable_shared_from_this<Core> {
 public:
  using Ptr = std::shared_ptr<Core>;
  using WeakPtr = std::weak_ptr<Core>;

  static Ptr create(folly::Function<std::shared_ptr<const void>()> creator);

  struct VersionedData {
    VersionedData() {}

    VersionedData(std::shared_ptr<const void> data_, size_t version_)
        : data(std::move(data_)), version(version_) {}

    std::shared_ptr<const void> data;
    size_t version{0};
  };

  VersionedData getData();

  size_t getVersion() const {
    return version_;
  }

  size_t getVersionLastChange() {
    return versionLastChange_;
  }

  size_t refresh(size_t version, bool force = false);

  ~Core();

 private:
  explicit Core(folly::Function<std::shared_ptr<const void>()> creator);

  void addDependent(Core::WeakPtr dependent);
  void removeStaleDependents();

  using Dependents = std::vector<WeakPtr>;
  using Dependencies = std::unordered_set<Ptr>;

  folly::Synchronized<Dependents> dependents_;
  folly::Synchronized<Dependencies> dependencies_;

  std::atomic<size_t> version_{0};
  std::atomic<size_t> versionLastChange_{0};

  folly::Synchronized<VersionedData> data_;

  folly::Function<std::shared_ptr<const void>()> creator_;

  std::mutex refreshMutex_;
};
} // namespace observer_detail
} // namespace folly