CookBook.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file 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.
 */

#ifndef ACSDKMANUFACTORY_INTERNAL_COOKBOOK_H_
#define ACSDKMANUFACTORY_INTERNAL_COOKBOOK_H_

#include <functional>
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <AVSCommon/Utils/TypeIndex.h>

#include "acsdkManufactory/Annotated.h"
#include "acsdkManufactory/internal/AbstractPointerCache.h"
#include "acsdkManufactory/internal/AbstractRecipe.h"

namespace alexaClientSDK {
namespace acsdkManufactory {
namespace internal {

// Forward declaration
class RuntimeManufactory;

class CookBook {
public:
    CookBook();

    template <typename Type, typename... Dependencies>
    CookBook& addUniqueFactory(std::function<std::unique_ptr<Type>(Dependencies...)> factory);

    template <typename Type, typename... Dependencies>
    CookBook& addUniqueFactory(std::unique_ptr<Type> (*factory)(Dependencies...));

    template <typename Type, typename... Dependencies>
    CookBook& addPrimaryFactory(std::function<std::shared_ptr<Type>(Dependencies...)> factory);

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addPrimaryFactory(std::function<Annotated<Annotation, Type>(Dependencies...)> factory);

    template <typename Type, typename... Dependencies>
    CookBook& addPrimaryFactory(std::shared_ptr<Type> (*factory)(Dependencies...));

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addPrimaryFactory(Annotated<Annotation, Type> (*factory)(Dependencies...));

    template <typename Type, typename... Dependencies>
    CookBook& addRequiredFactory(std::function<std::shared_ptr<Type>(Dependencies...)> factory);

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addRequiredFactory(std::function<Annotated<Annotation, Type>(Dependencies...)> factory);

    template <typename Type, typename... Dependencies>
    CookBook& addRequiredFactory(std::shared_ptr<Type> (*factory)(Dependencies...));

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addRequiredFactory(Annotated<Annotation, Type> (*factory)(Dependencies...));

    template <typename Type, typename... Dependencies>
    CookBook& addRetainedFactory(std::function<std::shared_ptr<Type>(Dependencies...)> factory);

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addRetainedFactory(std::function<Annotated<Annotation, Type>(Dependencies...)> factory);

    template <typename Type, typename... Dependencies>
    CookBook& addRetainedFactory(std::shared_ptr<Type> (*factory)(Dependencies...));

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addRetainedFactory(Annotated<Annotation, Type> (*factory)(Dependencies...));

    template <typename Type, typename... Dependencies>
    CookBook& addUnloadableFactory(std::function<std::shared_ptr<Type>(Dependencies...)> factory);

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addUnloadableFactory(std::function<Annotated<Annotation, Type>(Dependencies...)> factory);

    template <typename Type, typename... Dependencies>
    CookBook& addUnloadableFactory(std::shared_ptr<Type> (*factory)(Dependencies...));

    template <typename Annotation, typename Type, typename... Dependencies>
    CookBook& addUnloadableFactory(Annotated<Annotation, Type> (*factory)(Dependencies...));

    template <typename Type>
    CookBook& addInstance(const Type& instance);

    CookBook& addCookBook(const CookBook& cookBook);

    bool checkCompleteness();

    bool doRequiredGets(RuntimeManufactory& runtimeManufactory);

    template <typename Type>
    std::unique_ptr<Type> createUniquePointer(RuntimeManufactory& runtimeManufactory);

    template <typename Type>
    std::unique_ptr<AbstractPointerCache> createPointerCache();

private:
    class FactoryRecipe : public AbstractRecipe {
    public:
        using Factory = void* (*)();

        FactoryRecipe(
            Factory factory,
            CachedInstanceLifecycle lifecycle,
            std::vector<avsCommon::utils::TypeIndex> dependencies,
            ProduceInstanceFunction produceFunction,
            DeleteInstanceFunction deleteFunction);

        ~FactoryRecipe() = default;

        Factory getFactory() const;

        bool isEquivalent(const std::shared_ptr<AbstractRecipe>& recipe) const override;

    private:
        Factory m_factory;
    };

    class FunctionRecipe : public AbstractRecipe {
    public:
        using Function = void*;

        using DeleteRecipeFunction = void (*)(void*);

        FunctionRecipe(
            Function function,
            CachedInstanceLifecycle lifecycle,
            std::vector<avsCommon::utils::TypeIndex> dependencies,
            ProduceInstanceFunction produceFunction,
            DeleteInstanceFunction deleteFunction,
            DeleteRecipeFunction deleteRecipeFunction);

        ~FunctionRecipe();

        Function getFunction() const;

        bool isEquivalent(const std::shared_ptr<AbstractRecipe>& recipe) const override;
    private:
        Function m_function;

        DeleteRecipeFunction m_deleteRecipeFunction;
    };

    class InstanceRecipe : public AbstractRecipe {
    public:
        InstanceRecipe(
            std::shared_ptr<void> instance,
            ProduceInstanceFunction produceFunction,
            DeleteInstanceFunction deleteFunction);

        ~InstanceRecipe() = default;

        std::shared_ptr<void> getInstance() const;

        bool isEquivalent(const std::shared_ptr<AbstractRecipe>& recipe) const override;
    private:
        std::shared_ptr<void> m_instance;
    };

    template <typename Type, typename... Dependencies>
    static void* produceFromSharedFactoryRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename Annotation, typename... Dependencies>
    static void* produceFromAnnotatedSharedFactoryRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename... Dependencies>
    static void* produceFromSharedFunctionRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename Annotation, typename... Dependencies>
    static void* produceFromAnnotatedSharedFunctionRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type>
    static void deleteFunctionForSharedRecipe(void* cachedValue);

    template <typename Type, typename... Dependencies>
    static void deleteFunctionForFunctionRecipeFunction(void* function);

    template <typename Type, typename... Dependencies>
    static void* produceFromWeakFactoryRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename Annotation, typename... Dependencies>
    static void* produceFromAnnotatedWeakFactoryRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename... Dependencies>
    static void* produceFromWeakFunctionRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename Annotation, typename... Dependencies>
    static void* produceFromAnnotatedWeakFunctionRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename... Dependencies>
    static void* produceFromUniqueFactoryRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    template <typename Type, typename... Dependencies>
    static void* produceFromUniqueFunctionRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    static void deleteFunctionForUniqueRecipe(void* cachedValue);

    static void* produceFromInstanceRecipe(
        std::shared_ptr<AbstractRecipe> recipe,
        RuntimeManufactory& runtimeManufactory,
        void* cachedValue);

    static void deleteFunctionForInstanceRecipe(void* cachedValue);

    class GetWrapperCollection {
        using GetWrapper = bool (*)(RuntimeManufactory& runtimeManufactory);

        using GetWrapperIterator =
            std::vector<bool (*)(RuntimeManufactory&), std::allocator<bool (*)(RuntimeManufactory&)>>::iterator;
        using ConstGetWrapperIterator =
            std::vector<bool (*)(RuntimeManufactory&), std::allocator<bool (*)(RuntimeManufactory&)>>::const_iterator;

    public:
        template <typename Type>
        bool append(GetWrapper getWrapper);

        void append(const std::shared_ptr<GetWrapperCollection>& collection);

        /*
         * Return iterator to beginning of m_getWrappers.
         * @return iterator of beginning of m_getWrappers.
         */
        GetWrapperIterator begin();

        /*
         * Return iterator to end of m_getWrappers.
         * @return iterator of end of m_getWrappers.
         */
        GetWrapperIterator end();

        /*
         * Return const_iterator to beginning of m_getWrappers.
         * @return const_iterator of beginning of m_getWrappers.
         */
        ConstGetWrapperIterator cbegin() const;

        /*
         * Return const_iterator to end of m_getWrappers.
         * @return const_iterator of end of m_getWrappers.
         */
        ConstGetWrapperIterator cend() const;

        /*
         * Return const_iterator to beginning of m_getWrappers.
         * @return const_iterator of beginning of m_getWrappers.
         */
        ConstGetWrapperIterator begin() const;

        /*
         * Return const_iterator to end of m_getWrappers.
         * @return const_iterator of end of m_getWrappers.
         */
        ConstGetWrapperIterator end() const;

    private:
        std::unordered_map<avsCommon::utils::TypeIndex, std::size_t> m_types;

        std::vector<GetWrapper> m_orderedGetWrappers;
    };

    template <typename Type, typename... Dependencies>
    using InstanceGetter = std::function<Type(Dependencies...)>;

    bool addInstance(avsCommon::utils::TypeIndex type, const std::shared_ptr<AbstractRecipe>& newInstanceRecipe);

    bool addRecipe(avsCommon::utils::TypeIndex type, const std::shared_ptr<AbstractRecipe>& newRecipe);

    bool checkForCyclicDependencies();

    bool checkIsValid(const char* functionName) const;

    void markInvalid(const std::string& event, const std::string& reason, const std::string& type = "");

    void logDependencies() const;

    template <typename Type, typename... Dependencies>
    static Type invokeWithDependencies(
        RuntimeManufactory& runtimeManufactory,
        std::function<Type(Dependencies...)> function);

    template <typename Type, typename FunctionType, typename... Dependencies>
    static Type innerInvokeWithDependencies(FunctionType function, Dependencies... dependencies);

    static std::string getLoggerTag();

    bool m_isValid;

    std::unordered_map<avsCommon::utils::TypeIndex, std::shared_ptr<AbstractRecipe>> m_recipes;

    std::shared_ptr<GetWrapperCollection> m_primaryGets;

    std::shared_ptr<GetWrapperCollection> m_requiredGets;
};

}  // namespace internal
}  // namespace acsdkManufactory
}  // namespace alexaClientSDK

#include <acsdkManufactory/internal/CookBook_imp.h>

#endif  // ACSDKMANUFACTORY_INTERNAL_COOKBOOK_H_