ScheduledEvent.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 "celix_bundle_context.h"
 
namespace celix {
 
class ScheduledEvent final {
  public:
    friend class ScheduledEventBuilder;
 
    ScheduledEvent() = default;
 
    ~ScheduledEvent() noexcept {
        if (!isOneShot && ctx) {
            celix_bundleContext_tryRemoveScheduledEventAsync(ctx.get(), eventId);
        }
    }
 
    ScheduledEvent(const ScheduledEvent&) = delete;
    ScheduledEvent& operator=(const ScheduledEvent&) = delete;
 
    ScheduledEvent(ScheduledEvent&& rhs) noexcept
        : ctx{std::move(rhs.ctx)}, eventId{rhs.eventId}, isOneShot{rhs.isOneShot} {
        rhs.eventId = -1;
    }
 
    ScheduledEvent& operator=(ScheduledEvent&& rhs) noexcept {
        if (this != &rhs) {
            ctx = std::move(rhs.ctx);
            eventId = rhs.eventId;
            isOneShot = rhs.isOneShot;
            rhs.eventId = -1;
        }
        return *this;
    }
 
    void cancel() {
        if (ctx) {
            celix_bundleContext_removeScheduledEvent(ctx.get(), eventId);
        }
    }
 
    void wakeup() {
        if (ctx) {
            celix_bundleContext_wakeupScheduledEvent(ctx.get(), eventId);
        }
    }
 
    template <typename Rep, typename Period>
    bool waitFor(std::chrono::duration<Rep, Period> waitTime) {
        double waitTimeInSeconds = std::chrono::duration_cast<std::chrono::duration<double>>(waitTime).count();
        celix_status_t status = CELIX_SUCCESS;
        if (ctx) {
            status = celix_bundleContext_waitForScheduledEvent(ctx.get(), eventId, waitTimeInSeconds);
        }
        return status == CELIX_SUCCESS;
    }
 
  private:
    struct Callbacks {
        std::function<void()> callback{};              
        std::function<void()> removeCallback{};        
    };
 
    static void (*callback)(void*);
 
    ScheduledEvent(std::shared_ptr<celix_bundle_context_t> _cCtx,
                   const std::string& _name,
                   std::function<void()> _callback,
                   std::function<void()> _removeCallback,
                   celix_scheduled_event_options_t& options) {
        static auto callback = [](void* data) {
            auto* callbacks = static_cast<Callbacks*>(data);
            (callbacks->callback)();
        };
        static auto removeCallback = [](void* data) {
            auto* callbacks = static_cast<Callbacks*>(data);
            if (callbacks->removeCallback) {
                (callbacks->removeCallback)();
            }
            delete callbacks;
        };
 
        ctx = std::move(_cCtx);
        isOneShot = options.intervalInSeconds == 0;
        options.name = _name.c_str();
        auto* callbacks = new Callbacks{std::move(_callback), std::move(_removeCallback)};
        options.callbackData = callbacks;
        options.callback = callback;
        options.removeCallbackData = callbacks;
        options.removeCallback = removeCallback;
        eventId = celix_bundleContext_scheduleEvent(ctx.get(), &options);
    }
 
    std::shared_ptr<celix_bundle_context_t> ctx{}; 
    long eventId{-1};                              
    bool isOneShot{false};                         
};
 
} // end namespace celix