* Licence details can be found in the file COPYING.
*
* \author Alfredo Braunstein
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
* \author Martin Vermeer
*
* Full author contact details are available in file CREDITS.
}
+bool BufferParams::removeBadModules()
+{
+ // we'll write a new list of modules, since we can't just remove them,
+ // as that would invalidate our iterators
+ list<string> oldModules = getModules();
+ clearLayoutModules();
+
+ list<string> const & provmods = baseClass()->providedModules();
+ list<string> const & exclmods = baseClass()->excludedModules();
+ bool consistent = true; // set to false if we have to do anything
+
+ list<string>::const_iterator oit = oldModules.begin();
+ list<string>::const_iterator const oen = oldModules.end();
+ for (; oit != oen; ++oit) {
+ string const & modname = *oit;
+ // skip modules that the class provides
+ if (find(provmods.begin(), provmods.end(), modname) != provmods.end()) {
+ LYXERR0("Module `" << modname << "' dropped because provided by document class.");
+ consistent = false;
+ continue;
+ }
+ // are we excluded by the document class?
+ if (find(exclmods.begin(), exclmods.end(), modname) != exclmods.end()) {
+ LYXERR0("Module `" << modname << "' dropped because excluded by document class.");
+ consistent = false;
+ continue;
+ }
+ // determine whether some provided module excludes us or we exclude it
+ list<string>::const_iterator pit = provmods.begin();
+ list<string>::const_iterator const pen = provmods.end();
+ bool excluded = false;
+ for (; !excluded && pit != pen; ++pit) {
+ if (!LyXModule::areCompatible(modname, *pit)) {
+ LYXERR0("Module " << modname <<
+ " dropped becuase it conflicts with provided module `" << *pit << "'.");
+ consistent = false;
+ excluded = true;
+ }
+ }
+ if (excluded)
+ continue;
+ layoutModules_.push_back(modname);
+ }
+ return consistent;
+}
+
+
void BufferParams::addDefaultModules()
{
- // add any default modules not already in use
+ // add any default modules not already in use
list<string> const & mods = baseClass()->defaultModules();
list<string>::const_iterator mit = mods.begin();
list<string>::const_iterator men = mods.end();
- // we want to add these to the front, but in the right order,
- // so we collect them here first.
- list<string> modulesToAdd;
+ // We want to insert the default modules at the beginning of
+ // the list, but also to insert them in the correct order.
+ // The obvious thing to do would be to collect them and then
+ // insert them, but that doesn't work because a later default
+ // module may require an earlier one, and then the test below
+ // moduleCanBeAdded(modname)
+ // will fail. So we have to do it a more complicated way.
+ list<string>::iterator insertpos = layoutModules_.begin();
+ int numinserts = 0;
for (; mit != men; mit++) {
string const & modName = *mit;
- // see if we're already in use
- if (find(layoutModules_.begin(), layoutModules_.end(), modName) !=
- layoutModules_.end()) {
- LYXERR(Debug::TCLASS, "Default module `" << modName <<
- "' not added because already used.");
- continue;
- }
// make sure the user hasn't removed it
if (find(removedModules_.begin(), removedModules_.end(), modName) !=
removedModules_.end()) {
continue;
}
- // Now we want to check the list of selected modules to see if any of them
- // excludes this one, or if we exclude one of them.
- LyXModule * thismod = moduleList[modName];
- if (!thismod) {
- LYXERR0("Adding default module " << modName <<
- " even though it is unavailable.");
- modulesToAdd.push_back(modName);
+ if (!moduleCanBeAdded(modName)) {
+ // FIXME This could be because it's already present, so we should
+ // probably return something indicating that.
+ LYXERR(Debug::TCLASS, "Default module `" << modName <<
+ "' could not be added.");
continue;
}
+ LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
+ layoutModules_.insert(insertpos, modName);
+ // now we reset insertpos
+ ++numinserts;
+ insertpos = layoutModules_.begin();
+ advance(insertpos, numinserts);
+ }
+}
- bool foundit = false;
- vector<string> const ourExcMods = thismod->getExcludedModules();
- vector<string>::const_iterator const eit = ourExcMods.begin();
- vector<string>::const_iterator const een = ourExcMods.end();
-
- // so iterate over the selected modules...
- LayoutModuleList::const_iterator lit = layoutModules_.begin();
- LayoutModuleList::const_iterator const len = layoutModules_.end();
- for (; lit != len; lit++) {
- LyXModule * lm = moduleList[*lit];
- if (!lm)
- continue;
- vector<string> const & exc = lm->getExcludedModules();
- // ...and see if this one excludes us.
- if (find(exc.begin(), exc.end(), modName) != exc.end()) {
- foundit = true;
- LYXERR(Debug::TCLASS, "Default module `" << modName <<
- "' not added because excluded by loaded module `" <<
- *lit << "'.");
- break;
- }
- if (find(eit, een, *lit) != een) {
- foundit = true;
- LYXERR(Debug::TCLASS, "Default module `" << modName <<
- "' not added because it excludes loaded module `" <<
- *lit << "'.");
- break;
+
+bool BufferParams::checkModuleConsistency() {
+ bool consistent = true;
+ // Perform a consistency check on the set of modules. We need to make
+ // sure that none of the modules exclude each other and that requires
+ // are satisfied.
+ list<string> oldModules = getModules();
+ clearLayoutModules();
+ list<string>::const_iterator oit = oldModules.begin();
+ list<string>::const_iterator oen = oldModules.end();
+ list<string> const & provmods = baseClass()->providedModules();
+ for (; oit != oen; ++oit) {
+ string const & modname = *oit;
+ bool excluded = false;
+ // Determine whether some prior module excludes us, or we exclude it
+ list<string>::const_iterator lit = layoutModules_.begin();
+ list<string>::const_iterator len = layoutModules_.end();
+ for (; !excluded && lit != len; ++lit) {
+ if (!LyXModule::areCompatible(modname, *lit)) {
+ consistent = false;
+ LYXERR0("Module " << modname <<
+ " dropped because it is excluded by prior module " << *lit);
+ excluded = true;
}
}
- if (!foundit) {
- LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
- modulesToAdd.push_back(modName);
+ if (excluded)
+ continue;
+
+ // determine whether some provided module or some prior module
+ // satisfies our requirements
+ LyXModule const * const oldmod = moduleList[modname];
+ if (!oldmod) {
+ LYXERR0("Default module " << modname <<
+ " added although it is unavailable and can't check requirements.");
+ continue;
+ }
+
+ vector<string> const & reqs = oldmod->getRequiredModules();
+ if (!reqs.empty()) {
+ // we now set excluded to true, meaning that we haven't
+ // yet found a required module.
+ excluded = true;
+ vector<string>::const_iterator rit = reqs.begin();
+ vector<string>::const_iterator ren = reqs.end();
+ for (; rit != ren; ++rit) {
+ string const reqmod = *rit;
+ if (find(provmods.begin(), provmods.end(), reqmod) !=
+ provmods.end()) {
+ excluded = false;
+ break;
+ }
+ if (find(layoutModules_.begin(), layoutModules_.end(), reqmod) !=
+ layoutModules_.end()) {
+ excluded = false;
+ break;
+ }
+ }
+ }
+ if (excluded) {
+ consistent = false;
+ LYXERR0("Module " << modname << " dropped because requirements not met.");
+ } else {
+ LYXERR(Debug::TCLASS, "Module " << modname << " passed consistency check.");
+ layoutModules_.push_back(modname);
}
}
-
- // OK, now we can add the default modules.
- layoutModules_.insert(
- layoutModules_.begin(), modulesToAdd.begin(), modulesToAdd.end());
+ return consistent;
}
}
pimpl_->baseClass_ = classname;
+ // the previous document class may have loaded some modules that the
+ // new one excludes, and the new class may provide, etc, some that
+ // conflict with ones that were already loaded. So we need to go
+ // through the list and fix everything. I suppose there are various
+ // ways this could be done, but the following seems to work at the
+ // moment. (Thanks to Philippe Charpentier for helping work out all
+ // the bugs---rgh.)
+ //
+ // first, we remove any modules the new document class itself provides,
+ // those it excludes, and those that conflict with ones it excludes.
+ // this has to be done first because, otherwise, a module we're about
+ // to remove could prevent a default module from being added.
+ removeBadModules();
+ // next, we add any default modules the new class provides.
addDefaultModules();
+ // finally, we perform a general consistency check on the set of
+ // loaded modules.
+ checkModuleConsistency();
+ // FIXME removeBadModules() and checkModuleConsistency() both return
+ // a boolean indicating whether something had to be changed. It might
+ // be worth popping a message to the user if so.
return true;
}
}
-bool BufferParams::addLayoutModule(string const & modName)
+bool BufferParams::moduleCanBeAdded(string const & modName) const
+{
+ // Is the module already present?
+ LayoutModuleList::const_iterator it = layoutModules_.begin();
+ LayoutModuleList::const_iterator end = layoutModules_.end();
+ for (; it != end; it++)
+ if (*it == modName)
+ return false;
+
+ LyXModule const * const lm = moduleList[modName];
+ if (!lm)
+ return true;
+
+ // Is this module explicitly excluded by the document class?
+ list<string>::const_iterator const exclmodstart =
+ baseClass()->excludedModules().begin();
+ list<string>::const_iterator const exclmodend =
+ baseClass()->excludedModules().end();
+ if (find(exclmodstart, exclmodend, modName) != exclmodend)
+ return false;
+
+ // Is this module already provided by the document class?
+ list<string>::const_iterator const provmodstart =
+ baseClass()->providedModules().begin();
+ list<string>::const_iterator const provmodend =
+ baseClass()->providedModules().end();
+ if (find(provmodstart, provmodend, modName) != provmodend)
+ return false;
+
+ // Check for conflicts with used modules
+ // first the provided modules...
+ list<string>::const_iterator provmodit = provmodstart;
+ for (; provmodit != provmodend; ++provmodit) {
+ if (!LyXModule::areCompatible(modName, *provmodit))
+ return false;
+ }
+ // and then the selected modules
+ LayoutModuleList::const_iterator mit = getModules().begin();
+ LayoutModuleList::const_iterator const men = getModules().end();
+ for (; mit != men; ++mit)
+ if (!LyXModule::areCompatible(modName, *mit))
+ return false;
+
+ // Check whether some required module is available
+ vector<string> const reqs = lm->getRequiredModules();
+ if (reqs.empty())
+ return true;
+
+ mit = getModules().begin(); // reset
+ vector<string>::const_iterator rit = reqs.begin();
+ vector<string>::const_iterator ren = reqs.end();
+ bool foundone = false;
+ for (; rit != ren; ++rit) {
+ if (find(mit, men, *rit) != men ||
+ find(provmodstart, provmodend, *rit) != provmodend) {
+ foundone = true;
+ break;
+ }
+ }
+
+ return foundone;
+}
+
+
+bool BufferParams::addLayoutModule(string const & modName)
{
LayoutModuleList::const_iterator it = layoutModules_.begin();
LayoutModuleList::const_iterator end = layoutModules_.end();