Catalog Class Reference

#include <catalog.h>

Classes
struct	Entry
	VisibleForTesting. More...
class	Match

Public Member Functions
absl::StatusOr< std::vector< Match > >	FindMatch (std::string_view query) const
	Tries to identify a match for the query across the Catalog.

Static Public Member Functions
static absl::StatusOr< Catalog >	Open (std::string_view data_dir)
static absl::StatusOr< Catalog >	Make (const std::vector< Entry > &entries)
	Make a Catalog for testing.
static absl::StatusOr< Entry >	ParseEntry (std::istream &is)
	VisibleForTesting.

Detailed Description

A storage of licenses that can be matched against. The in memory representation of the data/headers and data/licenses directories. This represents a 2 tiered search, first the sector is used to determine what matcher should be used, then a match is performend on that. This approach was chosen to minimize the size of the RE2::Set.

Definition at line 21 of file catalog.h.

Member Function Documentation

FindMatch()

absl::StatusOr< std::vector< Catalog::Match > > Catalog::FindMatch

(

std::string_view

query

)

const

Tries to identify a match for the query across the Catalog.

Parameters

query

The text that will be matched against.

Returns

absl::StatusCode::kNotFound when a match can't be found. absl::StatusCode::kInvalidArgument if more than one match comes up from the selector.

Definition at line 183 of file catalog.cc.

                                {
  std::vector<int> selector_results;
  if (!selector_.Match(query, &selector_results)) {
    return absl::NotFoundError("Selector didn't match.");
  }
 
  std::vector<Catalog::Match> results;
  std::vector<int> missed_results;
  missed_results.reserve(selector_results.size());
  std::vector<int> hit_results;
  hit_results.reserve(selector_results.size());
  for (int selector_result : selector_results) {
    RE2* matcher = matchers_[selector_result].get();
    std::optional<Match> match =
        FindMatchForSelectedMatcher(query, matcher, names_[selector_result]);
    if (match.has_value()) {
      results.emplace_back(std::move(match.value()));
      hit_results.push_back(selector_result);
    } else {
      missed_results.push_back(selector_result);
    }
  }
  if (selector_results.size() != results.size()) {
    std::stringstream missed;
    for (size_t i = 0; i < missed_results.size(); ++i) {
      if (i != 0) {
        missed << ", ";
      }
      missed << names_[missed_results[i]];
    }
    std::stringstream hit;
    hit << " Hit matcher(s): (";
    for (size_t i = 0; i < hit_results.size(); ++i) {
      if (i != 0) {
        hit << ", ";
      }
      hit << names_[hit_results[i]];
    }
    hit << ")";
    return absl::NotFoundError(
        absl::StrCat("Selected matcher(s) (", missed.str(), ") didn't match.",
                     hit_results.empty() ? "" : hit.str()));
  } else {
    for (size_t i = 0; i < results.size(); ++i) {
      for (size_t j = i + 1; j < results.size(); ++j) {
        if (Overlaps(results[i].GetMatchedText(),
                     results[j].GetMatchedText())) {
          return absl::InvalidArgumentError(absl::StrCat(
              "Selected matchers overlap (", results[i].GetMatcher(), ", ",
              results[j].GetMatcher(), ").\n", results[i].GetMatchedText(),
              "\n############\n", results[j].GetMatchedText()));
        }
      }
    }
 
    return results;
  }
}

References i.

Make()

absl::StatusOr< Catalog > Catalog::Make ( const std::vector< Entry > &  entries )

static

Make a Catalog for testing.

Definition at line 151 of file catalog.cc.

                                                                   {
  RE2::Set selector(RE2::Options(), RE2::Anchor::UNANCHORED);
  std::vector<std::unique_ptr<RE2>> matchers;
  std::vector<std::string> names;
 
  for (const Entry& entry : entries) {
    std::string err;
    names.push_back(std::string(entry.name));
    int idx = selector.Add(entry.unique, &err);
    if (idx < 0) {
      return absl::InvalidArgumentError(
          absl::StrCat("Unable to add set entry: ", entry.unique, " ", err));
    }
    matchers.push_back(std::make_unique<RE2>(entry.matcher));
  }
 
  bool did_compile = selector.Compile();
  if (!did_compile) {
    return absl::OutOfRangeError("RE2::Set ran out of memory.");
  }
  return Catalog(std::move(selector), std::move(matchers), std::move(names));
}

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

Open()

absl::StatusOr< Catalog > Catalog::Open ( std::string_view  data_dir )

static

Definition at line 98 of file catalog.cc.

                                                           {
  fs::path data_dir_path(data_dir);
  if (!fs::exists(data_dir_path)) {
    return absl::InvalidArgumentError(
        absl::StrCat("Data directory doesn't exist ", data_dir));
  }
  fs::path licenses_path = data_dir_path / "licenses";
  if (!fs::exists(licenses_path)) {
    return absl::InvalidArgumentError(absl::StrCat(
        "Licenses directory doesn't exist ", licenses_path.string()));
  }
 
  RE2::Set selector(RE2::Options(), RE2::Anchor::UNANCHORED);
  std::vector<std::unique_ptr<RE2>> matchers;
  std::vector<std::string> names;
 
  for (const fs::path& file : fs::directory_iterator(licenses_path)) {
    std::ifstream infile(file.string());
    if (!infile.good()) {
      return absl::InvalidArgumentError("Unable to open file " + file.string());
    }
 
    absl::StatusOr<Entry> entry = ParseEntry(infile);
    if (!entry.ok()) {
      return absl::InvalidArgumentError(
          absl::StrCat("Unable to parse data entry at ", file.string(), " : ",
                       entry.status()));
    }
 
    std::string err;
    selector.Add(entry->unique, &err);
    if (!err.empty()) {
      return absl::InvalidArgumentError(absl::StrCat(
          "Unable to add unique key from ", file.string(), " : ", err));
    }
    names.emplace_back(std::move(entry->name));
 
    auto matcher_re2 = std::make_unique<RE2>(entry->matcher);
    if (!matcher_re2) {
      return absl::InvalidArgumentError("Unable to make matcher.");
    }
 
    matchers.emplace_back(std::move(matcher_re2));
  }
 
  bool did_compile = selector.Compile();
  if (!did_compile) {
    return absl::UnknownError("Unable to compile selector.");
  }
 
  return Catalog(std::move(selector), std::move(matchers), std::move(names));
}

References ParseEntry().

Referenced by Data::Open().

ParseEntry()

absl::StatusOr< Catalog::Entry > Catalog::ParseEntry ( std::istream &  is )

static

VisibleForTesting.

Definition at line 243 of file catalog.cc.

                                                             {
  if (!is.good()) {
    return absl::InvalidArgumentError("Bad stream.");
  }
  std::string name;
  std::getline(is, name);
  if (is.eof()) {
    return absl::InvalidArgumentError("Bad stream.");
  }
  std::string unique;
  std::getline(is, unique);
  if (is.eof()) {
    return absl::InvalidArgumentError("Bad stream.");
  }
 
  std::string matcher_text((std::istreambuf_iterator<char>(is)),
                           std::istreambuf_iterator<char>());
 
  std::string ignore_whitespace_matcher = IgnoreWhitespace(matcher_text);
 
  VLOG(4) << "matcher:" << name << ":\n" << ignore_whitespace_matcher;
 
  return Catalog::Entry{.name = std::move(name),
                        .unique = std::move(unique),
                        .matcher = std::move(ignore_whitespace_matcher)};
}

References name, and Catalog::Entry::name.

Referenced by Open(), and TEST().

---

The documentation for this class was generated from the following files:

• tools/licenses_cpp/src/catalog.h
• tools/licenses_cpp/src/catalog.cc