hydrocouple.h

Go to the documentation of this file.

 
#ifndef HYDROCOUPLE_H
#define HYDROCOUPLE_H
 
#include <variant>
#include <string>
#include <array>
#include <vector>
#include <any>
#include <functional>
#include <list>
#include <set>
#include <memory>
 
using namespace std;
 
enum ByteOrder
{
 
  BigEndian = 0,
 
  LittleEndian = 1
};
 
namespace HydroCouple
{
  template <typename... Args>
  class ISignal;
  class IModelComponent;
  class IAdaptedOutputFactory;
  class IArgument;
  class IInput;
  class IOutput;
  class IExchangeItem;
  class IAdaptedOutput;
  class IAdaptedOutputFactory;
  class IAdaptedOutputFactoryComponent;
  class IUnit;
  class IComponentStatusChangeEventArgs;
  class IWorkflowComponent;
  class IWorkflowComponentStatusChangeEventArgs;
 
  typedef variant<
      bool,
      char,
      short,
      int,
      long,
      unsigned char,
      unsigned short,
      unsigned int,
      unsigned long,
      float,
      double,
      long double,
      string,
      void *>
      hydrocouple_variant;
 
  template <typename... Args>
  class ISlot
  {
  public:
    virtual ~ISlot() = default;
 
    virtual void operator()(const ISignal<Args...> &sender, Args... args) = 0;
  };
 
  template <typename... Args>
  class ISignal
  {
  public:
    virtual ~ISignal() = default;
 
    virtual void connect(const shared_ptr<ISlot<Args...>> &slot) = 0;
 
    virtual void disconnect(const shared_ptr<ISlot<Args...>> &slot) = 0;
 
    virtual void blockSignals(bool block) = 0;
 
  protected:
    virtual void emit(Args... args) = 0;
  };
 
  class IPropertyChanged : public virtual ISignal<string>
  {
 
  public:
    virtual ~IPropertyChanged() = default;
  };
 
  class IDescription : public virtual IPropertyChanged
  {
 
  public:
    virtual ~IDescription() = default;
 
    virtual string caption() const = 0;
 
    virtual void setCaption(const string &caption) = 0;
 
    virtual string description() const = 0;
 
    virtual void setDescription(const string &description) = 0;
  };
 
  class IIdentity : public virtual IDescription
  {
  public:
    virtual ~IIdentity() = default;
 
    virtual string id() const = 0;
  };
 
  class IComponentInfo : public virtual IIdentity
  {
 
  public:
    virtual ~IComponentInfo() = default;
 
    virtual string libraryFilePath() const = 0;
 
    virtual void setLibraryFilePath(const string &filePath) = 0;
 
    virtual string iconFilePath() const = 0;
 
    virtual string developer() const = 0;
 
    virtual list<string> documentation() const = 0;
 
    virtual string license() const = 0;
 
    virtual string copyright() const = 0;
 
    virtual string url() const = 0;
 
    virtual string email() const = 0;
 
    virtual string version() const = 0;
 
    virtual set<string> tags() const = 0;
 
    virtual bool validateLicense(const string &licenseInfo, string &validationMessage) = 0;
 
    virtual bool validateLicense(string &validationMessage) = 0;
  };
 
  class IModelComponentInfo : public virtual IComponentInfo
  {
 
  public:
    virtual ~IModelComponentInfo() = default;
 
    virtual IModelComponent *createComponentInstance() = 0;
 
    virtual vector<IAdaptedOutputFactory *> adaptedOutputFactories() const = 0;
  };
 
  class IModelComponent : public virtual IIdentity, public virtual ISignal<const shared_ptr<IComponentStatusChangeEventArgs> &>
  {
 
  public:
    enum ComponentStatus
    {
      Created,
 
      Initializing,
 
      Initialized,
 
      Validating,
 
      Valid,
 
      WaitingForData,
 
      Invalid,
 
      Preparing,
 
      Updating,
 
      Updated,
 
      Done,
 
      Finishing,
 
      Finished,
 
      Failed,
    };
 
    virtual ~IModelComponent() = default;
 
    virtual IModelComponentInfo *componentInfo() const = 0;
 
    virtual ComponentStatus status() const = 0;
 
    virtual vector<IArgument *> arguments() const = 0;
 
    virtual vector<IInput *> inputs() const = 0;
 
    virtual vector<IOutput *> outputs() const = 0;
 
    virtual vector<IComponentDataItem *> results() const = 0;
 
    virtual void initialize() = 0;
 
    virtual vector<string> validate() = 0;
 
    virtual void prepare() = 0;
 
    virtual void update(const initializer_list<IOutput *> &requiredOutputs = {}) = 0;
 
    virtual void finish() = 0;
 
    virtual const IWorkflowComponent *workflow() const = 0;
 
    virtual void setWorkflow(const IWorkflowComponent *workflow) = 0;
 
    virtual int mpiNumOfProcesses() const = 0;
 
    virtual int mpiProcessRank() const = 0;
 
    virtual void mpiSetProcessRank(int processRank) = 0;
 
    virtual set<int> mpiAllocatedProcesses() const = 0;
 
    virtual void mpiAllocateProcesses(const set<int> &mpiProcessesToAllocate) = 0;
 
    virtual void mpiClearAllocatedProcesses() = 0;
 
    virtual string referenceDirectory() const = 0;
 
    virtual void setReferenceDirectory(const string &referenceDirectory) = 0;
 
    virtual bool hasEditor() const = 0;
 
    virtual void showEditor(void *opaqueUIPointer = nullptr) = 0;
 
    virtual bool hasViewer() const = 0;
 
    virtual void showViewer(void *opaqueUIPointer = nullptr) = 0;
  };
 
  class IProxyModelComponent : public virtual IModelComponent
  {
 
  public:
    virtual ~IProxyModelComponent() = default;
 
    virtual int parentMpiProcessRank() const = 0;
 
    virtual string parentProcessAddress() const = 0;
 
    virtual string parentId() const = 0;
  };
 
  class IComponentStatusChangeEventArgs
  {
  public:
    virtual ~IComponentStatusChangeEventArgs() = default;
 
    virtual IModelComponent *component() const = 0;
 
    virtual IModelComponent::ComponentStatus previousStatus() const = 0;
 
    virtual IModelComponent::ComponentStatus status() const = 0;
 
    virtual string message() const = 0;
 
    virtual bool hasProgressMonitor() const = 0;
 
    virtual float percentProgress() const = 0;
  };
 
  class ICloneableModelComponent : public virtual IModelComponent
  {
  public:
    virtual ~ICloneableModelComponent() = default;
 
    virtual ICloneableModelComponent *parent() const = 0;
 
    virtual ICloneableModelComponent *clone(const unordered_map<string, hydrocouple_variant> &clone_optional_arguments = unordered_map<string, hydrocouple_variant>()) = 0;
 
    virtual vector<ICloneableModelComponent *> clones() const = 0;
  };
 
  class IValueDefinition : public virtual IDescription
  {
  public:
    virtual ~IValueDefinition() = default;
 
    virtual type_info type() const = 0;
 
    virtual hydrocouple_variant missingValue() const = 0;
 
    virtual hydrocouple_variant defaultValue() const = 0;
  };
 
  class IDimension : public virtual IIdentity
  {
  public:
    enum LengthType
    {
      Static = 0,
 
      Dynamic = 1
    };
 
    virtual ~IDimension() = default;
 
    virtual LengthType lengthType() const = 0;
  };
 
  class IQuality : public virtual IValueDefinition
  {
  public:
    virtual ~IQuality() = default;
 
    virtual set<hydrocouple_variant> categories() const = 0;
 
    virtual bool isOrdered() const = 0;
  };
 
  class IUnitDimensions : public virtual IDescription
  {
  public:
    enum FundamentalUnitDimension
    {
      Length,
 
      Mass,
 
      Time,
 
      ElectricCurrent,
 
      Temperature,
 
      AmountOfSubstance,
 
      LuminousIntensity,
 
      Currency,
 
      Unitless,
    };
 
    virtual ~IUnitDimensions() = default;
 
    virtual double power(HydroCouple::IUnitDimensions::FundamentalUnitDimension dimension) = 0;
  };
 
  class IUnit : public virtual IDescription
  {
  public:
    enum class DistanceUnitType
    {
      Standard,
      Geographic,
      Unknown
    };
 
    enum class DistanceUnits
    {
 
      Meters,
 
      Kilometers,
 
      Feet,
 
      NauticalMiles,
 
      Yards,
 
      Miles,
 
      Degrees,
 
      Centimeters,
 
      Millimeters,
 
      Inches,
 
      Unknown
    };
 
    enum AreaUnits
    {
 
      SquareMeters,
 
      SquareKilometers,
 
      SquareFeet,
 
      SquareYards,
 
      SquareMiles,
 
      Hectares,
 
      Acres,
 
      SquareNauticalMiles,
 
      SquareDegrees,
 
      SquareCentimeters,
 
      SquareMillimeters,
 
      SquareInches,
 
      Unknown
    };
 
    virtual ~IUnit() = default;
 
    virtual IUnitDimensions *dimensions() const = 0;
 
    virtual double conversionFactorToSI() const = 0;
 
    virtual double offsetToSI() const = 0;
  };
 
  class IQuantity : public virtual IValueDefinition
  {
  public:
    virtual ~IQuantity() = default;
 
    virtual IUnit *unit() const = 0;
 
    virtual hydrocouple_variant minValue() const = 0;
 
    virtual hydrocouple_variant maxValue() const = 0;
  };
 
  class IComponentDataItem : public virtual IIdentity, public virtual ISignal<const shared_ptr<IComponentDataItemValueChanged> &>
  {
  public:
    virtual ~IComponentDataItem() = default;
 
    virtual IModelComponent *modelComponent() const = 0;
 
    virtual vector<IDimension *> dimensions() const = 0;
 
    virtual int dimensionLength(const initializer_list<int> &dimensionIndexes = {}) const = 0;
 
    virtual IValueDefinition *valueDefinition() const = 0;
 
    virtual void getValue(
        hydrocouple_variant &data,
        const initializer_list<int> &dimensionIndexes) const = 0;
 
    virtual void getValues(
        hydrocouple_variant *data,
        const initializer_list<int> &dimensionIndexes,
        const initializer_list<int> &dimensionLengths = {}) const = 0;
 
    virtual void setValue(
        const hydrocouple_variant &data,
        const initializer_list<int> &dimensionIndexes) = 0;
 
    virtual void setValues(
        const hydrocouple_variant *data,
        const initializer_list<int> &dimensionIndexes,
        const initializer_list<int> &dimensionLengths = {}) = 0;
 
    virtual bool hasEditor() const = 0;
 
    virtual void showEditor(void *opaqueUIPointer = nullptr) = 0;
 
    virtual bool hasViewer() const = 0;
 
    virtual void showViewer(void *opaqueUIPointer = nullptr) = 0;
  };
 
  class IComponentDataItemValueChanged
  {
  public:
    virtual ~IComponentDataItemValueChanged() = default;
 
    virtual IComponentDataItem *componentDataItem() const = 0;
 
    virtual initializer_list<int> dimensionIndexes() const = 0;
 
    virtual initializer_list<int> dimensionLengths() const = 0;
  };
 
  class IArgument : public virtual IComponentDataItem
  {
 
  public:
    enum ArgumentInputType
    {
      String,
 
      File,
 
      /*
       * \brief Enumeration indicating that the argument was read from a URL.
       */
      JSON,
 
      XML,
 
      URL,
 
      MEMORY_OBJECT
    };
 
    virtual ~IArgument() = default;
 
    virtual bool isOptional() const = 0;
 
    virtual bool isReadOnly() const = 0;
 
    virtual string toString() const = 0;
 
    virtual void saveData() = 0;
 
    virtual list<string> fileFilters() const = 0;
 
    virtual list<type_info> validComponentDataItemTypes() const = 0;
 
    virtual bool isValidArgType(ArgumentInputType argType) const = 0;
 
    virtual ArgumentInputType currentArgumentInputType() const = 0;
 
    virtual bool initialize(const string &value, ArgumentInputType argType, string &message) = 0;
 
    virtual bool initialize(const IComponentDataItem &componentDataItem, string &message) = 0;
  };
 
  class IExchangeItemChangeEventArgs
  {
  public:
    virtual ~IExchangeItemChangeEventArgs() = default;
 
    virtual IExchangeItem *exchangeItem() const = 0;
 
    virtual string message() const = 0;
  };
 
  class IExchangeItem : public virtual IComponentDataItem
  {
 
  public:
    virtual ~IExchangeItem() = default;
  };
 
  class IOutput : public virtual IExchangeItem
  {
  public:
    virtual ~IOutput() = default;
 
    virtual vector<IInput *> consumers() const = 0;
 
    virtual void addConsumer(IInput *consumer) = 0;
 
    virtual bool removeConsumer(IInput *consumer) = 0;
 
    virtual vector<IAdaptedOutput *> adaptedOutputs() const = 0;
 
    virtual void addAdaptedOutput(IAdaptedOutput *adaptedOutput) = 0;
 
    virtual bool removeAdaptedOutput(IAdaptedOutput *adaptedOutput) = 0;
 
    virtual void updateValues(const IInput *querySpecifier) = 0;
  };
 
  class IAdaptedOutput : public virtual IOutput
  {
  public:
    virtual ~IAdaptedOutput() = default;
 
    virtual IAdaptedOutputFactory *adaptedOutputFactory() const = 0;
 
    virtual vector<IArgument *> arguments() const = 0;
 
    virtual void initialize() = 0;
 
    virtual IOutput *adaptee() const = 0;
 
    virtual void refresh() = 0;
  };
 
  class IAdaptedOutputFactory : public virtual IIdentity
  {
  public:
    virtual ~IAdaptedOutputFactory() = default;
 
    virtual vector<IIdentity *> getAvailableAdaptedOutputIds(const IOutput *provider, const IInput *consumer = nullptr) = 0;
 
    virtual IAdaptedOutput *createAdaptedOutput(IIdentity *adaptedProviderId, IOutput *provider, IInput *consumer = nullptr) = 0;
  };
 
  class IAdaptedOutputFactoryComponentInfo : public virtual IComponentInfo
  {
  public:
    virtual ~IAdaptedOutputFactoryComponentInfo() = default;
 
    virtual IAdaptedOutputFactoryComponent *createComponentInstance() = 0;
  };
 
  class IAdaptedOutputFactoryComponent : public virtual IAdaptedOutputFactory
  {
  public:
    virtual ~IAdaptedOutputFactoryComponent() = default;
 
    virtual IAdaptedOutputFactoryComponentInfo *componentInfo() const = 0;
  };
 
  class IInput : public virtual IExchangeItem
  {
  public:
    virtual ~IInput() = default;
 
    virtual IOutput *provider() const = 0;
 
    virtual bool setProvider(IOutput *provider) = 0;
 
    virtual bool canConsume(IOutput *provider, string &message) const = 0;
  };
 
  class IMultiInput : public virtual IInput
  {
  public:
    virtual ~IMultiInput() = default;
 
    virtual vector<IIdentity *> providerLabels() const = 0;
 
    virtual bool isRequiredProvider(const IIdentity *providerLabel) const = 0;
 
    virtual vector<IOutput *> providers() const = 0;
 
    virtual void canConsume(IOutput *provider, string &message, const IIdentity *providerRoleIdentifier = nullptr) const = 0;
 
    virtual bool addProvider(IOutput *provider, const IIdentity *providerRoleIdentifier = nullptr) = 0;
 
    virtual bool removeProvider(IOutput *provider) = 0;
  };
 
  class IIdBasedComponentDataItem : public virtual IComponentDataItem
  {
 
  public:
    using IComponentDataItem::getValue;
    using IComponentDataItem::getValues;
    using IComponentDataItem::setValue;
    using IComponentDataItem::setValues;
 
    virtual ~IIdBasedComponentDataItem() = default;
 
    virtual vector<string> identifiers() const = 0;
 
    virtual IDimension *identifierDimension() const = 0;
 
    virtual void getValue(
        hydrocouple_variant &data,
        int idIndex,
        const initializer_list<int> &dimensionIndexes = {}) const = 0;
 
    virtual void getValues(
        hydrocouple_variant *data,
        const initializer_list<int> &idIndexes,
        const initializer_list<int> &dimensionIndexes = {},
        const initializer_list<int> &dimensionLengths = {}) const = 0;
 
    virtual void getValues(
        hydrocouple_variant *data,
        int idIndex,
        const initializer_list<int> &dimensionIndexes = {},
        int idIndexLength = 1,
        const initializer_list<int> &dimensionLengths = {}) const = 0;
 
    virtual void setValue(
        const hydrocouple_variant &data,
        int idIndex,
        const initializer_list<int> &dimensionIndexes = {}) = 0;
 
    virtual void setValues(
        const hydrocouple_variant *data,
        const initializer_list<int> &idIndexes,
        const initializer_list<int> &dimensionIndexes = {},
        const initializer_list<int> &dimensionLengths = {}) = 0;
 
    virtual void setValues(
        const hydrocouple_variant *data,
        int idIndex,
        const initializer_list<int> &dimensionIndexes = {},
        int idIndexLength = 1,
        const initializer_list<int> &dimensionLengths = {}) = 0;
  };
 
  class IWorkflowComponentInfo : public virtual IComponentInfo
  {
 
  public:
    virtual ~IWorkflowComponentInfo() = default;
 
    virtual IWorkflowComponent *createComponentInstance() = 0;
  };
 
  class IWorkflowComponent : public virtual IIdentity, public virtual ISignal<const shared_ptr<IWorkflowComponentStatusChangeEventArgs> &>
  {
 
  public:
    enum WorkflowStatus
    {
      Created,
      Initializing,
      Initialized,
      Updating,
      Updated,
      Done,
      Finishing,
      Finished,
      Failed
    };
 
    virtual ~IWorkflowComponent() = default;
 
    virtual IWorkflowComponentInfo *componentInfo() const = 0;
 
    virtual vector<IIdentity *> modelComponentLabels() const = 0;
 
    virtual bool isRequiredModelComponent(const IIdentity *modelComponentLabel) const = 0;
 
    virtual void initialize() = 0;
 
    virtual void update() = 0;
 
    virtual void finish() = 0;
 
    virtual WorkflowStatus status() const = 0;
 
    virtual vector<IModelComponent *> modelComponents() const = 0;
 
    virtual bool addModelComponent(IModelComponent *component, const IIdentity *modelRoleIdentifier = nullptr) = 0;
 
    virtual bool removeModelComponent(IModelComponent *component) = 0;
  };
 
  class IWorkflowComponentStatusChangeEventArgs
  {
  public:
    virtual ~IWorkflowComponentStatusChangeEventArgs() = default;
 
    virtual IWorkflowComponent *workflowComponent() const = 0;
 
    virtual IWorkflowComponent::WorkflowStatus previousStatus() const = 0;
 
    virtual IWorkflowComponent::WorkflowStatus status() const = 0;
 
    virtual string message() const = 0;
 
    virtual bool hasProgressMonitor() const = 0;
 
    virtual float percentProgress() const = 0;
  };
 
}
 
#endif // HYDROCOUPLE_H