folly::LogName Class Reference

#include <LogName.h>

Classes
struct	Equals
struct	Hash

Static Public Member Functions
static std::string	canonicalize (folly::StringPiece name)
static size_t	hash (folly::StringPiece name)
static int	cmp (folly::StringPiece nameA, folly::StringPiece nameB)
static folly::StringPiece	getParent (folly::StringPiece name)

Detailed Description

The LogName class contains utility functions for processing log category names. It primarily handles canonicalization of names.

For instance, "foo.bar", "foo/bar", "foo..bar", and ".foo.bar..." all refer to the same log category.

Definition at line 29 of file LogName.h.

Member Function Documentation

std::string folly::LogName::canonicalize ( folly::StringPiece  name )

static

Return a canonicalized version of the log name.

'/' and '\' characters are converted to '.', then leading and trailing '.' characters are removed, and all sequences of consecutive '.' characters are replaced with a single '.'

Definition at line 26 of file LogName.cpp.

References folly::test::end(), folly::Range< Iter >::size(), and string.

Referenced by folly::LogCategory::LogCategory(), folly::parseLogConfigDynamic(), TEST(), and TEST_F().

                                                 {
  std::string cname;
  cname.reserve(input.size());

  // Ignore trailing category separator characters
  size_t end = input.size();
  while (end > 0 && isSeparator(input[end - 1])) {
    --end;
  }

  bool ignoreSeparator = true;
  for (size_t idx = 0; idx < end; ++idx) {
    if (isSeparator(input[idx])) {
      if (ignoreSeparator) {
        continue;
      }
      cname.push_back('.');
      ignoreSeparator = true;
    } else {
      cname.push_back(input[idx]);
      ignoreSeparator = false;
    }
  }
  return cname;
}

int folly::LogName::cmp ( folly::StringPiece  nameA, folly::StringPiece  nameB  )

static

Compare two log names.

The log name does not need to be pre-canonicalized. Returns 0 if and only if the two names refer to the same log category. Otherwise, returns -1 if the canonical version of nameA is less than the canonical version of nameB.

Definition at line 81 of file LogName.cpp.

References folly::Range< Iter >::empty(), folly::Range< Iter >::front(), s, and folly::Range< Iter >::uncheckedAdvance().

Referenced by folly::LogName::Equals::operator()(), and TEST().

                                             {
  // Ignore trailing separators
  auto stripTrailingSeparators = [](StringPiece& s) {
    while (!s.empty() && isSeparator(s.back())) {
      s.uncheckedSubtract(1);
    }
  };
  stripTrailingSeparators(a);
  stripTrailingSeparators(b);

  // Advance ptr until it no longer points to a category separator.
  // This is used to skip over consecutive sequences of separator characters.
  auto skipOverSeparators = [](StringPiece& s) {
    while (!s.empty() && isSeparator(s.front())) {
      s.uncheckedAdvance(1);
    }
  };

  bool ignoreSeparator = true;
  while (true) {
    if (ignoreSeparator) {
      skipOverSeparators(a);
      skipOverSeparators(b);
    }
    if (a.empty()) {
      return b.empty() ? 0 : -1;
    } else if (b.empty()) {
      return 1;
    }
    if (isSeparator(a.front())) {
      if (!isSeparator(b.front())) {
        return '.' - b.front();
      }
      ignoreSeparator = true;
    } else {
      if (a.front() != b.front()) {
        return a.front() - b.front();
      }
      ignoreSeparator = false;
    }
    a.uncheckedAdvance(1);
    b.uncheckedAdvance(1);
  }
}

StringPiece folly::LogName::getParent ( folly::StringPiece  name )

static

Get the name of the parent log category.

Returns a StringPiece pointing into the input data. As a result, the parent log name may not be canonical if the input log name is not already canonical.

If the input log name refers to the root log category, an empty StringPiece will be returned.

Definition at line 126 of file LogName.cpp.

References folly::Range< Iter >::begin(), folly::Range< Iter >::empty(), name, and folly::Range< Iter >::size().

Referenced by folly::LoggerDB::getOrCreateCategoryLocked(), and TEST().

                                               {
  if (name.empty()) {
    return name;
  }

  ssize_t idx = name.size();

  // Skip over any trailing separator characters
  while (idx > 0 && isSeparator(name[idx - 1])) {
    --idx;
  }

  // Now walk backwards to the next separator character
  while (idx > 0 && !isSeparator(name[idx - 1])) {
    --idx;
  }

  // And again skip over any separator characters, in case there are multiple
  // repeated characters.
  while (idx > 0 && isSeparator(name[idx - 1])) {
    --idx;
  }

  return StringPiece(name.begin(), idx);
}

size_t folly::LogName::hash ( folly::StringPiece  name )

static

Hash a log name.

The log name does not need to be pre-canonicalized. The hash for equivalent log names will always be equal.

Definition at line 52 of file LogName.cpp.

References folly::test::end(), folly::Range< Iter >::size(), uint32_t, uint8_t, and folly::value().

Referenced by folly::LogName::Hash::operator()(), and TEST().

                                     {
  // Code based on StringPiece::hash(), but which ignores leading and trailing
  // category separator characters, as well as multiple consecutive separator
  // characters, so equivalent names result in the same hash.
  uint32_t hash = 5381;

  size_t end = name.size();
  while (end > 0 && isSeparator(name[end - 1])) {
    --end;
  }

  bool ignoreSeparator = true;
  for (size_t idx = 0; idx < end; ++idx) {
    uint8_t value;
    if (isSeparator(name[idx])) {
      if (ignoreSeparator) {
        continue;
      }
      value = '.';
      ignoreSeparator = true;
    } else {
      value = static_cast<uint8_t>(name[idx]);
      ignoreSeparator = false;
    }
    hash = ((hash << 5) + hash) + value;
  }
  return hash;
}

---

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

• proxygen/folly/folly/logging/LogName.h
• proxygen/folly/folly/logging/LogName.cpp