celix_bundle_activator.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.
 */

#include <stdlib.h>

#include "celix_bundle_context.h"

#ifndef CELIX_BUNDLE_ACTIVATOR_H_
#define CELIX_BUNDLE_ACTIVATOR_H_

#ifdef __cplusplus
extern "C" {
#endif

celix_status_t celix_bundleActivator_create(celix_bundle_context_t *ctx, void **userData);

celix_status_t celix_bundleActivator_start(void *userData, celix_bundle_context_t *ctx);

celix_status_t celix_bundleActivator_stop(void *userData, celix_bundle_context_t *ctx);

celix_status_t celix_bundleActivator_destroy(void *userData, celix_bundle_context_t* ctx);


#define CELIX_GEN_BUNDLE_ACTIVATOR(actType, actStart, actStop)                                                         \
celix_status_t celix_bundleActivator_create(celix_bundle_context_t *ctx __attribute__((unused)), void **userData) {    \
    celix_status_t status = CELIX_SUCCESS;                                                                             \
    actType *data = (actType*)calloc(1, sizeof(*data));                                                                \
    if (data != NULL) {                                                                                                \
        *userData = data;                                                                                              \
    } else {                                                                                                           \
        status = CELIX_ENOMEM;                                                                                         \
    }                                                                                                                  \
    return status;                                                                                                     \
}                                                                                                                      \
                                                                                                                       \
celix_status_t celix_bundleActivator_start(void *userData, celix_bundle_context_t *ctx) {                              \
    return actStart((actType*)userData, ctx);                                                                          \
}                                                                                                                      \
                                                                                                                       \
celix_status_t celix_bundleActivator_stop(void *userData, celix_bundle_context_t *ctx) {                               \
    return actStop((actType*)userData, ctx);                                                                           \
}                                                                                                                      \
                                                                                                                       \
celix_status_t celix_bundleActivator_destroy(void *userData, celix_bundle_context_t *ctx __attribute__((unused))) {    \
    free(userData);                                                                                                    \
    return CELIX_SUCCESS;                                                                                              \
}

#ifdef __cplusplus
}


#define CELIX_GEN_CXX_BUNDLE_ACTIVATOR(actType)                                                                        \
                                                                                                                       \
namespace /*anon*/ {                                                                                                   \
struct BundleActivatorData {                                                                                           \
    std::shared_ptr<DependencyManager> mng{};                                                                          \
    std::unique_ptr<actType> activator{};                                                                              \
};                                                                                                                     \
}                                                                                                                      \
                                                                                                                       \
extern "C" celix_status_t bundleActivator_create(celix_bundle_context_t *context, void** userData) {                   \
    int status = CELIX_SUCCESS;                                                                                        \
                                                                                                                       \
    BundleActivatorData* data = nullptr;                                                                               \
    data = new BundleActivatorData{};                                                                                  \
    if (data != nullptr) {                                                                                             \
        data->mng = std::shared_ptr<celix::dm::DependencyManager>{new celix::dm::DependencyManager{context}};          \
    }                                                                                                                  \
                                                                                                                       \
    if (data == nullptr || data->mng == nullptr) {                                                                     \
        status = CELIX_ENOMEM;                                                                                         \
        if (data != nullptr) {                                                                                         \
            delete data;                                                                                               \
        }                                                                                                              \
        *userData = nullptr;                                                                                           \
    } else {                                                                                                           \
        *userData = data;                                                                                              \
    }                                                                                                                  \
    return status;                                                                                                     \
}                                                                                                                      \
                                                                                                                       \
extern "C" celix_status_t bundleActivator_start(void *userData, celix_bundle_context_t *) {                            \
    auto* data = static_cast<BundleActivatorData*>(userData);                                                          \
    if (data != nullptr) {                                                                                             \
        data->activator = std::unique_ptr<actType>{new actType{data->mng}};                                            \
        data->mng->start();                                                                                            \
    }                                                                                                                  \
    return CELIX_SUCCESS;                                                                                              \
}                                                                                                                      \
                                                                                                                       \
extern "C" celix_status_t bundleActivator_stop(void *userData, celix_bundle_context_t*) {                              \
    auto* data = static_cast<BundleActivatorData*>(userData);                                                          \
    if (data != nullptr) {                                                                                             \
        data->mng->stop();                                                                                             \
        data->activator = nullptr;                                                                                     \
        data->mng = nullptr;                                                                                           \
    }                                                                                                                  \
    return CELIX_SUCCESS;                                                                                              \
}                                                                                                                      \
                                                                                                                       \
extern "C" celix_status_t bundleActivator_destroy(void *userData, celix_bundle_context_t*) {                           \
    auto* data = static_cast<BundleActivatorData*>(userData);                                                          \
    if (data != nullptr) {                                                                                             \
        delete data;                                                                                                   \
    }                                                                                                                  \
    return CELIX_SUCCESS;                                                                                              \
}                                                                                                                      \


#endif

#endif /* CELIX_BUNDLE_ACTIVATOR_H_ */