{
public:
virtual void
- ModuleAdded (const lldb::ModuleSP& module_sp) = 0;
+ ModuleAdded (const ModuleList& module_list, const lldb::ModuleSP& module_sp) = 0;
virtual void
- ModuleRemoved (const lldb::ModuleSP& module_sp) = 0;
+ ModuleRemoved (const ModuleList& module_list, const lldb::ModuleSP& module_sp) = 0;
virtual void
- ModuleUpdated (const lldb::ModuleSP& old_module_sp,
+ ModuleUpdated (const ModuleList& module_list, const lldb::ModuleSP& old_module_sp,
const lldb::ModuleSP& new_module_sp) = 0;
virtual void
- WillClearList () = 0;
+ WillClearList (const ModuleList& module_list) = 0;
virtual
~Notifier ()
//------------------------------------------------------------------
virtual void
- ModuleAdded (const lldb::ModuleSP& module_sp);
+ ModuleAdded (const ModuleList& module_list, const lldb::ModuleSP& module_sp);
virtual void
- ModuleRemoved (const lldb::ModuleSP& module_sp);
+ ModuleRemoved (const ModuleList& module_list, const lldb::ModuleSP& module_sp);
virtual void
- ModuleUpdated (const lldb::ModuleSP& old_module_sp,
+ ModuleUpdated (const ModuleList& module_list,
+ const lldb::ModuleSP& old_module_sp,
const lldb::ModuleSP& new_module_sp);
virtual void
- WillClearList ();
+ WillClearList (const ModuleList& module_list);
public:
Mutex::Locker lhs_locker(m_modules_mutex);
Mutex::Locker rhs_locker(rhs.m_modules_mutex);
m_modules = rhs.m_modules;
- m_notifier = rhs.m_notifier;
}
ModuleList::ModuleList (ModuleList::Notifier* notifier) :
Mutex::Locker lhs_locker(m_modules_mutex);
Mutex::Locker rhs_locker(rhs.m_modules_mutex);
m_modules = rhs.m_modules;
- m_notifier = rhs.m_notifier;
}
return *this;
}
Mutex::Locker locker(m_modules_mutex);
m_modules.push_back(module_sp);
if (use_notifier && m_notifier)
- m_notifier->ModuleAdded(module_sp);
+ m_notifier->ModuleAdded(*this, module_sp);
}
}
{
m_modules.erase (pos);
if (use_notifier && m_notifier)
- m_notifier->ModuleRemoved(module_sp);
+ m_notifier->ModuleRemoved(*this, module_sp);
return true;
}
}
ModuleSP module_sp(*pos);
collection::iterator retval = m_modules.erase(pos);
if (use_notifier && m_notifier)
- m_notifier->ModuleRemoved(module_sp);
+ m_notifier->ModuleRemoved(*this, module_sp);
return retval;
}
return false;
AppendImpl (new_module_sp, false);
if (m_notifier)
- m_notifier->ModuleUpdated(old_module_sp,new_module_sp);
+ m_notifier->ModuleUpdated(*this, old_module_sp,new_module_sp);
return true;
}
{
Mutex::Locker locker(m_modules_mutex);
if (use_notifier && m_notifier)
- m_notifier->WillClearList();
+ m_notifier->WillClearList(*this);
m_modules.clear();
}
}
void
-Target::WillClearList ()
+Target::WillClearList (const ModuleList& module_list)
{
}
void
-Target::ModuleAdded (const ModuleSP &module_sp)
+Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp)
{
// A module is being added to this target for the first time
- ModuleList module_list;
- module_list.Append(module_sp);
+ ModuleList my_module_list;
+ my_module_list.Append(module_sp);
LoadScriptingResourceForModule(module_sp, this);
- ModulesDidLoad (module_list);
+ ModulesDidLoad (my_module_list);
}
void
-Target::ModuleRemoved (const ModuleSP &module_sp)
+Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp)
{
// A module is being added to this target for the first time
- ModuleList module_list;
- module_list.Append(module_sp);
- ModulesDidUnload (module_list);
+ ModuleList my_module_list;
+ my_module_list.Append(module_sp);
+ ModulesDidUnload (my_module_list);
}
void
-Target::ModuleUpdated (const ModuleSP &old_module_sp, const ModuleSP &new_module_sp)
+Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp)
{
// A module is replacing an already added module
m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);