Source/cmSourceGroup.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#include "cmSourceGroup.h"

#include <utility>

#include <cm/memory>

#include "cmGeneratorExpression.h"
#include "cmList.h"
#include "cmStringAlgorithms.h"

class cmSourceGroupInternals
{
public:
  SourceGroupVector GroupChildren;
};

cmSourceGroup::cmSourceGroup(std::string name, cm::string_view regex,
                             cm::string_view parentName)
  : Name(std::move(name))
{
  this->Internal = cm::make_unique<cmSourceGroupInternals>();
  this->SetGroupRegex(regex);
  if (parentName.empty()) {
    this->FullName = this->Name;
  } else {
    this->FullName = cmStrCat(parentName, '\\', this->Name);
  }
}

cmSourceGroup::~cmSourceGroup() = default;

bool cmSourceGroup::SetGroupRegex(cm::string_view regex)
{
  if (regex.data()) {
    return this->GroupRegex.compile(static_cast<std::string>(regex));
  }
  return this->GroupRegex.compile("^$");
}

void cmSourceGroup::ResolveGenex(cmLocalGenerator* lg,
                                 std::string const& config)
{
  std::set<std::string> files;

  for (auto& pair : this->GroupFileSets) {
    files.clear();
    for (std::string const& fileSet : pair.second) {
      cmList list{ cmGeneratorExpression::Evaluate(fileSet, lg, config) };
      files.insert(list.begin(), list.end());
    }
    pair.second = std::move(files);
  }

  files.clear();
  for (std::string const& file : this->GroupFiles) {
    cmList list{ cmGeneratorExpression::Evaluate(file, lg, config) };
    files.insert(list.begin(), list.end());
  }
  this->GroupFiles = std::move(files);

  if (!this->Internal) {
    return;
  }

  for (auto const& group : this->Internal->GroupChildren) {
    group->ResolveGenex(lg, config);
  }
}

void cmSourceGroup::AddGroupFile(std::string const& name)
{
  this->GroupFiles.insert(name);
}

void cmSourceGroup::AddGroupFileSets(std::string const& target,
                                     std::set<std::string> const& fileSets)
{
  auto& fs = this->GroupFileSets[target];
  fs.insert(fileSets.begin(), fileSets.end());
}

std::string const& cmSourceGroup::GetName() const
{
  return this->Name;
}

std::string const& cmSourceGroup::GetFullName() const
{
  return this->FullName;
}

bool cmSourceGroup::MatchesRegex(std::string const& name) const
{
  cmsys::RegularExpressionMatch match;
  return this->GroupRegex.find(name.c_str(), match);
}

bool cmSourceGroup::MatchesFiles(std::string const& name) const
{
  return this->GroupFiles.find(name) != this->GroupFiles.cend();
}

std::set<std::string> const& cmSourceGroup::GetGroupFiles() const
{
  return this->GroupFiles;
}
std::map<std::string, std::set<std::string>> const&
cmSourceGroup::GetGroupFileSets() const
{
  return this->GroupFileSets;
}

void cmSourceGroup::AddChild(std::unique_ptr<cmSourceGroup> child)
{
  this->Internal->GroupChildren.push_back(std::move(child));
}

cmSourceGroup* cmSourceGroup::LookupChild(std::string const& name) const
{
  for (auto& group : this->Internal->GroupChildren) {
    // look if descendant is the one we're looking for
    if (group->GetName() == name) {
      return group.get(); // if so return it
    }
  }

  // if no child with this name was found return NULL
  return nullptr;
}

cmSourceGroup* cmSourceGroup::MatchChildrenFiles(std::string const& name)
{
  if (this->MatchesFiles(name)) {
    return this;
  }
  for (auto& group : this->Internal->GroupChildren) {
    cmSourceGroup* result = group->MatchChildrenFiles(name);
    if (result) {
      return result;
    }
  }
  return nullptr;
}

cmSourceGroup const* cmSourceGroup::MatchChildrenFiles(
  std::string const& name) const
{
  if (this->MatchesFiles(name)) {
    return this;
  }
  for (auto const& group : this->Internal->GroupChildren) {
    cmSourceGroup const* result = group->MatchChildrenFiles(name);
    if (result) {
      return result;
    }
  }
  return nullptr;
}

cmSourceGroup* cmSourceGroup::MatchChildrenRegex(std::string const& name) const
{
  for (auto& group : this->Internal->GroupChildren) {
    cmSourceGroup* result = group->MatchChildrenRegex(name);
    if (result) {
      return result;
    }
  }
  if (this->MatchesRegex(name)) {
    return const_cast<cmSourceGroup*>(this);
  }

  return nullptr;
}

cmSourceGroup* cmSourceGroup::MatchChildrenFileSets(std::string const& target,
                                                    std::string const& fileSet)
{
  auto item = this->GroupFileSets.find(target);
  if (item != this->GroupFileSets.end() &&
      item->second.find(fileSet) != item->second.end()) {
    return this;
  }
  for (auto const& group : this->Internal->GroupChildren) {
    if (cmSourceGroup* result =
          group->MatchChildrenFileSets(target, fileSet)) {
      return result;
    }
  }
  return nullptr;
}

SourceGroupVector const& cmSourceGroup::GetGroupChildren() const
{
  return this->Internal->GroupChildren;
}

/**
 * Find a source group whose regular expression matches the filename
 * part of the given source name.  Search backward through the list of
 * source groups, and take the first matching group found.  This way
 * non-inherited source_group() commands will have precedence over
 * inherited ones.
 */
cmSourceGroup* cmSourceGroup::FindSourceGroup(std::string const& source,
                                              SourceGroupVector const& groups)
{
  // First search for a group that lists the file explicitly.
  for (auto sg = groups.rbegin(); sg != groups.rend(); ++sg) {
    cmSourceGroup* result = (*sg)->MatchChildrenFiles(source);
    if (result) {
      return result;
    }
  }

  // Now search for a group whose regex matches the file.
  for (auto sg = groups.rbegin(); sg != groups.rend(); ++sg) {
    cmSourceGroup* result = (*sg)->MatchChildrenRegex(source);
    if (result) {
      return result;
    }
  }

  // Shouldn't get here, but just in case, return the default group.
  return groups.data()->get();
}

/**
 * Find a source group whose matches the target and file set.
 * Search backward through the list of source groups, and take the first
 * matching group found.  This way non-inherited source_group() commands will
 * have precedence over inherited ones.
 */
cmSourceGroup* cmSourceGroup::FindSourceGroup(std::string const& target,
                                              std::string const& fileSet,
                                              SourceGroupVector const& groups)
{
  // First search for a group that lists the file set explicitly.
  for (auto sg = groups.rbegin(); sg != groups.rend(); ++sg) {
    if (cmSourceGroup* result =
          (*sg)->MatchChildrenFileSets(target, fileSet)) {
      return result;
    }
  }

  return nullptr;
}

void cmSourceGroupFiles::Add(cmSourceGroup const* sg, cmSourceFile const* sf)
{
  this->SourceFiles[sg].push_back(sf);
}

std::vector<cmSourceFile const*> const& cmSourceGroupFiles::GetSourceFiles(
  cmSourceGroup const* sg) const
{
  auto i = this->SourceFiles.find(sg);
  if (i != this->SourceFiles.end()) {
    return i->second;
  }
  static std::vector<cmSourceFile const*> const empty;
  return empty;
}