Component.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 <vector>
#include <atomic>
#include <mutex>
#include <memory>
#include <iostream>
#include <type_traits>
#include <algorithm>
#include <cstdio>
 
#include "dm_component.h"
#include "celix/dm/types.h"
#include "celix/dm/ServiceDependency.h"
#include "celix/dm/ProvidedService.h"
#include "celix_dependency_manager.h"
 
 
 
namespace celix { namespace dm {
 
    enum class ComponentState {
        INACTIVE =                              1,
        WAITING_FOR_REQUIRED =                  2,
        INITIALIZING =                          3,
        DEINITIALIZING =                        4,
        INSTANTIATED_AND_WAITING_FOR_REQUIRED = 5,
        STARTING =                              6,
        STOPPING =                              7,
        TRACKING_OPTIONAL =                     8,
        SUSPENDING =                            9,
        SUSPENDED =                             10,
        RESUMING =                              11,
    };
 
    class BaseComponent {
    public:
        BaseComponent(celix_bundle_context_t *con, celix_dependency_manager_t* cdm, std::string name, std::string uuid) : context{con}, cDepMan{cdm}, cCmp{nullptr} {
            this->cCmp = celix_dmComponent_createWithUUID(this->context, name.c_str(), uuid.empty() ? nullptr : uuid.c_str());
            celix_dmComponent_setImplementation(this->cCmp, this);
            cmpUUID = std::string{celix_dmComponent_getUUID(this->cCmp)};
            cmpName = std::string{celix_dmComponent_getName(this->cCmp)};
        }
        virtual ~BaseComponent() noexcept;
 
        BaseComponent(const BaseComponent&) = delete;
        BaseComponent& operator=(const BaseComponent&) = delete;
 
        celix_dm_component_t* cComponent() const { return this->cCmp; }
 
        celix_bundle_context_t* bundleContext() const { return this->context; }
 
        const std::string& getUUID() const {
            return cmpUUID;
        }
 
        const std::string& getName() const {
            return cmpName;
        }
 
        ComponentState getState() const {
             auto cState = celix_dmComponent_currentState(cCmp);
             switch (cState) {
                 case CELIX_DM_CMP_STATE_WAITING_FOR_REQUIRED:
                     return ComponentState::WAITING_FOR_REQUIRED;
                 case CELIX_DM_CMP_STATE_INITIALIZING:
                     return ComponentState::INITIALIZING;
                 case CELIX_DM_CMP_STATE_DEINITIALIZING:
                     return ComponentState::DEINITIALIZING;
                 case CELIX_DM_CMP_STATE_INITIALIZED_AND_WAITING_FOR_REQUIRED:
                     return ComponentState::INSTANTIATED_AND_WAITING_FOR_REQUIRED;
                 case CELIX_DM_CMP_STATE_STARTING:
                     return ComponentState::STARTING;
                 case CELIX_DM_CMP_STATE_STOPPING:
                     return ComponentState::STOPPING;
                 case CELIX_DM_CMP_STATE_TRACKING_OPTIONAL:
                     return ComponentState::TRACKING_OPTIONAL;
                 case CELIX_DM_CMP_STATE_SUSPENDING:
                     return ComponentState::SUSPENDING;
                 case CELIX_DM_CMP_STATE_SUSPENDED:
                     return ComponentState::SUSPENDED;
                 case CELIX_DM_CMP_STATE_RESUMING:
                     return ComponentState::RESUMING;
                 default:
                     return ComponentState::INACTIVE;
             }
         }
 
        void wait() const;
 
        void runBuild();
 
        friend std::ostream& operator<<(std::ostream& out, const BaseComponent& cmp);
    protected:
        celix_bundle_context_t* context;
        celix_dependency_manager_t* cDepMan;
        celix_dm_component_t *cCmp;
        std::string cmpUUID{};
        std::string cmpName{};
 
        std::atomic<bool> cmpAddedToDepMan{false};
 
        std::mutex mutex{}; //protects below
        std::vector<std::shared_ptr<BaseServiceDependency>> dependencies{};
        std::vector<std::shared_ptr<BaseProvidedService>> providedServices{};
        std::vector<std::shared_ptr<void>> componentContexts{};
    };
 
    inline std::ostream& operator<<(std::ostream& out, const BaseComponent& cmp);
 
    template<class T>
    class Component : public BaseComponent {
        using type = T;
    private:
        std::mutex instanceMutex{};
        std::unique_ptr<T> instance {nullptr};
        std::shared_ptr<T> sharedInstance {nullptr};
        std::vector<T> valInstance {};
 
        void (T::*initFp)() = {};
        void (T::*startFp)() = {};
        void (T::*stopFp)() = {};
        void (T::*deinitFp)() = {};
 
        int (T::*initFpNoExc)() = {};
        int (T::*startFpNoExc)() = {};
        int (T::*stopFpNoExc)() = {};
        int (T::*deinitFpNoExc)() = {};
 
        Component(celix_bundle_context_t *context, celix_dependency_manager_t* cDepMan, std::string name, std::string uuid);
    public:
        ~Component() override;
 
        static std::shared_ptr<Component<T>> create(celix_bundle_context_t*, celix_dependency_manager_t* cDepMan, std::string name, std::string uuid);
 
        bool isValid() const;
 
        T& getInstance();
 
        Component<T>& setInstance(std::shared_ptr<T> inst);
 
        Component<T>& setInstance(std::unique_ptr<T>&& inst);
 
        Component<T>& setInstance(T&& inst);
 
        template<class I> Component<T>& addInterfaceWithName(const std::string &serviceName, const std::string &version = std::string{}, const Properties &properties = Properties{});
 
        template<class I> Component<T>& addInterface(const std::string &version = std::string{}, const Properties &properties = Properties{});
 
        template<class I> Component<T>& addCInterface(I* svc, const std::string &serviceName, const std::string &version = std::string{}, const Properties &properties = Properties{});
 
 
        template<class I> ProvidedService<T,I>& createProvidedCService(I* svc, std::string serviceName);
 
        template<class I> ProvidedService<T,I>& createProvidedService(std::string serviceName = {});
 
        template<class I> ProvidedService<T,I>& createUnassociatedProvidedService(std::shared_ptr<I> svc, std::string serviceName = {});
 
        template<class I> Component<T>& removeCInterface(const I* svc);
 
 
        template<class I>
        ServiceDependency<T,I>& createServiceDependency(const std::string &name = std::string{});
 
        template<class I>
        Component<T>& remove(ServiceDependency<T,I>& dep);
 
        template<typename I>
        CServiceDependency<T,I>& createCServiceDependency(const std::string &name);
 
        template<typename I>
        Component<T>& remove(CServiceDependency<T,I>& dep);
 
        Component<T>& setCallbacks(
                void (T::*init)(),
                void (T::*start)(),
                void (T::*stop)(),
                void (T::*deinit)()
        );
 
        Component<T>& setCallbacks(
                int (T::*init)(),
                int (T::*start)(),
                int (T::*stop)(),
                int (T::*deinit)()
        );
 
        Component<T>& removeCallbacks();
 
 
        Component<T>& addContext(std::shared_ptr<void>);
 
         Component<T>& build();
 
        Component<T>& buildAsync();
    private:
        int invokeLifecycleMethod(const std::string& methodName, void (T::*lifecycleMethod)());
    };
}}
 
#include "celix/dm/Component_Impl.h"