android-12.0.0_r34/s

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "annotator/types.h"

#include <vector>

#include "utils/optional.h"

namespace libtextclassifier3 {

const CodepointSpan CodepointSpan::kInvalid =
    CodepointSpan(kInvalidIndex, kInvalidIndex);

const TokenSpan TokenSpan::kInvalid = TokenSpan(kInvalidIndex, kInvalidIndex);

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const CodepointSpan& span) {
  return stream << "CodepointSpan(" << span.first << ", " << span.second << ")";
}

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const TokenSpan& span) {
  return stream << "TokenSpan(" << span.first << ", " << span.second << ")";
}

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const Token& token) {
  if (!token.is_padding) {
    return stream << "Token(\"" << token.value << "\", " << token.start << ", "
                  << token.end << ")";
  } else {
    return stream << "Token()";
  }
}

bool DatetimeComponent::ShouldRoundToGranularity() const {
  // Don't round to the granularity for relative expressions that specify the
  // distance. So that, e.g. "in 2 hours" when it's 8:35:03 will result in
  // 10:35:03.
  if (relative_qualifier == RelativeQualifier::UNSPECIFIED) {
    return false;
  }
  if (relative_qualifier == RelativeQualifier::NEXT ||
      relative_qualifier == RelativeQualifier::TOMORROW ||
      relative_qualifier == RelativeQualifier::YESTERDAY ||
      relative_qualifier == RelativeQualifier::LAST ||
      relative_qualifier == RelativeQualifier::THIS ||
      relative_qualifier == RelativeQualifier::NOW) {
    return true;
  }
  return false;
}

namespace {
std::string FormatMillis(int64 time_ms_utc) {
  long time_seconds = time_ms_utc / 1000;  // NOLINT
  char buffer[512];
  strftime(buffer, sizeof(buffer), "%a %Y-%m-%d %H:%M:%S %Z",
           localtime(&time_seconds));
  return std::string(buffer);
}
}  // namespace

std::string ComponentTypeToString(
    const DatetimeComponent::ComponentType& component_type) {
  switch (component_type) {
    case DatetimeComponent::ComponentType::UNSPECIFIED:
      return "UNSPECIFIED";
    case DatetimeComponent::ComponentType::YEAR:
      return "YEAR";
    case DatetimeComponent::ComponentType::MONTH:
      return "MONTH";
    case DatetimeComponent::ComponentType::WEEK:
      return "WEEK";
    case DatetimeComponent::ComponentType::DAY_OF_WEEK:
      return "DAY_OF_WEEK";
    case DatetimeComponent::ComponentType::DAY_OF_MONTH:
      return "DAY_OF_MONTH";
    case DatetimeComponent::ComponentType::HOUR:
      return "HOUR";
    case DatetimeComponent::ComponentType::MINUTE:
      return "MINUTE";
    case DatetimeComponent::ComponentType::SECOND:
      return "SECOND";
    case DatetimeComponent::ComponentType::MERIDIEM:
      return "MERIDIEM";
    case DatetimeComponent::ComponentType::ZONE_OFFSET:
      return "ZONE_OFFSET";
    case DatetimeComponent::ComponentType::DST_OFFSET:
      return "DST_OFFSET";
    default:
      return "";
  }
}

std::string RelativeQualifierToString(
    const DatetimeComponent::RelativeQualifier& relative_qualifier) {
  switch (relative_qualifier) {
    case DatetimeComponent::RelativeQualifier::UNSPECIFIED:
      return "UNSPECIFIED";
    case DatetimeComponent::RelativeQualifier::NEXT:
      return "NEXT";
    case DatetimeComponent::RelativeQualifier::THIS:
      return "THIS";
    case DatetimeComponent::RelativeQualifier::LAST:
      return "LAST";
    case DatetimeComponent::RelativeQualifier::NOW:
      return "NOW";
    case DatetimeComponent::RelativeQualifier::TOMORROW:
      return "TOMORROW";
    case DatetimeComponent::RelativeQualifier::YESTERDAY:
      return "YESTERDAY";
    case DatetimeComponent::RelativeQualifier::PAST:
      return "PAST";
    case DatetimeComponent::RelativeQualifier::FUTURE:
      return "FUTURE";
    default:
      return "";
  }
}

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const DatetimeParseResultSpan& value) {
  stream << "DatetimeParseResultSpan({" << value.span.first << ", "
         << value.span.second << "}, "
         << "/*target_classification_score=*/ "
         << value.target_classification_score << "/*priority_score=*/"
         << value.priority_score << " {";
  for (const DatetimeParseResult& data : value.data) {
    stream << "{/*time_ms_utc=*/ " << data.time_ms_utc << " /* "
           << FormatMillis(data.time_ms_utc) << " */, /*granularity=*/ "
           << data.granularity << ", /*datetime_components=*/ ";
    for (const DatetimeComponent& datetime_comp : data.datetime_components) {
      stream << "{/*component_type=*/ "
             << ComponentTypeToString(datetime_comp.component_type)
             << " /*relative_qualifier=*/ "
             << RelativeQualifierToString(datetime_comp.relative_qualifier)
             << " /*value=*/ " << datetime_comp.value << " /*relative_count=*/ "
             << datetime_comp.relative_count << "}, ";
    }
    stream << "}, ";
  }
  stream << "})";
  return stream;
}

bool ClassificationResult::operator==(const ClassificationResult& other) const {
  return ClassificationResultsEqualIgnoringScoresAndSerializedEntityData(
             *this, other) &&
         fabs(score - other.score) < 0.001 &&
         fabs(priority_score - other.priority_score) < 0.001 &&
         serialized_entity_data == other.serialized_entity_data;
}

bool ClassificationResultsEqualIgnoringScoresAndSerializedEntityData(
    const ClassificationResult& a, const ClassificationResult& b) {
  return a.collection == b.collection &&
         a.datetime_parse_result == b.datetime_parse_result &&
         a.serialized_knowledge_result == b.serialized_knowledge_result &&
         a.contact_pointer == b.contact_pointer &&
         a.contact_name == b.contact_name &&
         a.contact_given_name == b.contact_given_name &&
         a.contact_family_name == b.contact_family_name &&
         a.contact_nickname == b.contact_nickname &&
         a.contact_email_address == b.contact_email_address &&
         a.contact_phone_number == b.contact_phone_number &&
         a.contact_id == b.contact_id &&
         a.app_package_name == b.app_package_name &&
         a.numeric_value == b.numeric_value &&
         fabs(a.numeric_double_value - b.numeric_double_value) < 0.001 &&
         a.duration_ms == b.duration_ms;
}

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const ClassificationResult& result) {
  return stream << "ClassificationResult(" << result.collection
                << ", /*score=*/ " << result.score << ", /*priority_score=*/ "
                << result.priority_score << ")";
}

logging::LoggingStringStream& operator<<(
    logging::LoggingStringStream& stream,
    const std::vector<ClassificationResult>& results) {
  stream = stream << "{\n";
  for (const ClassificationResult& result : results) {
    stream = stream << "    " << result << "\n";
  }
  stream = stream << "}";
  return stream;
}

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const AnnotatedSpan& span) {
  std::string best_class;
  float best_score = -1;
  if (!span.classification.empty()) {
    best_class = span.classification[0].collection;
    best_score = span.classification[0].score;
  }
  return stream << "Span(" << span.span.first << ", " << span.span.second
                << ", " << best_class << ", " << best_score << ")";
}

logging::LoggingStringStream& operator<<(logging::LoggingStringStream& stream,
                                         const DatetimeParsedData& data) {
  std::vector<DatetimeComponent> date_time_components;
  data.GetDatetimeComponents(&date_time_components);
  stream = stream << "DatetimeParsedData { \n";
  for (const DatetimeComponent& c : date_time_components) {
    stream = stream << " DatetimeComponent { \n";
    stream = stream << "  Component Type:" << static_cast<int>(c.component_type)
                    << "\n";
    stream = stream << "  Value:" << c.value << "\n";
    stream = stream << "  Relative Qualifier:"
                    << static_cast<int>(c.relative_qualifier) << "\n";
    stream = stream << "  Relative Count:" << c.relative_count << "\n";
    stream = stream << " } \n";
  }
  stream = stream << "}";
  return stream;
}

void DatetimeParsedData::SetAbsoluteValue(
    const DatetimeComponent::ComponentType& field_type, int value) {
  GetOrCreateDatetimeComponent(field_type).value = value;
}

void DatetimeParsedData::SetRelativeValue(
    const DatetimeComponent::ComponentType& field_type,
    const DatetimeComponent::RelativeQualifier& relative_value) {
  GetOrCreateDatetimeComponent(field_type).relative_qualifier = relative_value;
}

void DatetimeParsedData::SetRelativeCount(
    const DatetimeComponent::ComponentType& field_type, int relative_count) {
  GetOrCreateDatetimeComponent(field_type).relative_count = relative_count;
}

void DatetimeParsedData::AddDatetimeComponents(
    const std::vector<DatetimeComponent>& datetime_components) {
  for (const DatetimeComponent& datetime_component : datetime_components) {
    date_time_components_.insert(
        {datetime_component.component_type, datetime_component});
  }
}

bool DatetimeParsedData::HasFieldType(
    const DatetimeComponent::ComponentType& field_type) const {
  if (date_time_components_.find(field_type) == date_time_components_.end()) {
    return false;
  }
  return true;
}

bool DatetimeParsedData::GetFieldValue(
    const DatetimeComponent::ComponentType& field_type,
    int* field_value) const {
  if (HasFieldType(field_type)) {
    *field_value = date_time_components_.at(field_type).value;
    return true;
  }
  return false;
}

bool DatetimeParsedData::GetRelativeValue(
    const DatetimeComponent::ComponentType& field_type,
    DatetimeComponent::RelativeQualifier* relative_value) const {
  if (HasFieldType(field_type)) {
    *relative_value = date_time_components_.at(field_type).relative_qualifier;
    return true;
  }
  return false;
}

bool DatetimeParsedData::HasRelativeValue(
    const DatetimeComponent::ComponentType& field_type) const {
  if (HasFieldType(field_type)) {
    return date_time_components_.at(field_type).relative_qualifier !=
           DatetimeComponent::RelativeQualifier::UNSPECIFIED;
  }
  return false;
}

bool DatetimeParsedData::HasAbsoluteValue(
    const DatetimeComponent::ComponentType& field_type) const {
  return HasFieldType(field_type) && !HasRelativeValue(field_type);
}

bool DatetimeParsedData::IsEmpty() const {
  return date_time_components_.empty();
}

void DatetimeParsedData::GetRelativeDatetimeComponents(
    std::vector<DatetimeComponent>* date_time_components) const {
  for (auto it = date_time_components_.begin();
       it != date_time_components_.end(); it++) {
    if (it->second.relative_qualifier !=
        DatetimeComponent::RelativeQualifier::UNSPECIFIED) {
      date_time_components->push_back(it->second);
    }
  }
}

void DatetimeParsedData::GetDatetimeComponents(
    std::vector<DatetimeComponent>* date_time_components) const {
  for (auto it = date_time_components_.begin();
       it != date_time_components_.end(); it++) {
    date_time_components->push_back(it->second);
  }
}

DatetimeComponent& DatetimeParsedData::GetOrCreateDatetimeComponent(
    const DatetimeComponent::ComponentType& component_type) {
  auto result =
      date_time_components_
          .insert(
              {component_type,
               DatetimeComponent(
                   component_type,
                   DatetimeComponent::RelativeQualifier::UNSPECIFIED, 0, 0)})
          .first;
  return result->second;
}

namespace {
DatetimeGranularity GetFinestGranularityFromComponentTypes(
    const std::vector<DatetimeComponent::ComponentType>&
        datetime_component_types) {
  DatetimeGranularity granularity = DatetimeGranularity::GRANULARITY_UNKNOWN;
  for (const auto& component_type : datetime_component_types) {
    switch (component_type) {
      case DatetimeComponent::ComponentType::YEAR:
        if (granularity < DatetimeGranularity::GRANULARITY_YEAR) {
          granularity = DatetimeGranularity::GRANULARITY_YEAR;
        }
        break;

      case DatetimeComponent::ComponentType::MONTH:
        if (granularity < DatetimeGranularity::GRANULARITY_MONTH) {
          granularity = DatetimeGranularity::GRANULARITY_MONTH;
        }
        break;

      case DatetimeComponent::ComponentType::WEEK:
        if (granularity < DatetimeGranularity::GRANULARITY_WEEK) {
          granularity = DatetimeGranularity::GRANULARITY_WEEK;
        }
        break;

      case DatetimeComponent::ComponentType::DAY_OF_WEEK:
      case DatetimeComponent::ComponentType::DAY_OF_MONTH:
        if (granularity < DatetimeGranularity::GRANULARITY_DAY) {
          granularity = DatetimeGranularity::GRANULARITY_DAY;
        }
        break;

      case DatetimeComponent::ComponentType::HOUR:
        if (granularity < DatetimeGranularity::GRANULARITY_HOUR) {
          granularity = DatetimeGranularity::GRANULARITY_HOUR;
        }
        break;

      case DatetimeComponent::ComponentType::MINUTE:
        if (granularity < DatetimeGranularity::GRANULARITY_MINUTE) {
          granularity = DatetimeGranularity::GRANULARITY_MINUTE;
        }
        break;

      case DatetimeComponent::ComponentType::SECOND:
        if (granularity < DatetimeGranularity::GRANULARITY_SECOND) {
          granularity = DatetimeGranularity::GRANULARITY_SECOND;
        }
        break;

      case DatetimeComponent::ComponentType::MERIDIEM:
      case DatetimeComponent::ComponentType::ZONE_OFFSET:
      case DatetimeComponent::ComponentType::DST_OFFSET:
      default:
        break;
    }
  }
  return granularity;
}
}  // namespace

DatetimeGranularity DatetimeParsedData::GetFinestGranularity() const {
  std::vector<DatetimeComponent::ComponentType> component_types;
  std::transform(date_time_components_.begin(), date_time_components_.end(),
                 std::back_inserter(component_types),
                 [](const std::map<DatetimeComponent::ComponentType,
                                   DatetimeComponent>::value_type& pair) {
                   return pair.first;
                 });
  return GetFinestGranularityFromComponentTypes(component_types);
}

Optional<DatetimeComponent> GetDatetimeComponent(
    const std::vector<DatetimeComponent>& datetime_components,
    const DatetimeComponent::ComponentType& component_type) {
  for (auto datetime_component : datetime_components) {
    if (datetime_component.component_type == component_type) {
      return Optional<DatetimeComponent>(datetime_component);
    }
  }
  return Optional<DatetimeComponent>();
}

// Returns the granularity of the DatetimeComponents.
DatetimeGranularity GetFinestGranularity(
    const std::vector<DatetimeComponent>& datetime_component) {
  std::vector<DatetimeComponent::ComponentType> component_types;
  std::transform(datetime_component.begin(), datetime_component.end(),
                 std::back_inserter(component_types),
                 [](const DatetimeComponent& component) {
                   return component.component_type;
                 });
  return GetFinestGranularityFromComponentTypes(component_types);
}

}  // namespace libtextclassifier3