hydrocouple.h

Go to the documentation of this file.

 
#ifndef HYDROCOUPLE_H
#define HYDROCOUPLE_H
 
 
#include <any>
#include <functional>
#include <list>
#include <set>
 
 
using namespace std;
 
enum ByteOrder
{
  BigEndian = 0,
  LittleEndian = 1
};
 
namespace HydroCouple
{
  class IModelComponent;
  class IAdaptedOutputFactory;
  class IArgument;
  class IInput;
  class IOutput;
  class IExchangeItem;
  class IAdaptedOutput;
  class IAdaptedOutputFactory;
  class IAdaptedOutputFactoryComponent;
  class IUnit;
  class IComponentStatusChangeEventArgs;
  class IWorkflowComponent;
 
 
  typedef  variant<
      bool,
      char,
      short,
      int,
      long,
      unsigned char,
      unsigned short,
      unsigned int,
      unsigned long,
      float,
      double,
      long double,
      string
      > hydrocouple_variant;
 
 
  class IPropertyChanged
  {
 
  public:
    
    virtual ~IPropertyChanged() = 0;
 
    virtual void registerPropertyChangedListener(const function<void(const any&, const string&)>& propertyChangedListener) = 0;
 
    virtual void deRegisterPropertyChangedListener(const function<void(const any&, const string& propertyName)>& propertyChangedListener) = 0;
 
  };
 
  class IDescription : public virtual IPropertyChanged
  {
 
  public:
 
    virtual ~IDescription() = 0;
 
    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() = 0;
 
    virtual string id() const = 0;
  };
 
  class IComponentInfo : public virtual IIdentity
  {
 
  public:
    virtual ~IComponentInfo() = 0;
 
    virtual string libraryFilePath() const = 0;
 
    virtual void setLibraryFilePath(const string &filePath) = 0;
 
    virtual string iconFilePath() const = 0;
 
    virtual string vendor() 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() = 0;
 
    virtual IModelComponent *createComponentInstance() = 0;
 
    virtual vector<IAdaptedOutputFactory *> adaptedOutputFactories() const = 0;
  };
 
  class IModelComponent : public virtual IIdentity
  {
 
  public:
    enum ComponentStatus
    {
      Created,
 
      Initializing,
 
      Initialized,
 
      Validating,
 
      Valid,
 
      WaitingForData,
 
      Invalid,
 
      Preparing,
 
      Updating,
 
      Updated,
 
      Done,
 
      Finishing,
 
      Finished,
 
      Failed,
    };
 
    virtual ~IModelComponent() = 0;
 
    virtual IModelComponentInfo *componentInfo() const = 0;
 
    virtual vector<IArgument *> arguments() const = 0;
 
    virtual ComponentStatus status() const = 0;
 
    virtual vector<IInput *> inputs() const = 0;
 
    virtual vector<IOutput *> outputs() const = 0;
 
    virtual void initialize() = 0;
 
    virtual vector<string> validate() = 0;
 
    virtual void prepare() = 0;
 
    virtual void update(const vector<IOutput *> &requiredOutputs = vector<IOutput *>()) = 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 void registerComponentStatusChangedListener(const function<void(const shared_ptr<IComponentStatusChangeEventArgs>&)>& statusChangedEventListener) = 0;
 
    virtual void deRegisterComponentStatusChangedListener(const function<void(const shared_ptr<IComponentStatusChangeEventArgs>&)>& statusChangedEventListener) = 0;
  };
 
  class IProxyModelComponent : public virtual IModelComponent
  {
 
  public:
    virtual ~IProxyModelComponent() = 0;
 
    virtual int parentMpiProcessRank() const = 0;
 
    virtual string parentId() const = 0;
  };
 
  class IComponentStatusChangeEventArgs
  {
  public:
    virtual ~IComponentStatusChangeEventArgs() = 0;
 
    virtual IModelComponent *component() const = 0;
 
    virtual HydroCouple::IModelComponent::ComponentStatus previousStatus() const = 0;
 
    virtual HydroCouple::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() = 0;
 
    virtual ICloneableModelComponent *parent() const = 0;
 
    virtual ICloneableModelComponent *clone() = 0;
 
    virtual list<ICloneableModelComponent *> clones() const = 0;
  };
 
  class IValueDefinition : public virtual IDescription
  {
  public:
    virtual ~IValueDefinition() = 0;
 
    virtual  type_info type() const = 0;
 
    virtual hydrocouple_variant missingValue() const = 0;
 
    virtual hydrocouple_variant defaultValue() const = 0;
  };
 
  class IDimension : public virtual IIdentity
  {
  public:
    virtual ~IDimension() = 0;
  };
 
  class IQuality : public virtual IValueDefinition
  {
  public:
    virtual ~IQuality() = 0;
 
    virtual vector<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
    };
 
 
    virtual ~IUnitDimensions() = 0;
 
    virtual double getPower(HydroCouple::IUnitDimensions::FundamentalUnitDimension dimension) = 0;
  };
 
  class IUnit : public virtual IDescription
  {
  public:
 
    virtual ~IUnit() = 0;
 
    virtual IUnitDimensions *dimensions() const = 0;
 
    virtual double conversionFactorToSI() const = 0;
 
    virtual double offsetToSI() const = 0;
  };
 
  class IQuantity : public virtual IValueDefinition
  {
  public:
    virtual ~IQuantity() = 0;
 
    virtual IUnit *unit() const = 0;
 
    virtual hydrocouple_variant minValue() const = 0;
 
    virtual hydrocouple_variant maxValue() const = 0;
  };
 
  class IComponentDataItem : public virtual IIdentity
  {
  public:
 
    virtual ~IComponentDataItem() = 0;
 
    virtual IModelComponent *modelComponent() const = 0;
 
    virtual vector<IDimension *> dimensions() const = 0;
 
    virtual int dimensionLength(const vector<int> &dimensionIndexes) const = 0;
 
    virtual IValueDefinition *valueDefinition() const = 0;
 
    virtual void getValue(const vector<int> &dimensionIndexes, void *data) const = 0;
 
    virtual void setValue(const vector<int> &dimensionIndexes, const void *data) = 0;
 
 
    virtual bool hasEditor() const = 0;
 
    virtual void showEditor() = 0;
 
    virtual bool hasViewer() const = 0;
 
    virtual void showViewer() = 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
    };
 
    virtual ~IArgument() = 0;
 
    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 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() = 0;
 
    virtual IExchangeItem *exchangeItem() const = 0;
 
    virtual string message() const = 0;
  };
 
  class IExchangeItem : public virtual IComponentDataItem
  {
 
  public:
    virtual ~IExchangeItem() = 0;
 
    virtual void registerExchangeItemStatusChangedListener(const function<void(const shared_ptr<IExchangeItemChangeEventArgs>&)>& exchangeItemChangedEventListener) = 0;
 
    virtual void deRegisterExchangeItemStatusChangedListener(const function<void(const shared_ptr<IExchangeItemChangeEventArgs>&)>& exchangeItemChangedEventListener) = 0;
  };
 
  class IOutput : public virtual IExchangeItem
  {
  public:
 
    virtual ~IOutput() = 0;
 
    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(IInput *querySpecifier) = 0;
  };
 
  class IAdaptedOutput : public virtual IOutput
  {
  public:
 
    virtual ~IAdaptedOutput() = 0;
 
    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() = 0;
 
    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() = 0;
 
    virtual IAdaptedOutputFactoryComponent *createComponentInstance() = 0;
  };
 
  class IAdaptedOutputFactoryComponent : public virtual IAdaptedOutputFactory
  {
  public:
 
    virtual ~IAdaptedOutputFactoryComponent() = 0;
 
    virtual IAdaptedOutputFactoryComponentInfo *componentInfo() const = 0;
  };
 
  class IInput : public virtual IExchangeItem
  {
  public:
 
    virtual ~IInput() = 0;
 
    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() = 0;
 
    virtual vector<IOutput *> providers() const = 0;
 
    virtual bool addProvider(IOutput *provider) = 0;
 
    virtual bool removeProvider(IOutput *provider) = 0;
  };
 
  class IIdBasedComponentDataItem : public virtual IComponentDataItem
  {
    using IComponentDataItem::getValue;
    using IComponentDataItem::setValue;
 
  public:
    virtual ~IIdBasedComponentDataItem() = 0;
 
    virtual list<string> identifiers() const = 0;
 
    virtual IDimension *identifierDimension() const = 0;
 
    virtual void getValue(int idIndex, void *data) const = 0;
 
    virtual void getValues(int idIndex, int stride, void *data) const = 0;
 
    virtual void setValue(int idIndex, const void *data) = 0;
 
    virtual void setValues(int idIndex, int stride, const void *data) = 0;
  };
 
  class IWorkflowComponentInfo : public virtual IComponentInfo
  {
 
  public:
 
    virtual ~IWorkflowComponentInfo() = 0;
 
    virtual IWorkflowComponent *createComponentInstance() = 0;
  };
 
  class IWorkflowComponent : public virtual IIdentity
  {
 
  public:
    enum WorkflowStatus
    {
      Created,
      Initializing,
      Initialized,
      Updating,
      Updated,
      Done,
      Finishing,
      Finished,
      Failed
    };
 
    virtual ~IWorkflowComponent() = 0;
 
    virtual IWorkflowComponentInfo *componentInfo() const = 0;
 
    virtual void initialize() = 0;
 
    virtual void update() = 0;
 
    virtual void finish() = 0;
 
    virtual WorkflowStatus status() const = 0;
 
    virtual list<IModelComponent *> modelComponents() const = 0;
 
    virtual void addModelComponent(IModelComponent *component) = 0;
 
    virtual void removeModelComponent(IModelComponent *component) = 0;
 
    virtual void registerComponentStatusChangedListener(const function<void(const IWorkflowComponent*, WorkflowStatus, const string&)>& workflowComponentStatusChangedListener) = 0;
 
    virtual void deRegisterComponentStatusChangedListener(const function<void(const IWorkflowComponent*, WorkflowStatus, const string&)>& workflowComponentStatusChangedListener) = 0;
 
  };
 
}
 
#endif // HYDROCOUPLE_H