FunctionalInterface.cpp

   1 #include "ArithmeticEvaluator.h"\r
   2 #include "FunctionalInterface.h"\r
   3 #include "ReferenceInterface.h"\r
   4 #include "GroupInterface.h"\r
   5 #include "FunctionalBlock.h"\r
   6 #include "GroupBlock.h"\r
   7 \r
   8 \r
   9 FunctionalInterface::FunctionalInterface(AbstractBlock* _owner, ReferenceInterface *_reference) throw(Exception) : ConnectedInterface(_owner) {\r
  10 \r
  11   if (_owner == NULL) throw(Exception(BLOCK_NULL));\r
  12   if (_reference == NULL) throw(Exception(IFACE_NULL));\r
  13 \r
  14   if (! _owner->isFunctionalBlock()) throw(Exception(BLOCK_INVALID_TYPE));\r
  15   if (! _reference->isReferenceInterface()) throw(Exception(IFACE_INVALID_TYPE));\r
  16 \r
  17   reference = _reference;\r
  18 \r
  19   name = reference->getName();\r
  20   width = reference->getWidth();\r
  21   direction = reference->getDirection();\r
  22   purpose = reference->getPurpose();  \r
  23   connectedFrom = NULL;\r
  24 }\r
  25 \r
  26 bool FunctionalInterface::isFunctionalInterface() {\r
  27   return true;\r
  28 }\r
  29 \r
  30 int FunctionalInterface::getInterfaceMultiplicity() {\r
  31 \r
  32   int i=0;\r
  33   int ifaceCount = 0;\r
  34   FunctionalInterface* iface = NULL;\r
  35 \r
  36   if (direction == AbstractInterface::Input) {\r
  37     QList<AbstractInterface *> inputs = owner->getInputs();\r
  38     for(i=0;i<inputs.size();i++) {\r
  39       iface = AI_TO_FUN(inputs.at(i));\r
  40       if (iface->getReference() == reference) {\r
  41         ifaceCount += 1;\r
  42       }\r
  43     }\r
  44   }\r
  45   else if (direction == AbstractInterface::Output) {\r
  46     QList<AbstractInterface *> outputs = owner->getOutputs();\r
  47     for(i=0;i<outputs.size();i++) {\r
  48       iface = AI_TO_FUN(outputs.at(i));\r
  49       if (iface->getReference() == reference) {\r
  50         ifaceCount += 1;\r
  51       }\r
  52     }\r
  53   }\r
  54   else if (direction == AbstractInterface::InOut) {\r
  55     QList<AbstractInterface *> bidirs = owner->getBidirs();\r
  56     for(i=0;i<bidirs.size();i++) {\r
  57       iface = AI_TO_FUN(bidirs.at(i));\r
  58       if (iface->getReference() == reference) {\r
  59         ifaceCount += 1;\r
  60       }\r
  61     }\r
  62   }\r
  63   if (ifaceCount == 0) {\r
  64     return -1;\r
  65   }\r
  66   else if ( reference->getMultiplicity() == -1) {\r
  67     return ifaceCount;\r
  68   }\r
  69   else if ( ifaceCount < reference->getMultiplicity()) {\r
  70     return ifaceCount;\r
  71   }\r
  72   return -1;\r
  73 }\r
  74 \r
  75 AbstractInterface *FunctionalInterface::clone() { \r
  76   int id = getInterfaceMultiplicity();\r
  77   if (id < 0) return NULL;\r
  78   FunctionalInterface *inter = new FunctionalInterface(owner, reference);\r
  79   inter->setWidth(width);\r
  80   inter->setDirection(direction);\r
  81   inter->setPurpose(purpose);  \r
  82   inter->connectFrom(NULL);\r
  83   inter->setName(reference->getName()+"_"+QString::number(id+1));\r
  84   return inter;\r
  85 }\r
  86 \r
  87 bool FunctionalInterface::canConnectTo(AbstractInterface *iface) {\r
  88 \r
  89   /* NOTE :\r
  90      necessary conditions :\r
  91         - this is an output or in/out interface\r
  92         - iface type must be functional or group interface\r
  93         - iface->connectedFrom must be NULL\r
  94 \r
  95      valid cases:\r
  96      1 - iface is owned by a block (group or func) that is within the same group as the block that own this\r
  97         1.1 - this is output and iface is input\r
  98         1.2 - both are inout\r
  99      2 - iface is owned by the parent group of the block that owns this\r
 100         2.1 - this is an output, iface is an output of the group\r
 101         2.2 - both are inout\r
 102 \r
 103   */\r
 104   if (direction == Input) return false;\r
 105   if (iface->isReferenceInterface()) return false;\r
 106   if (iface->getConnectedFrom() != NULL) return false;\r
 107 \r
 108   if (getOwner()->getParent() == iface->getOwner()->getParent()) {\r
 109 \r
 110     if ((direction == Output) && (iface->getDirection() == Input)) return true;\r
 111     if ((direction == InOut) && (iface->getDirection() == InOut)) return true;\r
 112   }\r
 113   else if (getOwner()->getParent() == iface->getOwner()) {\r
 114     if ((direction == Output) && (iface->getDirection() == Output)) return true;\r
 115     if ((direction == InOut) && (iface->getDirection() == InOut)) return true;\r
 116   }\r
 117 \r
 118   return false;\r
 119 \r
 120 }\r
 121 \r
 122 bool FunctionalInterface::canConnectFrom(AbstractInterface *iface) {\r
 123 \r
 124   /* NOTE :\r
 125      necessary conditions :\r
 126         - this is an input or in/out interface\r
 127         - iface type must be functional or group interface\r
 128         - this connectedFrom must be NULL\r
 129 \r
 130      valid cases:\r
 131      1 - iface is owned by a block (group or func) that is within the same group as the block that own this\r
 132         1.1 - this is input and iface is output\r
 133         1.2 - both are inout\r
 134      2 - iface is owned by the parent group of the block that owns this\r
 135         2.1 - this is an input, iface is an input of the group\r
 136         2.2 - both are inout\r
 137   */\r
 138   if (direction == Output) return false;\r
 139   if (iface->isReferenceInterface()) return false;\r
 140   if (connectedFrom != NULL) return false;\r
 141 \r
 142   if (getOwner()->getParent() == iface->getOwner()->getParent()) {\r
 143 \r
 144     if ((direction == Input) && (iface->getDirection() == Output)) return true;\r
 145     if ((direction == InOut) && (iface->getDirection() == InOut)) return true;\r
 146   }\r
 147   else if (getOwner()->getParent() == iface->getOwner()) {\r
 148     if ((direction == Input) && (iface->getDirection() == Input)) return true;\r
 149     if ((direction == InOut) && (iface->getDirection() == InOut)) return true;\r
 150   }\r
 151 \r
 152   return false;\r
 153 }\r
 154 \r
 155 \r
 156 void FunctionalInterface::connectionsValidation(QStack<AbstractInterface *> *interfacetoValidate, QList<AbstractInterface *> *validatedInterfaces) throw(Exception) {\r
 157 \r
 158   /*\r
 159   //inputs interfaces\r
 160   double widthInput, widthOutput;\r
 161   if(getDirection() == AbstractInterface::Input){\r
 162     widthInput = getDoubleWidth();\r
 163     widthOutput = getConnectedFrom()->getDoubleWidth();\r
 164     if(widthInput != widthOutput){\r
 165       throw new Exception(WIDTHS_NOT_EQUALS);\r
 166     }\r
 167     foreach(AbstractInterface *inter, getOwner()->getOutputs()){\r
 168       if(inter->isConnectedTo()){\r
 169         if((!interfacetoValidate->contains(inter)) && (!validatedInterfaces->contains(inter))){\r
 170           interfacetoValidate->push(inter);\r
 171         }\r
 172       }\r
 173     }\r
 174   }\r
 175   //outputs interfaces\r
 176   else if(getDirection() == AbstractInterface::Output){\r
 177     widthOutput = getDoubleWidth();\r
 178     foreach(AbstractInterface *inter, getConnectedTo()){\r
 179       widthInput = inter->getDoubleWidth();\r
 180       if(widthInput != widthOutput){\r
 181         throw new Exception(WIDTHS_NOT_EQUALS);\r
 182       }\r
 183     }\r
 184     foreach(AbstractInterface *inter, getConnectedTo()){\r
 185       if((!interfacetoValidate->contains(inter)) && (!validatedInterfaces->contains(inter))){\r
 186         interfacetoValidate->push(inter);\r
 187       }\r
 188     }\r
 189   }\r
 190   else if(getDirection() == AbstractInterface::InOut){\r
 191 \r
 192   }\r
 193 \r
 194   */\r
 195 }\r