annotator/duration/duration.h

/*
 * 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.
 */

#ifndef LIBTEXTCLASSIFIER_ANNOTATOR_DURATION_DURATION_H_
#define LIBTEXTCLASSIFIER_ANNOTATOR_DURATION_DURATION_H_

#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include "annotator/feature-processor.h"
#include "annotator/model_generated.h"
#include "annotator/types.h"
#include "utils/utf8/unicodetext.h"

namespace libtextclassifier3 {

namespace internal {
enum class DurationUnit {
  UNKNOWN = -1,
  WEEK = 0,
  DAY = 1,
  HOUR = 2,
  MINUTE = 3,
  SECOND = 4

  // NOTE: If we want to add MONTH and YEAR we'll have to think of different
  // parsing format, because MONTH and YEAR don't have a fixed number of
  // milliseconds, unlike week/day/hour/minute/second. We ignore the daylight
  // savings time and assume the day is always 24 hours.
};

// Prepares the mapping between token values and duration unit types.
std::unordered_map<std::string, internal::DurationUnit>
BuildTokenToDurationUnitMapping(const DurationAnnotatorOptions* options);

// Creates a set of strings from a flatbuffer string vector.
std::unordered_set<std::string> BuildStringSet(
    const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>*);

}  // namespace internal

// Annotator of duration expressions like "3 minutes 30 seconds".
class DurationAnnotator {
 public:
  explicit DurationAnnotator(const DurationAnnotatorOptions* options,
                             const FeatureProcessor* feature_processor)
      : options_(options),
        feature_processor_(feature_processor),
        token_value_to_duration_unit_(
            internal::BuildTokenToDurationUnitMapping(options)),
        filler_expressions_(
            internal::BuildStringSet(options->filler_expressions())),
        half_expressions_(
            internal::BuildStringSet(options->half_expressions())) {}

  // Classifies given text, and if it is a duration, it passes the result in
  // 'classification_result' and returns true, otherwise returns false.
  bool ClassifyText(const UnicodeText& context, CodepointSpan selection_indices,
                    AnnotationUsecase annotation_usecase,
                    ClassificationResult* classification_result) const;

  // Finds all duration instances in the input text.
  bool FindAll(const UnicodeText& context, const std::vector<Token>& tokens,
               AnnotationUsecase annotation_usecase,
               std::vector<AnnotatedSpan>* results) const;

 private:
  // Represents a component of duration parsed from text (e.g. "3 hours" from
  // the expression "3 hours and 20 minutes").
  struct ParsedDurationAtom {
    // Unit of the duration.
    internal::DurationUnit unit = internal::DurationUnit::UNKNOWN;

    // Quantity of the duration unit.
    int value = 0;

    // True, if half an unit was specified (either in addition, or exclusively).
    // E.g. "hour and a half".
    // NOTE: Quarter, three-quarters etc. is not supported.
    bool plus_half = false;

    static ParsedDurationAtom Half() {
      ParsedDurationAtom result;
      result.plus_half = true;
      return result;
    }
  };

  // Starts consuming tokens and returns the index past the last consumed token.
  int FindDurationStartingAt(const UnicodeText& context,
                             const std::vector<Token>& tokens,
                             int start_token_index,
                             AnnotatedSpan* result) const;

  bool ParseQuantityToken(const Token& token, ParsedDurationAtom* value) const;
  bool ParseDurationUnitToken(const Token& token,
                              internal::DurationUnit* duration_unit) const;
  bool ParseFillerToken(const Token& token) const;

  int64 ParsedDurationAtomsToMillis(
      const std::vector<ParsedDurationAtom>& atoms) const;

  const DurationAnnotatorOptions* options_;
  const FeatureProcessor* feature_processor_;
  const std::unordered_map<std::string, internal::DurationUnit>
      token_value_to_duration_unit_;
  const std::unordered_set<std::string> filler_expressions_;
  const std::unordered_set<std::string> half_expressions_;
};

}  // namespace libtextclassifier3

#endif  // LIBTEXTCLASSIFIER_ANNOTATOR_DURATION_DURATION_H_