concepts.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_CONCEPTS_H
#define HEDGEHOG_CONCEPTS_H
#pragma once
 
#include <type_traits>
 
#include "meta_functions.h"
 
namespace hh {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace core {
 
namespace abstraction {
class SlotAbstraction;
class NotifierAbstraction;
class NodeAbstraction;
template<class Input>
class ReceiverAbstraction;
template<class Output>
class SenderAbstraction;
}
 
namespace implementor {
class ImplementorSlot;
class ImplementorNotifier;
template<class Input>
class ImplementorReceiver;
template<class Input>
class ImplementorExecute;
template<class Output>
class ImplementorSender;
}
}
 
class ManagedMemory;
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
namespace tool {
 
template<class T, class ...Ts>
concept ContainsConcept = isContainedIn_v<T, Ts...>; // The type T is not in Ts...
 
template<class T, class Tuple>
concept ContainsInTupleConcept = isContainedInTuple_v<T, Tuple>; // The type T is not in Ts...
 
template<class I, class Is>
concept MatchInputTypeConcept =
ContainsInTupleConcept<I, Is>; // The input type (I) should be part of the list of input types (Is)
 
template<class O, class ...Os>
concept MatchOutputTypeConcept =
ContainsConcept<O, Os...>; // The output type (O) should be part of the list of output types (Os)
 
template<class T, class ...Os>
concept MultiSendersAndNotifierAbstractionConcept =
(std::is_base_of_v<core::abstraction::SenderAbstraction<Os>, T> && ...) &&
    std::is_base_of_v<core::abstraction::NotifierAbstraction, T>;
 
template<class T>
concept ManageableMemory =
std::is_base_of_v<ManagedMemory, T> // Derives from ManagedMemory
    && std::is_default_constructible_v<T>; // default constructible
 
template<class CoreNode, class TupleCoreInputs, class TupleGraphInputs>
concept CompatibleInputCore =
std::is_base_of_v<core::abstraction::NodeAbstraction, CoreNode> // The core given derives from NodeAbstraction
    && std::tuple_size_v<Intersect_t<TupleCoreInputs, TupleGraphInputs>> != 0; // There is at least one common type
 
 
template<class CoreNode, class InputType, class TupleCoreInputs, class TupleGraphInputs>
concept CompatibleInputCoreForAType =
std::is_base_of_v<core::abstraction::NodeAbstraction, CoreNode> // The core given derives from NodeAbstraction
    && ContainsInTupleConcept<InputType, TupleGraphInputs> // The input type is part of the graph input types
    && ContainsInTupleConcept<InputType, TupleCoreInputs>; // The input type is part of the core input types
 
template<class CoreNode, class TupleCoreOutputs, class TupleGraphOutputs>
concept CompatibleOutputCore =
std::is_base_of_v<core::abstraction::NodeAbstraction, CoreNode> // The core given derives from NodeAbstraction
    && std::tuple_size_v<Intersect_t<TupleCoreOutputs,
                                     TupleGraphOutputs>> != 0;  // There is at least one common type
 
 
template<class CoreNode, class OutputType, class TupleCoreOutputs, class TupleGraphOutputs>
concept CompatibleOutputCoreForAType =
std::is_base_of_v<core::abstraction::NodeAbstraction, CoreNode> // The core given derives from NodeAbstraction
    && ContainsInTupleConcept<OutputType, TupleGraphOutputs> // The output type is part of the graph output types
    && ContainsInTupleConcept<OutputType, TupleCoreOutputs>; // The output type is part of the core output types
 
template<class NodeType>
concept SenderNode =
std::is_base_of_v<behavior::Node, NodeType> // The node derives from Node
    && requires(NodeType *node){
      typename NodeType::outputs_t; // The node has its output types accessible
      std::is_base_of_v<behavior::MultiSenders<typename NodeType::outputs_t>, NodeType
      >; // The node derives from MultiSenders
    };
 
template<class NodeType>
concept ReceiverNode =
std::is_base_of_v<behavior::Node, NodeType> // The node derives from Node
    && requires(NodeType *node){
      typename NodeType::inputs_t; // The node has its input types accessible
      std::is_base_of_v<behavior::MultiReceivers<typename NodeType::inputs_t>, NodeType
      >; // The node derives from MultiReceivers
    };
 
template<class NodeType, class OutputType>
concept SenderNodeForAType =
SenderNode<NodeType> // The node is a sender node
    && ContainsInTupleConcept<OutputType,
                              typename NodeType::outputs_t>; // The OutputType is part of the sender output types
 
template<class NodeType, class InputType>
concept ReceiverNodeForAType =
ReceiverNode<NodeType> // The node is a receiver node
    && ContainsInTupleConcept<InputType,
                              typename NodeType::inputs_t>; // The InputType is part of the sender input types
 
template<class NodeType, class TupleGraphInputs>
concept CompatibleInputNode =
ReceiverNode<NodeType> // The node is a receiver node
    && std::tuple_size_v<
        Intersect_t<typename NodeType::inputs_t, TupleGraphInputs>
    > != 0; // There is at least one common type between the task and graph input types
 
template<class NodeType, class InputType, class TupleGraphInputs>
concept CompatibleInputNodeForAType =
ReceiverNodeForAType<NodeType, InputType> // The node is a receiver node
    && ContainsInTupleConcept<InputType, TupleGraphInputs>; // The input type is part of the graph input types
 
template<class NodeType, class TupleGraphOutputs>
concept CompatibleOutputNode =
SenderNode<NodeType> // The node is a sender node
    && std::tuple_size_v<
        Intersect_t<typename NodeType::outputs_t, TupleGraphOutputs>
    > != 0; // There is at least one common type between the task and graph output types
 
template<class NodeType, class OutputType, class TupleGraphOutputs>
concept CompatibleOutputNodeForAType =
SenderNodeForAType<NodeType, OutputType> // The node is a sender node
    && ContainsInTupleConcept<OutputType, TupleGraphOutputs>; // The output type is part of the graph output types
 
template<class NodeType>
concept CopyableNode = requires(NodeType *n){
  { n->copy() }; // Check if the copy method is available
  std::is_same_v<decltype(n->copy()), std::shared_ptr<NodeType>>; // Check if copy() returns the right type
};
 
template<class MultiReceiver, class ...InputTypes>
concept ConcreteMultiReceiverImplementation =
(std::is_base_of_v<core::implementor::ImplementorReceiver<InputTypes>, MultiReceiver>, ...);
 
template<class MultiSender, class ...OutputTypes>
concept ConcreteMultiSenderImplementation =
(std::is_base_of_v<core::implementor::ImplementorSender<OutputTypes>, MultiSender>, ...);
 
template<class MultiExecute, class ...InputTypes>
concept ConcreteMultiExecuteImplementation =
(std::is_base_of_v<core::implementor::ImplementorExecute<InputTypes>, MultiExecute>, ...);
 
}
}
#endif //HEDGEHOG_CONCEPTS_H