AbstractInterface.h

   1 #ifndef __ABSTRACTINTERFACE_H__
   2 #define __ABSTRACTINTERFACE_H__
   3
   4 #include <iostream>
   5
   6 #include <QtCore>
   7 #include <QtGui>
   8
   9 class AbstractBlock;
  10
  11 #include "Exception.h"
  12 class Exception;
  13
  14 #define AI_TO_REF(ptr) ((ReferenceInterface*)ptr)
  15 #define AI_TO_FUN(ptr) ((FunctionalInterface*)ptr)
  16 #define AI_TO_GRP(ptr) ((GroupInterface*)ptr)
  17
  18 using namespace std;
  19 using namespace Qt;
  20
  21
  22 class AbstractInterface {
  23
  24 public :
  25
  26   enum IfaceWidthType { Expression = 1, Boolean, Natural, Inherited}; //! Inherited is only for Group interface
  27   enum IfacePurpose { Data = 1, Control, Clock, Reset, Wishbone };
  28   enum IfaceDirection { Input = 1, Output = 2, InOut = 3 };
  29   enum IfaceVHDLContext { Entity = 1, Component = 2, Architecture = 3 }; // NB : 3 is when creating an instance of the block that owns this iface
  30   enum IfaceVHDLFlags { NoComma = 1 };
  31
  32   static int getIntDirection(QString str);
  33
  34   AbstractInterface(AbstractBlock* _owner);
  35   AbstractInterface(AbstractBlock* _owner, const QString& _name, const QString& _type, const QString& _width, int _direction, int _purpose);
  36   AbstractInterface(AbstractInterface* other);
  37   virtual ~AbstractInterface();
  38
  39   // getters
  40   inline QString getName() { return name;}
  41   inline int getType() { return type; }
  42   QString getTypeString();
  43   inline QString getWidth() { return width;}
  44   inline int getPurpose() { return purpose;}
  45   QString getPurposeString();
  46   inline int getDirection() { return direction;}
  47   QString getDirectionString();
  48   inline AbstractBlock *getOwner() { return owner;}
  49   inline AbstractInterface* getAssociatedIface() { return associatedIface; }
  50
  51   double getDoubleWidth() throw(QException);
  52
  53   inline QList<char> getConsumptionPattern() { return consumptionPattern; }
  54   inline QList<char> getProductionPattern() { return productionPattern; }
  55   inline QList<char> getOutputPattern() { return outputPattern; }
  56
  57   //virtual QList<AbstractInterface*> getConnectedTo() = 0;
  58
  59   /* NB: only GroupInterface and FunctionalInterface have a connectedFrom, so
  60      defining getConnectedFrom as pure virtual is normal, usefull even though it is ugly :-)
  61    */
  62   virtual AbstractInterface* getConnectedFrom() = 0;
  63
  64   // setters
  65   inline void setOwner(AbstractBlock* _owner) { owner = _owner; }
  66   inline void setName(const QString& _name) { name = _name; }
  67   inline void setWidth(const QString& _width) { width = _width; }
  68   inline void setType(int _type) { type = _type;}
  69   inline void setType(const QString& _type) { type = typeFromString(_type);}
  70   void setPurpose(int _purpose);
  71   void setDirection(int _direction);
  72   bool setAssociatedIface(AbstractInterface* iface);
  73
  74   inline void setConsumptionPattern(QList<char> pattern) { consumptionPattern = pattern; }
  75   inline void setProductionPattern(QList<char> pattern) { productionPattern = pattern; }
  76   inline void setOutputPattern(QList<char> pattern) { outputPattern = pattern; }
  77
  78   // testers
  79   virtual bool isReferenceInterface();
  80   virtual bool isFunctionalInterface();
  81   virtual bool isGroupInterface();
  82   //virtual bool isConnectedTo() = 0;
  83   //virtual bool isConnectedFrom() = 0;
  84   //virtual bool canConnectTo(AbstractInterface* iface) = 0; // returns yes if this can be connected to iface, no if not
  85   //virtual bool canConnectFrom(AbstractInterface* iface) = 0; // returns yes if this can be connected from iface, no if not
  86
  87   // others
  88   virtual AbstractInterface *clone() = 0;
  89
  90   //virtual bool addConnectedTo(AbstractInterface *inter) = 0;
  91   //virtual void removeConnectedTo(AbstractInterface *inter) = 0;
  92   //virtual bool setConnectedFrom(AbstractInterface* inter) = 0;
  93   //virtual void clearConnectedTo() = 0;
  94   //virtual void clearConnections() = 0;
  95   //virtual void connectionsValidation(QStack<AbstractInterface*> *interfacetoValidate, QList<AbstractInterface*> *validatedInterfaces) throw(Exception) = 0;
  96   int typeFromString(const QString &_type);
  97
  98   QString toVHDL(int context, int flags) throw(Exception);
  99
 100 protected:
 101   QString name;
 102   int type;
 103   QString width;
 104   int purpose;
 105   int direction;
 106
 107   AbstractBlock* owner;
 108   /*!
 109    * \brief associatedIface the control (resp. data) interface that is bounded to this data (resp. control) interface
 110    * If a reference block is designed to be fully integrated in Blast, nearly every data interface is bounded
 111    * to a control interface that signals if the value presented on the interface is valid or not. associatedIface
 112    * references this control interface if this is a data interface, and a data interface is this is a control interface.
 113    * Note that the association is done by the call of setAssociatedIface() that must be done only for a control interface.
 114    * (NB: a test is done in the method to prevent the other case).
 115    */
 116   AbstractInterface* associatedIface;
 117
 118   // patterns
 119   QList<char> consumptionPattern; //! only usefull for input interfaces
 120   QList<char> productionPattern; //! only usefull for output interfaces
 121
 122   QList<char> outputPattern; //! only usefull for output interfaces
 123 };
 124
 125
 126 #endif // __ABSTRACTINTERFACE_H__