modifying pattern methods to throw exceptions

[blast.git] / GroupBlock.cpp

diff --git a/GroupBlock.cpp b/GroupBlock.cpp
index 4ec7f6bbe45d717fc51620a545a9a3d6dc21d51e..b6fc702d0f317701290434843331da6545b1eb22 100644 (file)
--- a/GroupBlock.cpp
+++ b/GroupBlock.cpp
@@ -1,6 +1,7 @@
 #include "GroupBlock.h"
 #include "BlockParameterGeneric.h"
 #include "AbstractInterface.h"
+#include "ConnectedInterface.h"
 #include "string.h"
 #include <sstream>
 
@@ -34,6 +35,10 @@ bool GroupBlock::isGroupBlock() {
   return true;
 }
 
+bool GroupBlock::isTopGroupBlock() {
+  return topGroup;
+}
+
 void GroupBlock::setParent(AbstractBlock *_parent) {
   parent = _parent;
   if (parent != NULL) {
@@ -41,8 +46,31 @@ void GroupBlock::setParent(AbstractBlock *_parent) {
   }
 }
 
+void GroupBlock::removeAllBlocks() {
+  foreach(AbstractBlock* block, blocks) {
+    if (block->isGroupBlock()) {
+      GroupBlock* group = AB_TO_GRP(block);
+      group->removeAllBlocks();
+    }
+    removeBlock(block);
+  }
+}
+
 void GroupBlock::removeBlock(AbstractBlock* block) {
-    blocks.removeAll(block);
+  /* CAUTION: no check is done if the block has connected interface
+     or not. Thus, they must be deleted elsewhere.
+  */
+  blocks.removeAll(block);
+  delete block;
+}
+
+AbstractBlock *GroupBlock::getFunctionalBlockByName(QString name) {
+  foreach(AbstractBlock* block, blocks) {
+    if (block->isFunctionalBlock()) {
+      if (block->getName() == name) return block;
+    }
+  }
+  return NULL;
 }
 
 void GroupBlock::parametersValidation(QList<AbstractBlock *> *checkedBlocks, QList<AbstractBlock *> *blocksToConfigure) {
@@ -76,3 +104,107 @@ void GroupBlock::removeGenericParameter(QString name) {
   BlockParameter* p = getParameterFromName(name);
   if (p != NULL) params.removeAll(p);
 }
+
+void GroupBlock::createInputPattern() {
+  foreach(AbstractInterface* iface, getControlInputs()) {
+    ConnectedInterface* connIface = AI_TO_CON(iface);
+    QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));    
+    connIface->setOutputPattern(pattern);    
+  }  
+}
+
+void GroupBlock::checkInputPatternCompatibility() throw(Exception){  
+}
+
+void GroupBlock::computeOutputPattern(int nbExec) throw(Exception) {
+
+  static QString fctName = "GroupBlock::computeOutputPattern()";
+#ifdef DEBUG_FCTNAME
+  cout << "call to " << qPrintable(fctName) << endl;
+#endif
+
+  cout << "computing output pattern of group " << qPrintable(name) << endl;
+  
+  bool canCompute = false;
+  bool compatible = false;
+  // get the input pattern on each inputs
+  createInputPattern();
+  
+  cout << "Input pattern OK" << endl;
+  // find blocks that are connected to that inputs and generators
+  QList<AbstractBlock*> fifo;
+  foreach(AbstractBlock* block, blocks) {
+        
+    bool addIt = false;
+    // if a block is a generator and has control outputs, add it
+    if (block->isGeneratorBlock()) {
+      if (block->getControlOutputs().size() > 0) addIt = true;
+    }
+    else {
+      // if the block has a control input connected from an intput of the group, add it too
+      foreach(AbstractInterface* iface, block->getControlInputs()) {
+        //cout << qPrintable(iface->getName()) << " of " << qPrintable(iface->getOwner()->getName()) << " connected to " << endl;       
+        ConnectedInterface* connFrom = ((ConnectedInterface*)iface)->getConnectedFrom();
+        //cout << qPrintable(connFrom->getName()) << " of " << qPrintable(connFrom->getOwner()->getName()) << endl;
+        
+        if (connFrom->getOwner() == this) {
+          addIt = true;
+          break;
+        }
+      }
+    }
+    if (addIt) {
+      cout << "adding " << qPrintable(block->getName()) << " to initialize the FIFO" << endl;
+      fifo.append(block);    
+    }
+  }
+  
+  while (!fifo.isEmpty()) {
+    AbstractBlock* block = fifo.takeFirst();
+    
+    if (block->getPatternComputed()) continue; // block has already been processed
+    
+    try {
+      block->checkInputPatternCompatibility();
+    }
+    catch(Exception e) {
+      cout << qPrintable(block->getName()) << " is not compatible with his input pattern" << endl;
+      throw(e);
+    }
+    compatible = true;
+    
+    try {
+      block->computeOutputPattern();
+    }
+    catch(Exception e) {    
+      cout << "cannot finalize output pattern computation of " << qPrintable(block->getName()) << endl;
+      throw(e);      
+    }
+    canCompute = true;
+    block->setPatternComputed(true);
+    // add other blocks connected from block to the fifo
+    foreach(AbstractInterface* iface, block->getControlOutputs()) {
+      ConnectedInterface* conn = (ConnectedInterface*)iface;
+      foreach(ConnectedInterface* connTo, conn->getConnectedTo()) {
+        /* if connTo is owned by a functional block
+           or by a group block that is within this, add the block to the fifo.
+         */
+        if (connTo->getOwner()->isFunctionalBlock()) {
+          fifo.append(connTo->getOwner());
+        }
+        else if (connTo->getOwner() != this) {
+          fifo.append(connTo->getOwner());
+        }      
+      }
+    }
+  }
+  
+  if (canCompute) {
+    foreach(AbstractInterface* iface, getControlOutputs()) {
+      ConnectedInterface* connIface = AI_TO_CON(iface);
+      QList<char>* pattern = new QList<char>(*(connIface->getConnectedFrom()->getOutputPattern()));
+      connIface->setOutputPattern(pattern);    
+    }
+    setPatternComputed(true);
+  }  
+}