comparison trunk/src/Support/Module.cc @ 401:b71ec2cbe55b

- Module tree

 };
 
 Module::~Module() {
 };
 
-bool Module::Initialize(const SignalBank &input) {
-  // LOG_INFO_NN(_T("-> %s "), module_identifier_.c_str());
+bool Module::Initialize(const SignalBank &input,
+                        Parameters *global_parameters) {
+  global_parameters_ = global_parameters;
   // Validate the input
   if (!input.Validate()) {
     LOG_ERROR(_T("Input SignalBank not valid"));
     return false;
   }

     LOG_ERROR(_T("Initialization failed in module %s"),
               module_identifier_.c_str());
     return false;
   }
   // If the module has an output bank, then we can set up the targets
-  // of this module..
+  // of this module.
   if (output_.initialized()) {
     // Check that the output SignalBank has been set up correctly
     if (!output_.Validate()) {
       LOG_ERROR(_T("Output SignalBank not valid in module %s"),
                 module_identifier_.c_str());

     // set up to accept an input SignalBank of the correct form, but
     // this is not checked.
     set<Module*>::const_iterator it;
     for (it = targets_.begin(); it != targets_.end(); ++it) {
       if (!(*it)->initialized())
-        if (!(*it)->Initialize(output_))
+        if (!(*it)->Initialize(output_, global_parameters_))
           return false;
     }
-  } else {
-    // LOG_INFO(_T("|"));
   }
   initialized_ = true;
   return true;
 }
 

 bool Module::initialized() const {
   return initialized_;
 }
 
 bool Module::AddTarget(Module* target_module) {
+  bool result = false;
   if (target_module) {
     pair<set<Module*>::iterator, bool> ret;
     ret = targets_.insert(target_module);
-    return ret.second;
+    result = ret.second;
+    if (result) {
+      if(initialized_) {
+        if(output_.initialized()) {
+          if (!target_module->initialized()) {
+            target_module->Initialize(output_, global_parameters_);
+          }
+        }
+      }
+    }
   }
-  return false;
+  return result;
 }
 
 bool Module::RemoveTarget(Module* target_module) {
   if (targets_.erase(target_module) != 0)
     return true;