TaskScheduler.h

/*
 * Copyright (C) 2019-2021 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */
 
#pragma once
 
#include <utility>
 
#include <olp/core/client/ApiResponse.h>
#include <olp/core/client/CancellationContext.h>
#include <olp/core/utils/WarningWorkarounds.h>
 
namespace olp {
namespace thread {
 
enum Priority : uint32_t { LOW = 100, NORMAL = 500, HIGH = 1000 };
 
class CORE_API TaskScheduler {
 public:
  using CallFuncType = std::function<void()>;
 
  virtual ~TaskScheduler() = default;
 
  void ScheduleTask(CallFuncType&& func) { EnqueueTask(std::move(func)); }
 
  void ScheduleTask(CallFuncType&& func, uint32_t priority) {
    EnqueueTask(std::move(func), priority);
  }
 
  template <class Function, typename std::enable_if<!std::is_convertible<
                                decltype(std::declval<Function>()),
                                CallFuncType>::value>::type* = nullptr>
  client::CancellationContext ScheduleTask(Function&& func) {
    client::CancellationContext context;
    auto task = [func, context]() {
      if (!context.IsCancelled()) {
        func(context);
      }
    };
    EnqueueTask(std::move(task));
    return context;
  }
 
 protected:
  virtual void EnqueueTask(CallFuncType&&) = 0;
 
  virtual void EnqueueTask(CallFuncType&& func, uint32_t priority) {
    OLP_SDK_CORE_UNUSED(priority);
    EnqueueTask(std::forward<CallFuncType>(func));
  }
};
 
inline CORE_API void ExecuteOrSchedule(
    const std::shared_ptr<TaskScheduler>& scheduler,
    TaskScheduler::CallFuncType&& func) {
  if (!scheduler) {
    // User didn't specify a TaskScheduler, execute sync
    func();
    return;
  }
 
  // Schedule for async execution
  scheduler->ScheduleTask(std::move(func));
}
 
}  // namespace thread
}  // namespace olp