size_t component::getGeneratedSize(const generationContext& ctx)
{
std::vector <shared_ptr <component> > children = getChildComponents();
size_t totalSize = 0;
for (std::vector <shared_ptr <component> >::iterator it = children.begin() ; it != children.end() ; ++it)
totalSize += (*it)->getGeneratedSize(ctx);
return totalSize;
}
utility::stream::size_type component::getGeneratedSize(const generationContext& ctx)
{
std::vector <ref <component> > children = getChildComponents();
utility::stream::size_type totalSize = 0;
for (std::vector <ref <component> >::iterator it = children.begin() ; it != children.end() ; ++it)
totalSize += (*it)->getGeneratedSize(ctx);
return totalSize;
}
void component::offsetParsedBounds(size_t offset)
{
// Offset parsed bounds of this component
if (m_parsedLength != 0)
m_parsedOffset += offset;
// Offset parsed bounds of our children
std::vector <shared_ptr <component> > children = getChildComponents();
for (size_t i = 0, n = children.size() ; i < n ; ++i)
children[i]->offsetParsedBounds(offset);
}
void component::offsetParsedBounds(const utility::stream::size_type offset)
{
// Offset parsed bounds of this component
if (m_parsedLength != 0)
m_parsedOffset += offset;
// Offset parsed bounds of our children
std::vector <ref <component> > children = getChildComponents();
for (size_t i = 0, n = children.size() ; i < n ; ++i)
children[i]->offsetParsedBounds(offset);
}
DependenciesSolvingResult ComponentDependencies::completeListWithParents(const QList<IComponent *> &forParents) const
{
if (forParents.empty())
return DependenciesSolvingResult();
DependencySolver solver;
QList<IComponent *> completeList;
QList<IComponent *> unresolvedList(forParents);
// TODO: refactoring is needed.
// Find all children for parents and reverse parent-children dependencies for correct ordering:
while (!unresolvedList.isEmpty()) {
IComponent *parent = unresolvedList[0];
solver.addComponent(parent->name());
DependenciesSolvingResult result = getChildComponents(parent);
for (IComponent * child : result.ordered()) {
if (!completeList.contains(child) && !unresolvedList.contains(child))
unresolvedList.push_back(child);
// We look all children for parents, so switch their dependencies:
solver.addComponent(child->name());
solver.addDependency(parent->name(), child->name());
}
unresolvedList.removeFirst();
completeList.push_back(parent);
}
QStringList ordered;
QStringList orphans;
QStringList missing;
bool hasCyclic = !solver.solve(ordered, orphans, missing);
if (hasCyclic) {
Log.d("At least one cyclic dependency has been found in the component manager. Cycles in the component dependencies must be avoided.");
return DependenciesSolvingResult(ordered, orphans, missing, m_components->toList(), hasCyclic);
}
if (!missing.isEmpty()) {
Log.d(QString("A component declared a dependency on another component which is not declared to be loaded. Missing component(s): %1")
.arg(missing.join(", ")).toLatin1());
}
return DependenciesSolvingResult(ordered, orphans, missing, m_components->toList(), hasCyclic);
}
