/*
 * Copyright 2014 Google Inc. 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.
 * 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.
 */

#ifndef FRUIT_BINDINGS_H
#define FRUIT_BINDINGS_H

#include <fruit/impl/meta/metaprogramming.h>

namespace fruit {
namespace impl {

// The types here represent individual entries added in a PartialComponent.

/**
 * Binds the base class I to the implementation C.
 * I must be a base class of C. I=C is not allowed.
 * I and/or C may be annotated using fruit::Annotated<>.
 */
template <typename I, typename C>
struct Bind {};

/**
 * Registers Signature as the constructor signature to use to inject a type.
 * Signature must be a valid signature and its return type must be constructible with those argument
 * types.
 * The arguments and the return type can be annotated using fruit::Annotated<>.
 */
template <typename Signature>
struct RegisterConstructor {};

/**
 * Binds an instance (i.e., object) to the type C.
 * AnnotatedC may be annotated using fruit::Annotated<>.
 * NOTE: for this binding, the runtime binding is added in advance.
 */
template <typename AnnotatedC, typename C>
struct BindInstance {};

/**
 * A variant of BindInstance that binds a constant reference.
 */
template <typename AnnotatedC, typename C>
struct BindConstInstance {};

template <typename... Params>
struct RegisterProvider;

/**
 * Registers `provider' as a provider of C, where provider is a lambda with no captures returning
 * either C or C*.
 */
template <typename Lambda>
struct RegisterProvider<Lambda> {};

/**
 * Registers `provider' as a provider of C, where provider is a lambda with no captures returning
 * either C or C*. Lambda must have the signature AnnotatedSignature (ignoring annotations).
 */
template <typename AnnotatedSignature, typename Lambda>
struct RegisterProvider<Lambda, AnnotatedSignature> {};

/**
 * Adds a multibinding for an instance (as a C&).
 */
template <typename C>
struct AddInstanceMultibinding {};

/**
 * Adds multibindings for a vector of instances (as a std::vector<C>&).
 */
template <typename C>
struct AddInstanceVectorMultibindings {};

/**
 * Similar to Bind<I, C>, but adds a multibinding instead.
 */
template <typename I, typename C>
struct AddMultibinding {};

template <typename... Params>
struct AddMultibindingProvider;

/**
 * Similar to RegisterProvider, but adds a multibinding instead.
 */
template <typename Lambda>
struct AddMultibindingProvider<Lambda> {};

/**
 * Similar to RegisterProvider, but adds a multibinding instead.
 * Lambda must have the signature AnnotatedSignature (ignoring annotations).
 */
template <typename AnnotatedSignature, typename Lambda>
struct AddMultibindingProvider<AnnotatedSignature, Lambda> {};

/**
 * Registers `Lambda' as a factory of C, where `Lambda' is a lambda with no captures returning C.
 * Lambda must have signature DecoratedSignature (ignoring any fruit::Annotated<> and
 * fruit::Assisted<>).
 * Lambda must return a C by value, or a std::unique_ptr<C>.
 */
template <typename DecoratedSignature, typename Lambda>
struct RegisterFactory {};

/**
 * Adds the bindings (and multibindings) in `component' to the current component.
 * OtherComponent must be of the form Component<...>.
 * NOTE: for this binding, the runtime binding is added in advance.
 */
template <typename GetComponentFunction>
struct InstallComponent {};

/**
 * Installs all the specified ComponentFunction objects.
 */
template <typename... ComponentFunctions>
struct InstallComponentFunctions {};

/**
 * An in-progress ReplaceComponent operation, where we don't have all the required information yet.
 */
template <typename GetReplacedComponent>
struct PartialReplaceComponent {};

/**
 * Replaces install()s for a component with install()s for another one.
 * The two Get*Component function signatures must return the same Component<...> type.
 */
template <typename GetReplacedComponent, typename GetReplacementComponent>
struct ReplaceComponent {};

} // namespace impl
} // namespace fruit

#endif // FRUIT_BINDINGS_H