traits.h

Go to the documentation of this file.

//  NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the
//  software in any medium, provided that you keep intact this entire notice. You may improve, modify and create
//  derivative works of the software or any portion of the software, and you may copy and distribute such modifications
//  or works. Modified works should carry a notice stating that you changed the software and should note the date and
//  nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the
//  source of the software. NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND,
//  EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR
//  WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE
//  CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS
//  THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE. You
//  are solely responsible for determining the appropriateness of using and distributing the software and you assume
//  all risks associated with its use, including but not limited to the risks and costs of program errors, compliance
//  with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of
//  operation. This software is not intended to be used in any situation where a failure could cause risk of injury or
//  damage to property. The software developed by NIST employees is not subject to copyright protection within the
//  United States.
 
 
 
#ifndef HEDGEHOG_TRAITS_H
#define HEDGEHOG_TRAITS_H
 
#pragma once
 
#include <tuple>
 
#include "../core/implementors/concrete_implementor/default_multi_senders.h"
 
namespace hh {
namespace core {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace abstraction {
template<class ...Inputs>
class TaskInputsManagementAbstraction;
template<class ...Inputs>
class GraphInputsManagementAbstraction;
template<class ...Outputs>
class GraphOutputsManagementAbstraction;
template<class ...Outputs>
class TaskOutputsManagementAbstraction;
template<class ...Inputs>
class ExecutionPipelineInputsManagementAbstraction;
template<class ...Outputs>
class ExecutionPipelineOutputsManagementAbstraction;
}
 
namespace implementor {
template<class ...Inputs>
class DefaultMultiExecutes;
 
template<class ...Inputs>
class MultiQueueReceivers;
}
}
 
namespace behavior {
template<class ...Inputs>
class MultiExecute;
template<class ...Inputs>
class MultiReceivers;
template<class ...Inputs>
class MultiSwitchRules;
template<class ...Outputs>
class MultiSenders;
template<class ...Outputs>
class TaskMultiSenders;
template<class ...Outputs>
class StateMultiSenders;
}
 
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
namespace tool {
 
template<class Inputs>
struct TaskInputsManagementAbstractionTypeDeducer;
 
template<class ...Inputs>
struct TaskInputsManagementAbstractionTypeDeducer<std::tuple<Inputs...>> {
  using type = core::abstraction::TaskInputsManagementAbstraction<Inputs...>;
};
 
template<class TupleInputs>
using TaskInputsManagementAbstractionTypeDeducer_t =
    typename TaskInputsManagementAbstractionTypeDeducer<TupleInputs>::type;
 
template<class Outputs>
struct TaskOutputsManagementAbstractionTypeDeducer;
 
template<class ...Outputs>
struct TaskOutputsManagementAbstractionTypeDeducer<std::tuple<Outputs...>> {
  using type = core::abstraction::TaskOutputsManagementAbstraction<Outputs...>;
};
 
template<class TupleOutputs>
using TaskOutputsManagementAbstractionTypeDeducer_t =
    typename TaskOutputsManagementAbstractionTypeDeducer<TupleOutputs>::type;
 
template<class Inputs>
struct GraphInputsManagementAbstractionTypeDeducer;
 
template<class ...Inputs>
struct GraphInputsManagementAbstractionTypeDeducer<std::tuple<Inputs...>> {
  using type = core::abstraction::GraphInputsManagementAbstraction<Inputs...>;
};
 
template<class TupleInputs>
using GraphInputsManagementAbstractionTypeDeducer_t =
    typename GraphInputsManagementAbstractionTypeDeducer<TupleInputs>::type;
 
template<class Outputs>
struct GraphOutputsManagementAbstractionTypeDeducer;
 
template<class ...Outputs>
struct GraphOutputsManagementAbstractionTypeDeducer<std::tuple<Outputs...>> {
  using type = core::abstraction::GraphOutputsManagementAbstraction<Outputs...>;
};
 
template<class TupleOutputs>
using GraphOutputsManagementAbstractionTypeDeducer_t =
    typename GraphOutputsManagementAbstractionTypeDeducer<TupleOutputs>::type;
 
template<class Inputs>
struct ExecutionPipelineInputsManagementAbstractionTypeDeducer;
 
template<class ...Inputs>
struct ExecutionPipelineInputsManagementAbstractionTypeDeducer<std::tuple<Inputs...>> {
  using type = core::abstraction::ExecutionPipelineInputsManagementAbstraction<Inputs...>;
};
 
template<class TupleInputs>
using ExecutionPipelineInputsManagementAbstractionTypeDeducer_t =
    typename ExecutionPipelineInputsManagementAbstractionTypeDeducer<TupleInputs>::type;
 
template<class Outputs>
struct ExecutionPipelineOutputsManagementAbstractionTypeDeducer;
 
template<class ...Outputs>
struct ExecutionPipelineOutputsManagementAbstractionTypeDeducer<std::tuple<Outputs...>> {
  using type = core::abstraction::ExecutionPipelineOutputsManagementAbstraction<Outputs...>;
};
 
template<class TupleOutputs>
using ExecutionPipelineOutputsManagementAbstractionTypeDeducer_t =
    typename ExecutionPipelineOutputsManagementAbstractionTypeDeducer<TupleOutputs>::type;
 
 
template<class Inputs>
struct DefaultMultiExecutesTypeDeducer;
 
template<class ...Inputs>
struct DefaultMultiExecutesTypeDeducer<std::tuple<Inputs...>> {
  using type = core::implementor::DefaultMultiExecutes<Inputs...>;
};
 
template<class TupleInputs>
using DefaultMultiExecutesTypeDeducer_t = typename DefaultMultiExecutesTypeDeducer<TupleInputs>::type;
 
template<size_t Separator, class ...AllTypes>
using DME = DefaultMultiExecutesTypeDeducer_t<hh::tool::Inputs<Separator, AllTypes...>>;
 
template<class Outputs>
struct MultiDefaultSendersTypeDeducer;
 
template<class ...Outputs>
struct MultiDefaultSendersTypeDeducer<std::tuple<Outputs...>> {
  using type = hh::core::implementor::DefaultMultiSenders<Outputs...>;
};
 
template<class TupleOutputs>
using MultiDefaultSendersTypeDeducer_t = typename MultiDefaultSendersTypeDeducer<TupleOutputs>::type;
 
template<size_t Separator, class ...AllTypes>
using MDS = MultiDefaultSendersTypeDeducer_t<hh::tool::Outputs<Separator, AllTypes...>>;
 
template<class Inputs>
struct MultiQueueReceiversTypeDeducer;
 
template<class ...Inputs>
struct MultiQueueReceiversTypeDeducer<std::tuple<Inputs...>> {
  using type = core::implementor::MultiQueueReceivers<Inputs...>;
};
 
template<class TupleInputs>
using MultiQueueReceiversTypeDeducer_t = typename MultiQueueReceiversTypeDeducer<TupleInputs>::type;
 
template<size_t Separator, class ...AllTypes>
using MQR = MultiQueueReceiversTypeDeducer_t<hh::tool::Inputs<Separator, AllTypes...>>;
 
template<class Inputs>
struct BehaviorMultiExecuteTypeDeducer;
 
template<class ...Inputs>
struct BehaviorMultiExecuteTypeDeducer<std::tuple<Inputs...>> { using type = behavior::MultiExecute<Inputs...>; };
 
template<class TupleInputs>
using BehaviorMultiExecuteTypeDeducer_t = typename BehaviorMultiExecuteTypeDeducer<TupleInputs>::type;
 
template<class Inputs>
struct BehaviorMultiReceiversTypeDeducer;
 
template<class ...Inputs>
struct BehaviorMultiReceiversTypeDeducer<std::tuple<Inputs...>> { using type = behavior::MultiReceivers<Inputs...>; };
 
template<class TupleInputs>
using BehaviorMultiReceiversTypeDeducer_t = typename BehaviorMultiReceiversTypeDeducer<TupleInputs>::type;
 
template<class Inputs>
struct BehaviorMultiSwitchRulesTypeDeducer;
 
template<class ...Inputs>
struct BehaviorMultiSwitchRulesTypeDeducer<std::tuple<Inputs...>> { using type = behavior::MultiSwitchRules<Inputs...>; };
 
template<class TupleInputs>
using BehaviorMultiSwitchRulesTypeDeducer_t = typename BehaviorMultiSwitchRulesTypeDeducer<TupleInputs>::type;
 
template<class Outputs>
struct BehaviorMultiSenderTypeDeducer;
 
template<class ...Outputs>
struct BehaviorMultiSenderTypeDeducer<std::tuple<Outputs...>> { using type = behavior::MultiSenders<Outputs...>; };
 
template<class TupleOutputs>
using BehaviorMultiSendersTypeDeducer_t = typename BehaviorMultiSenderTypeDeducer<TupleOutputs>::type;
 
template<class Outputs>
struct BehaviorTaskMultiSenderTypeDeducer;
 
template<class ...Outputs>
struct BehaviorTaskMultiSenderTypeDeducer<std::tuple<Outputs...>> { using type = behavior::TaskMultiSenders<Outputs...>; };
 
template<class TupleOutputs>
using BehaviorTaskMultiSendersTypeDeducer_t = typename BehaviorTaskMultiSenderTypeDeducer<TupleOutputs>::type;
 
template<class Outputs>
struct BehaviorStateMultiSenderTypeDeducer;
 
template<class ...Outputs>
struct BehaviorStateMultiSenderTypeDeducer<std::tuple<Outputs...>> { using type = behavior::StateMultiSenders<Outputs...>; };
 
template<class TupleOutputs>
using BehaviorStateMultiSendersTypeDeducer_t = typename BehaviorStateMultiSenderTypeDeducer<TupleOutputs>::type;
}
}
#endif //HEDGEHOG_TRAITS_H