ServiceDependency.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 <map>
#include <string>
#include <list>
#include <tuple>
#include <memory>
#include <iostream>
#include <functional>
#include <atomic>
#include <vector>
#include <cstring>
#include <chrono>
 
#include "celix_dm_service_dependency.h"
#include "celix_constants.h"
#include "celix_properties.h"
#include "celix/Utils.h"
#include "celix/dm/Properties.h"
 
namespace celix { namespace dm {
 
    enum class DependencyUpdateStrategy {
        suspend,
        locking
    };
 
    class BaseServiceDependency {
    private:
        const std::chrono::milliseconds warningTimoutForNonExpiredSvcObject{5000};
        std::atomic<bool> depAddedToCmp{false};
        celix_dm_component_t* cCmp;
    protected:
        celix_dm_service_dependency_t *cServiceDep {nullptr};
 
        void setDepStrategy(DependencyUpdateStrategy strategy) {
            if (strategy == DependencyUpdateStrategy::locking) {
                celix_dmServiceDependency_setStrategy(this->cServiceDependency(), DM_SERVICE_DEPENDENCY_STRATEGY_LOCKING);
            } else { /*suspend*/
                celix_dmServiceDependency_setStrategy(this->cServiceDependency(), DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
            }
        }
 
        template<typename U>
        void waitForExpired(std::weak_ptr<U> observe, long svcId, const char* observeType);
    public:
        BaseServiceDependency(celix_dm_component_t* c)  : cCmp{c} {
            this->cServiceDep = celix_dmServiceDependency_create();
            //NOTE using suspend as default strategy
            celix_dmServiceDependency_setStrategy(this->cServiceDep,  DM_SERVICE_DEPENDENCY_STRATEGY_SUSPEND);
        }
 
        virtual ~BaseServiceDependency() noexcept;
 
        BaseServiceDependency(const BaseServiceDependency&) = delete;
        BaseServiceDependency& operator=(const BaseServiceDependency&) = delete;
        BaseServiceDependency(BaseServiceDependency&&) noexcept = delete;
        BaseServiceDependency& operator=(BaseServiceDependency&&) noexcept = delete;
 
        bool isValid() const __attribute__((deprecated)) { return true; }
 
        celix_dm_service_dependency_t *cServiceDependency() const { return cServiceDep; }
 
        void wait() const;
 
        void runBuild();
    };
 
    template<class T>
    class TypedServiceDependency :  public BaseServiceDependency {
        using cmpType = T;
    protected:
        T* componentInstance {nullptr};
    public:
        TypedServiceDependency(celix_dm_component_t* cCmp) : BaseServiceDependency(cCmp) {}
        ~TypedServiceDependency() override = default;
 
        TypedServiceDependency(const TypedServiceDependency&) = delete;
        TypedServiceDependency& operator=(const TypedServiceDependency&) = delete;
        TypedServiceDependency(TypedServiceDependency&&) noexcept = delete;
        TypedServiceDependency& operator=(TypedServiceDependency&&) noexcept = delete;
 
        void setComponentInstance(T* cmp) { componentInstance = cmp;}
    };
 
    template<class T, typename I>
    class CServiceDependency : public TypedServiceDependency<T> {
        using type = I;
    public:
        CServiceDependency(celix_dm_component_t* cCmp, const std::string &name);
        ~CServiceDependency() override = default;
 
        CServiceDependency(const CServiceDependency&) = delete;
        CServiceDependency& operator=(const CServiceDependency&) = delete;
        CServiceDependency(CServiceDependency&&) noexcept = delete;
        CServiceDependency& operator=(CServiceDependency&&) noexcept = delete;
 
        CServiceDependency<T,I>& setVersionRange(const std::string &serviceVersionRange);
 
        CServiceDependency<T,I>& setFilter(const std::string &filter);
 
        CServiceDependency<T,I>& setRequired(bool req);
 
        CServiceDependency<T,I>& setStrategy(DependencyUpdateStrategy strategy);
 
        CServiceDependency<T,I>& setCallbacks(void (T::*set)(const I* service));
 
        CServiceDependency<T,I>& setCallbacks(void (T::*set)(const I* service, Properties&& properties));
 
        CServiceDependency<T,I>& setCallbacks(std::function<void(const I* service, Properties&& properties)> set);
 
        CServiceDependency<T,I>& setCallbacks(void (T::*add)(const I* service),  void (T::*remove)(const I* service));
 
        CServiceDependency<T,I>& setCallbacks(
                void (T::*add)(const I* service, Properties&& properties),
                void (T::*remove)(const I* service, Properties&& properties)
        );
 
        CServiceDependency<T,I>& setCallbacks(
                std::function<void(const I* service, Properties&& properties)> add,
                std::function<void(const I* service, Properties&& properties)> remove
        );
 
        CServiceDependency<T,I>& setAddLanguageFilter(bool addLang);
 
        CServiceDependency<T,I>& build();
 
        CServiceDependency<T,I>& buildAsync();
 
 
 
    private:
        std::string name {};
        std::string filter {};
        std::string versionRange {};
 
        std::function<void(const I* service, Properties&& properties)> setFp{nullptr};
        std::function<void(const I* service, Properties&& properties)> addFp{nullptr};
        std::function<void(const I* service, Properties&& properties)> removeFp{nullptr};
 
        void setupCallbacks();
        int invokeCallback(std::function<void(const I*, Properties&&)> fp, const celix_properties_t *props, const void* service);
 
        void setupService();
    };
 
    template<class T, class I>
    class ServiceDependency : public TypedServiceDependency<T> {
        using type = I;
    public:
        ServiceDependency(celix_dm_component_t* cCmp, const std::string &name);
        ~ServiceDependency() override = default;
 
        ServiceDependency(const ServiceDependency&) = delete;
        ServiceDependency& operator=(const ServiceDependency&) = delete;
        ServiceDependency(ServiceDependency&&) noexcept = delete;
        ServiceDependency& operator=(ServiceDependency&&) noexcept = delete;
 
        ServiceDependency<T,I>& setName(const std::string &_name);
 
        ServiceDependency<T,I>& setFilter(const std::string &filter);
 
        ServiceDependency<T,I>& setVersionRange(const std::string &versionRange);
 
        ServiceDependency<T,I>& setCallbacks(void (T::*set)(I* service));
 
        ServiceDependency<T,I>& setCallbacks(void (T::*set)(I* service, Properties&& properties));
 
        ServiceDependency<T,I>& setCallbacks(std::function<void(I* service, Properties&& properties)> set);
 
        ServiceDependency<T,I>& setCallbacks(void (T::*set)(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties));
 
        ServiceDependency<T,I>& setCallbacks(std::function<void(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties)> set);
 
        ServiceDependency<T,I>& setCallbacks(void (T::*set)(const std::shared_ptr<I>& service));
 
        ServiceDependency<T,I>& setCallbacks(std::function<void(const std::shared_ptr<I>& service)> set);
 
        ServiceDependency<T,I>& setCallbacks(void (T::*add)(I* service),  void (T::*remove)(I* service));
 
        ServiceDependency<T,I>& setCallbacks(
                void (T::*add)(I* service, Properties&& properties),
                void (T::*remove)(I* service, Properties&& properties)
        );
 
        ServiceDependency<T,I>& setCallbacks(
                std::function<void(I* service, Properties&& properties)> add,
                std::function<void(I* service, Properties&& properties)> remove
        );
 
        ServiceDependency<T,I>& setCallbacks(
                void (T::*add)(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties),
                void (T::*remove)(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties));
 
        ServiceDependency<T,I>& setCallbacks(
                std::function<void(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties)> add,
                std::function<void(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties)> remove);
 
 
        ServiceDependency<T,I>& setCallbacks(
                void (T::*add)(const std::shared_ptr<I>& service),
                void (T::*remove)(const std::shared_ptr<I>& service));
 
        ServiceDependency<T,I>& setCallbacks(
                std::function<void(const std::shared_ptr<I>& service)> add,
                std::function<void(const std::shared_ptr<I>& service)> remove);
 
        ServiceDependency<T,I>& setRequired(bool req);
 
        ServiceDependency<T,I>& setStrategy(DependencyUpdateStrategy strategy);
 
        ServiceDependency<T,I>& setAddLanguageFilter(bool addLang);
 
 
        ServiceDependency<T,I>& build();
 
        ServiceDependency<T,I>& buildAsync();
    private:
        void setupService();
        void setupCallbacks();
        int invokeCallback(std::function<void(I*, Properties&&)> fp, const celix_properties_t *props, const void* service);
 
        std::string name {};
        std::string filter {};
        std::string versionRange {};
 
        std::function<void(I* service, Properties&& properties)> setFp{};
        std::function<void(I* service, Properties&& properties)> addFp{};
        std::function<void(I* service, Properties&& properties)> removeFp{};
 
        std::function<void(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties)> setFpUsingSharedPtr{};
        std::function<void(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties)> addFpUsingSharedPtr{};
        std::function<void(const std::shared_ptr<I>& service, const std::shared_ptr<const celix::Properties>& properties)> removeFpUsingSharedPtr{};
 
        //note below is only updated in the Celix event thread.
        std::unordered_map<long, std::pair<std::shared_ptr<I>, std::shared_ptr<const celix::Properties>>> addedServices{};
        std::pair<std::shared_ptr<I>, std::shared_ptr<const celix::Properties>> setService{};
    };
}}
 
#include "celix/dm/ServiceDependency_Impl.h"