#define AI_TO_REF(ptr) ((ReferenceInterface*)ptr)
#define AI_TO_FUN(ptr) ((FunctionalInterface*)ptr)
#define AI_TO_GRP(ptr) ((GroupInterface*)ptr)
+#define AI_TO_CON(ptr) ((ConnectedInterface*)ptr)
using namespace std;
using namespace Qt;
public :
- enum IfaceWidthType { Expression = 1, Boolean, Natural};
- enum IfacePurpose { Data = 1, Control, Clock, Reset, Wishbone };
- enum IfaceDirection { Input = 1, Output = 2, InOut = 3 };
- enum IfaceVHDLContext { Entity = 1, Component = 2, Architecture = 3 }; // NB : 3 is when creating an instance of the block that owns this iface
+ enum IfaceWidthType { Expression = 1, Boolean, Natural, Inherited}; //! Inherited is only for Group interface
+ enum IfacePurpose { AnyPurpose = 0, Data = 1, Control, Clock, Reset, Wishbone };
+ enum IfaceDirection { AnyDirection = 0, Input = 1, Output = 2, InOut = 3 };
+ enum IfaceVHDLContext {AnyContext = 0, Entity = 1, Component = 2, Architecture = 3 }; // NB : 3 is when creating an instance of the block that owns this iface
enum IfaceVHDLFlags { NoComma = 1 };
- static int getIntDirection(QString str);
+ static int getIntDirection(QString str);
+ static int getIntPurpose(QString str);
AbstractInterface(AbstractBlock* _owner);
AbstractInterface(AbstractBlock* _owner, const QString& _name, const QString& _type, const QString& _width, int _direction, int _purpose);
inline int getDirection() { return direction;}
QString getDirectionString();
inline AbstractBlock *getOwner() { return owner;}
+ inline AbstractInterface* getAssociatedIface() { return associatedIface; }
double getDoubleWidth() throw(QException);
-
- //virtual QList<AbstractInterface*> getConnectedTo() = 0;
-
- /* NB: only GroupInterface and FunctionalInterface have a connectedFrom, so
- defining getConnectedFrom as pure virtual is normal, usefull even though it is ugly :-)
- */
- virtual AbstractInterface* getConnectedFrom() = 0;
+
// setters
inline void setOwner(AbstractBlock* _owner) { owner = _owner; }
inline void setType(int _type) { type = _type;}
inline void setType(const QString& _type) { type = typeFromString(_type);}
void setPurpose(int _purpose);
- void setDirection(int _direction);
-
+ void setDirection(int _direction);
+ bool setAssociatedIface(AbstractInterface* iface);
+
// testers
virtual bool isReferenceInterface();
virtual bool isFunctionalInterface();
virtual bool isGroupInterface();
- //virtual bool isConnectedTo() = 0;
- //virtual bool isConnectedFrom() = 0;
- //virtual bool canConnectTo(AbstractInterface* iface) = 0; // returns yes if this can be connected to iface, no if not
- //virtual bool canConnectFrom(AbstractInterface* iface) = 0; // returns yes if this can be connected from iface, no if not
// others
virtual AbstractInterface *clone() = 0;
-
- //virtual bool addConnectedTo(AbstractInterface *inter) = 0;
- //virtual void removeConnectedTo(AbstractInterface *inter) = 0;
- //virtual bool setConnectedFrom(AbstractInterface* inter) = 0;
- //virtual void clearConnectedTo() = 0;
- //virtual void clearConnections() = 0;
- //virtual void connectionsValidation(QStack<AbstractInterface*> *interfacetoValidate, QList<AbstractInterface*> *validatedInterfaces) throw(Exception) = 0;
+
int typeFromString(const QString &_type);
QString toVHDL(int context, int flags) throw(Exception);
int direction;
AbstractBlock* owner;
+ /*!
+ * \brief associatedIface the control (resp. data) interface that is bounded to this data (resp. control) interface
+ * If a reference block is designed to be fully integrated in Blast, nearly every data interface is bounded
+ * to a control interface that signals if the value presented on the interface is valid or not. associatedIface
+ * references this control interface if this is a data interface, and a data interface is this is a control interface.
+ * Note that the association is done by the call of setAssociatedIface() that must be done only for a control interface.
+ * (NB: a test is done in the method to prevent the other case).
+ */
+ AbstractInterface* associatedIface;
+
+
};
