DependencyManager.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 <cstdio>
#include <iostream>
#include <vector>
 
#include "celix/dm/types.h"
#include "celix/dm/Component.h"
#include "celix/dm/ServiceDependency.h"
#include "celix/dm/DependencyManagerInfo.h"
 
#include "bundle_context.h"
#include "celix_bundle_context.h"
#include "celix_dependency_manager.h"
 
namespace celix { namespace dm {
 
    class DependencyManager {
    public:
        DependencyManager(celix_bundle_context_t *ctx);
 
        virtual ~DependencyManager();
 
        DependencyManager(DependencyManager&& mgr) = delete;
        DependencyManager& operator=(DependencyManager&& rhs) = delete;
 
        DependencyManager(const DependencyManager&) = delete;
        DependencyManager& operator=(const DependencyManager&) = delete;
 
        celix_bundle_context_t* bundleContext() const { return context.get(); }
        celix_dependency_manager_t *cDependencyManager() const { return cDepMan.get(); }
 
 
        template<class T>
        typename std::enable_if<std::is_default_constructible<T>::value, Component<T>&>::type
        createComponent(std::string name = std::string{}, std::string uuid = {});
 
        template<class T>
        Component<T>& createComponent(std::unique_ptr<T>&& rhs, std::string name = std::string{}, std::string uuid = {});
 
        template<class T>
        Component<T>& createComponent(std::shared_ptr<T> rhs, std::string name = std::string{}, std::string uuid = {});
 
        template<class T>
        Component<T>& createComponent(T rhs, std::string name = std::string{}, std::string uuid = {});
 
        void build();
 
         void buildAsync();
 
        void start();
 
        void wait() const;
 
        void waitIfAble() const;
 
        void destroyComponent(BaseComponent &component);
 
 
        void clear();
 
        void clearAsync();
 
        void stop();
 
        std::size_t getNrOfComponents() const;
 
        template<typename T>
        std::shared_ptr<Component<T>> findComponent(const std::string& uuid) const;
 
        bool removeComponent(const std::string& uuid);
 
        bool removeComponentAsync(const std::string& uuid);
 
        celix::dm::DependencyManagerInfo getInfo() const;
 
        std::vector<celix::dm::DependencyManagerInfo> getInfos() const;
 
        friend std::ostream& operator<<(std::ostream& out, const DependencyManager& mng);
    private:
        template<class T>
        Component<T>& createComponentInternal(std::string name, std::string uuid);
 
        std::shared_ptr<celix_bundle_context_t> context;
        std::shared_ptr<celix_dependency_manager_t> cDepMan;
        mutable std::mutex mutex{}; //protects below
        std::vector<std::shared_ptr<BaseComponent>> components{};
    };
 
    inline std::ostream& operator<<(std::ostream& out, const DependencyManager& mng);
}}
 
#include "celix/dm/DependencyManager_Impl.h"