| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| // automatically generated by the FlatBuffers compiler, do not modify |
| |
| |
| #ifndef FLATBUFFERS_GENERATED_MODEL_LIBTEXTCLASSIFIER2_H_ |
| #define FLATBUFFERS_GENERATED_MODEL_LIBTEXTCLASSIFIER2_H_ |
| |
| #include "flatbuffers/flatbuffers.h" |
| |
| namespace libtextclassifier2 { |
| |
| struct CompressedBuffer; |
| struct CompressedBufferT; |
| |
| struct SelectionModelOptions; |
| struct SelectionModelOptionsT; |
| |
| struct ClassificationModelOptions; |
| struct ClassificationModelOptionsT; |
| |
| namespace RegexModel_ { |
| |
| struct Pattern; |
| struct PatternT; |
| |
| } // namespace RegexModel_ |
| |
| struct RegexModel; |
| struct RegexModelT; |
| |
| namespace DatetimeModelPattern_ { |
| |
| struct Regex; |
| struct RegexT; |
| |
| } // namespace DatetimeModelPattern_ |
| |
| struct DatetimeModelPattern; |
| struct DatetimeModelPatternT; |
| |
| struct DatetimeModelExtractor; |
| struct DatetimeModelExtractorT; |
| |
| struct DatetimeModel; |
| struct DatetimeModelT; |
| |
| namespace DatetimeModelLibrary_ { |
| |
| struct Item; |
| struct ItemT; |
| |
| } // namespace DatetimeModelLibrary_ |
| |
| struct DatetimeModelLibrary; |
| struct DatetimeModelLibraryT; |
| |
| struct ModelTriggeringOptions; |
| struct ModelTriggeringOptionsT; |
| |
| struct OutputOptions; |
| struct OutputOptionsT; |
| |
| struct Model; |
| struct ModelT; |
| |
| struct TokenizationCodepointRange; |
| struct TokenizationCodepointRangeT; |
| |
| namespace FeatureProcessorOptions_ { |
| |
| struct CodepointRange; |
| struct CodepointRangeT; |
| |
| struct BoundsSensitiveFeatures; |
| struct BoundsSensitiveFeaturesT; |
| |
| struct AlternativeCollectionMapEntry; |
| struct AlternativeCollectionMapEntryT; |
| |
| } // namespace FeatureProcessorOptions_ |
| |
| struct FeatureProcessorOptions; |
| struct FeatureProcessorOptionsT; |
| |
| enum ModeFlag { |
| ModeFlag_NONE = 0, |
| ModeFlag_ANNOTATION = 1, |
| ModeFlag_CLASSIFICATION = 2, |
| ModeFlag_ANNOTATION_AND_CLASSIFICATION = 3, |
| ModeFlag_SELECTION = 4, |
| ModeFlag_ANNOTATION_AND_SELECTION = 5, |
| ModeFlag_CLASSIFICATION_AND_SELECTION = 6, |
| ModeFlag_ALL = 7, |
| ModeFlag_MIN = ModeFlag_NONE, |
| ModeFlag_MAX = ModeFlag_ALL |
| }; |
| |
| inline ModeFlag (&EnumValuesModeFlag())[8] { |
| static ModeFlag values[] = { |
| ModeFlag_NONE, |
| ModeFlag_ANNOTATION, |
| ModeFlag_CLASSIFICATION, |
| ModeFlag_ANNOTATION_AND_CLASSIFICATION, |
| ModeFlag_SELECTION, |
| ModeFlag_ANNOTATION_AND_SELECTION, |
| ModeFlag_CLASSIFICATION_AND_SELECTION, |
| ModeFlag_ALL |
| }; |
| return values; |
| } |
| |
| inline const char **EnumNamesModeFlag() { |
| static const char *names[] = { |
| "NONE", |
| "ANNOTATION", |
| "CLASSIFICATION", |
| "ANNOTATION_AND_CLASSIFICATION", |
| "SELECTION", |
| "ANNOTATION_AND_SELECTION", |
| "CLASSIFICATION_AND_SELECTION", |
| "ALL", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameModeFlag(ModeFlag e) { |
| const size_t index = static_cast<int>(e); |
| return EnumNamesModeFlag()[index]; |
| } |
| |
| enum DatetimeExtractorType { |
| DatetimeExtractorType_UNKNOWN_DATETIME_EXTRACTOR_TYPE = 0, |
| DatetimeExtractorType_AM = 1, |
| DatetimeExtractorType_PM = 2, |
| DatetimeExtractorType_JANUARY = 3, |
| DatetimeExtractorType_FEBRUARY = 4, |
| DatetimeExtractorType_MARCH = 5, |
| DatetimeExtractorType_APRIL = 6, |
| DatetimeExtractorType_MAY = 7, |
| DatetimeExtractorType_JUNE = 8, |
| DatetimeExtractorType_JULY = 9, |
| DatetimeExtractorType_AUGUST = 10, |
| DatetimeExtractorType_SEPTEMBER = 11, |
| DatetimeExtractorType_OCTOBER = 12, |
| DatetimeExtractorType_NOVEMBER = 13, |
| DatetimeExtractorType_DECEMBER = 14, |
| DatetimeExtractorType_NEXT = 15, |
| DatetimeExtractorType_NEXT_OR_SAME = 16, |
| DatetimeExtractorType_LAST = 17, |
| DatetimeExtractorType_NOW = 18, |
| DatetimeExtractorType_TOMORROW = 19, |
| DatetimeExtractorType_YESTERDAY = 20, |
| DatetimeExtractorType_PAST = 21, |
| DatetimeExtractorType_FUTURE = 22, |
| DatetimeExtractorType_DAY = 23, |
| DatetimeExtractorType_WEEK = 24, |
| DatetimeExtractorType_MONTH = 25, |
| DatetimeExtractorType_YEAR = 26, |
| DatetimeExtractorType_MONDAY = 27, |
| DatetimeExtractorType_TUESDAY = 28, |
| DatetimeExtractorType_WEDNESDAY = 29, |
| DatetimeExtractorType_THURSDAY = 30, |
| DatetimeExtractorType_FRIDAY = 31, |
| DatetimeExtractorType_SATURDAY = 32, |
| DatetimeExtractorType_SUNDAY = 33, |
| DatetimeExtractorType_DAYS = 34, |
| DatetimeExtractorType_WEEKS = 35, |
| DatetimeExtractorType_MONTHS = 36, |
| DatetimeExtractorType_HOURS = 37, |
| DatetimeExtractorType_MINUTES = 38, |
| DatetimeExtractorType_SECONDS = 39, |
| DatetimeExtractorType_YEARS = 40, |
| DatetimeExtractorType_DIGITS = 41, |
| DatetimeExtractorType_SIGNEDDIGITS = 42, |
| DatetimeExtractorType_ZERO = 43, |
| DatetimeExtractorType_ONE = 44, |
| DatetimeExtractorType_TWO = 45, |
| DatetimeExtractorType_THREE = 46, |
| DatetimeExtractorType_FOUR = 47, |
| DatetimeExtractorType_FIVE = 48, |
| DatetimeExtractorType_SIX = 49, |
| DatetimeExtractorType_SEVEN = 50, |
| DatetimeExtractorType_EIGHT = 51, |
| DatetimeExtractorType_NINE = 52, |
| DatetimeExtractorType_TEN = 53, |
| DatetimeExtractorType_ELEVEN = 54, |
| DatetimeExtractorType_TWELVE = 55, |
| DatetimeExtractorType_THIRTEEN = 56, |
| DatetimeExtractorType_FOURTEEN = 57, |
| DatetimeExtractorType_FIFTEEN = 58, |
| DatetimeExtractorType_SIXTEEN = 59, |
| DatetimeExtractorType_SEVENTEEN = 60, |
| DatetimeExtractorType_EIGHTEEN = 61, |
| DatetimeExtractorType_NINETEEN = 62, |
| DatetimeExtractorType_TWENTY = 63, |
| DatetimeExtractorType_THIRTY = 64, |
| DatetimeExtractorType_FORTY = 65, |
| DatetimeExtractorType_FIFTY = 66, |
| DatetimeExtractorType_SIXTY = 67, |
| DatetimeExtractorType_SEVENTY = 68, |
| DatetimeExtractorType_EIGHTY = 69, |
| DatetimeExtractorType_NINETY = 70, |
| DatetimeExtractorType_HUNDRED = 71, |
| DatetimeExtractorType_THOUSAND = 72, |
| DatetimeExtractorType_MIN = DatetimeExtractorType_UNKNOWN_DATETIME_EXTRACTOR_TYPE, |
| DatetimeExtractorType_MAX = DatetimeExtractorType_THOUSAND |
| }; |
| |
| inline DatetimeExtractorType (&EnumValuesDatetimeExtractorType())[73] { |
| static DatetimeExtractorType values[] = { |
| DatetimeExtractorType_UNKNOWN_DATETIME_EXTRACTOR_TYPE, |
| DatetimeExtractorType_AM, |
| DatetimeExtractorType_PM, |
| DatetimeExtractorType_JANUARY, |
| DatetimeExtractorType_FEBRUARY, |
| DatetimeExtractorType_MARCH, |
| DatetimeExtractorType_APRIL, |
| DatetimeExtractorType_MAY, |
| DatetimeExtractorType_JUNE, |
| DatetimeExtractorType_JULY, |
| DatetimeExtractorType_AUGUST, |
| DatetimeExtractorType_SEPTEMBER, |
| DatetimeExtractorType_OCTOBER, |
| DatetimeExtractorType_NOVEMBER, |
| DatetimeExtractorType_DECEMBER, |
| DatetimeExtractorType_NEXT, |
| DatetimeExtractorType_NEXT_OR_SAME, |
| DatetimeExtractorType_LAST, |
| DatetimeExtractorType_NOW, |
| DatetimeExtractorType_TOMORROW, |
| DatetimeExtractorType_YESTERDAY, |
| DatetimeExtractorType_PAST, |
| DatetimeExtractorType_FUTURE, |
| DatetimeExtractorType_DAY, |
| DatetimeExtractorType_WEEK, |
| DatetimeExtractorType_MONTH, |
| DatetimeExtractorType_YEAR, |
| DatetimeExtractorType_MONDAY, |
| DatetimeExtractorType_TUESDAY, |
| DatetimeExtractorType_WEDNESDAY, |
| DatetimeExtractorType_THURSDAY, |
| DatetimeExtractorType_FRIDAY, |
| DatetimeExtractorType_SATURDAY, |
| DatetimeExtractorType_SUNDAY, |
| DatetimeExtractorType_DAYS, |
| DatetimeExtractorType_WEEKS, |
| DatetimeExtractorType_MONTHS, |
| DatetimeExtractorType_HOURS, |
| DatetimeExtractorType_MINUTES, |
| DatetimeExtractorType_SECONDS, |
| DatetimeExtractorType_YEARS, |
| DatetimeExtractorType_DIGITS, |
| DatetimeExtractorType_SIGNEDDIGITS, |
| DatetimeExtractorType_ZERO, |
| DatetimeExtractorType_ONE, |
| DatetimeExtractorType_TWO, |
| DatetimeExtractorType_THREE, |
| DatetimeExtractorType_FOUR, |
| DatetimeExtractorType_FIVE, |
| DatetimeExtractorType_SIX, |
| DatetimeExtractorType_SEVEN, |
| DatetimeExtractorType_EIGHT, |
| DatetimeExtractorType_NINE, |
| DatetimeExtractorType_TEN, |
| DatetimeExtractorType_ELEVEN, |
| DatetimeExtractorType_TWELVE, |
| DatetimeExtractorType_THIRTEEN, |
| DatetimeExtractorType_FOURTEEN, |
| DatetimeExtractorType_FIFTEEN, |
| DatetimeExtractorType_SIXTEEN, |
| DatetimeExtractorType_SEVENTEEN, |
| DatetimeExtractorType_EIGHTEEN, |
| DatetimeExtractorType_NINETEEN, |
| DatetimeExtractorType_TWENTY, |
| DatetimeExtractorType_THIRTY, |
| DatetimeExtractorType_FORTY, |
| DatetimeExtractorType_FIFTY, |
| DatetimeExtractorType_SIXTY, |
| DatetimeExtractorType_SEVENTY, |
| DatetimeExtractorType_EIGHTY, |
| DatetimeExtractorType_NINETY, |
| DatetimeExtractorType_HUNDRED, |
| DatetimeExtractorType_THOUSAND |
| }; |
| return values; |
| } |
| |
| inline const char **EnumNamesDatetimeExtractorType() { |
| static const char *names[] = { |
| "UNKNOWN_DATETIME_EXTRACTOR_TYPE", |
| "AM", |
| "PM", |
| "JANUARY", |
| "FEBRUARY", |
| "MARCH", |
| "APRIL", |
| "MAY", |
| "JUNE", |
| "JULY", |
| "AUGUST", |
| "SEPTEMBER", |
| "OCTOBER", |
| "NOVEMBER", |
| "DECEMBER", |
| "NEXT", |
| "NEXT_OR_SAME", |
| "LAST", |
| "NOW", |
| "TOMORROW", |
| "YESTERDAY", |
| "PAST", |
| "FUTURE", |
| "DAY", |
| "WEEK", |
| "MONTH", |
| "YEAR", |
| "MONDAY", |
| "TUESDAY", |
| "WEDNESDAY", |
| "THURSDAY", |
| "FRIDAY", |
| "SATURDAY", |
| "SUNDAY", |
| "DAYS", |
| "WEEKS", |
| "MONTHS", |
| "HOURS", |
| "MINUTES", |
| "SECONDS", |
| "YEARS", |
| "DIGITS", |
| "SIGNEDDIGITS", |
| "ZERO", |
| "ONE", |
| "TWO", |
| "THREE", |
| "FOUR", |
| "FIVE", |
| "SIX", |
| "SEVEN", |
| "EIGHT", |
| "NINE", |
| "TEN", |
| "ELEVEN", |
| "TWELVE", |
| "THIRTEEN", |
| "FOURTEEN", |
| "FIFTEEN", |
| "SIXTEEN", |
| "SEVENTEEN", |
| "EIGHTEEN", |
| "NINETEEN", |
| "TWENTY", |
| "THIRTY", |
| "FORTY", |
| "FIFTY", |
| "SIXTY", |
| "SEVENTY", |
| "EIGHTY", |
| "NINETY", |
| "HUNDRED", |
| "THOUSAND", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameDatetimeExtractorType(DatetimeExtractorType e) { |
| const size_t index = static_cast<int>(e); |
| return EnumNamesDatetimeExtractorType()[index]; |
| } |
| |
| enum DatetimeGroupType { |
| DatetimeGroupType_GROUP_UNKNOWN = 0, |
| DatetimeGroupType_GROUP_UNUSED = 1, |
| DatetimeGroupType_GROUP_YEAR = 2, |
| DatetimeGroupType_GROUP_MONTH = 3, |
| DatetimeGroupType_GROUP_DAY = 4, |
| DatetimeGroupType_GROUP_HOUR = 5, |
| DatetimeGroupType_GROUP_MINUTE = 6, |
| DatetimeGroupType_GROUP_SECOND = 7, |
| DatetimeGroupType_GROUP_AMPM = 8, |
| DatetimeGroupType_GROUP_RELATIONDISTANCE = 9, |
| DatetimeGroupType_GROUP_RELATION = 10, |
| DatetimeGroupType_GROUP_RELATIONTYPE = 11, |
| DatetimeGroupType_GROUP_DUMMY1 = 12, |
| DatetimeGroupType_GROUP_DUMMY2 = 13, |
| DatetimeGroupType_MIN = DatetimeGroupType_GROUP_UNKNOWN, |
| DatetimeGroupType_MAX = DatetimeGroupType_GROUP_DUMMY2 |
| }; |
| |
| inline DatetimeGroupType (&EnumValuesDatetimeGroupType())[14] { |
| static DatetimeGroupType values[] = { |
| DatetimeGroupType_GROUP_UNKNOWN, |
| DatetimeGroupType_GROUP_UNUSED, |
| DatetimeGroupType_GROUP_YEAR, |
| DatetimeGroupType_GROUP_MONTH, |
| DatetimeGroupType_GROUP_DAY, |
| DatetimeGroupType_GROUP_HOUR, |
| DatetimeGroupType_GROUP_MINUTE, |
| DatetimeGroupType_GROUP_SECOND, |
| DatetimeGroupType_GROUP_AMPM, |
| DatetimeGroupType_GROUP_RELATIONDISTANCE, |
| DatetimeGroupType_GROUP_RELATION, |
| DatetimeGroupType_GROUP_RELATIONTYPE, |
| DatetimeGroupType_GROUP_DUMMY1, |
| DatetimeGroupType_GROUP_DUMMY2 |
| }; |
| return values; |
| } |
| |
| inline const char **EnumNamesDatetimeGroupType() { |
| static const char *names[] = { |
| "GROUP_UNKNOWN", |
| "GROUP_UNUSED", |
| "GROUP_YEAR", |
| "GROUP_MONTH", |
| "GROUP_DAY", |
| "GROUP_HOUR", |
| "GROUP_MINUTE", |
| "GROUP_SECOND", |
| "GROUP_AMPM", |
| "GROUP_RELATIONDISTANCE", |
| "GROUP_RELATION", |
| "GROUP_RELATIONTYPE", |
| "GROUP_DUMMY1", |
| "GROUP_DUMMY2", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameDatetimeGroupType(DatetimeGroupType e) { |
| const size_t index = static_cast<int>(e); |
| return EnumNamesDatetimeGroupType()[index]; |
| } |
| |
| namespace TokenizationCodepointRange_ { |
| |
| enum Role { |
| Role_DEFAULT_ROLE = 0, |
| Role_SPLIT_BEFORE = 1, |
| Role_SPLIT_AFTER = 2, |
| Role_TOKEN_SEPARATOR = 3, |
| Role_DISCARD_CODEPOINT = 4, |
| Role_WHITESPACE_SEPARATOR = 7, |
| Role_MIN = Role_DEFAULT_ROLE, |
| Role_MAX = Role_WHITESPACE_SEPARATOR |
| }; |
| |
| inline Role (&EnumValuesRole())[6] { |
| static Role values[] = { |
| Role_DEFAULT_ROLE, |
| Role_SPLIT_BEFORE, |
| Role_SPLIT_AFTER, |
| Role_TOKEN_SEPARATOR, |
| Role_DISCARD_CODEPOINT, |
| Role_WHITESPACE_SEPARATOR |
| }; |
| return values; |
| } |
| |
| inline const char **EnumNamesRole() { |
| static const char *names[] = { |
| "DEFAULT_ROLE", |
| "SPLIT_BEFORE", |
| "SPLIT_AFTER", |
| "TOKEN_SEPARATOR", |
| "DISCARD_CODEPOINT", |
| "", |
| "", |
| "WHITESPACE_SEPARATOR", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameRole(Role e) { |
| const size_t index = static_cast<int>(e); |
| return EnumNamesRole()[index]; |
| } |
| |
| } // namespace TokenizationCodepointRange_ |
| |
| namespace FeatureProcessorOptions_ { |
| |
| enum CenterTokenSelectionMethod { |
| CenterTokenSelectionMethod_DEFAULT_CENTER_TOKEN_METHOD = 0, |
| CenterTokenSelectionMethod_CENTER_TOKEN_FROM_CLICK = 1, |
| CenterTokenSelectionMethod_CENTER_TOKEN_MIDDLE_OF_SELECTION = 2, |
| CenterTokenSelectionMethod_MIN = CenterTokenSelectionMethod_DEFAULT_CENTER_TOKEN_METHOD, |
| CenterTokenSelectionMethod_MAX = CenterTokenSelectionMethod_CENTER_TOKEN_MIDDLE_OF_SELECTION |
| }; |
| |
| inline CenterTokenSelectionMethod (&EnumValuesCenterTokenSelectionMethod())[3] { |
| static CenterTokenSelectionMethod values[] = { |
| CenterTokenSelectionMethod_DEFAULT_CENTER_TOKEN_METHOD, |
| CenterTokenSelectionMethod_CENTER_TOKEN_FROM_CLICK, |
| CenterTokenSelectionMethod_CENTER_TOKEN_MIDDLE_OF_SELECTION |
| }; |
| return values; |
| } |
| |
| inline const char **EnumNamesCenterTokenSelectionMethod() { |
| static const char *names[] = { |
| "DEFAULT_CENTER_TOKEN_METHOD", |
| "CENTER_TOKEN_FROM_CLICK", |
| "CENTER_TOKEN_MIDDLE_OF_SELECTION", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameCenterTokenSelectionMethod(CenterTokenSelectionMethod e) { |
| const size_t index = static_cast<int>(e); |
| return EnumNamesCenterTokenSelectionMethod()[index]; |
| } |
| |
| enum TokenizationType { |
| TokenizationType_INVALID_TOKENIZATION_TYPE = 0, |
| TokenizationType_INTERNAL_TOKENIZER = 1, |
| TokenizationType_ICU = 2, |
| TokenizationType_MIXED = 3, |
| TokenizationType_MIN = TokenizationType_INVALID_TOKENIZATION_TYPE, |
| TokenizationType_MAX = TokenizationType_MIXED |
| }; |
| |
| inline TokenizationType (&EnumValuesTokenizationType())[4] { |
| static TokenizationType values[] = { |
| TokenizationType_INVALID_TOKENIZATION_TYPE, |
| TokenizationType_INTERNAL_TOKENIZER, |
| TokenizationType_ICU, |
| TokenizationType_MIXED |
| }; |
| return values; |
| } |
| |
| inline const char **EnumNamesTokenizationType() { |
| static const char *names[] = { |
| "INVALID_TOKENIZATION_TYPE", |
| "INTERNAL_TOKENIZER", |
| "ICU", |
| "MIXED", |
| nullptr |
| }; |
| return names; |
| } |
| |
| inline const char *EnumNameTokenizationType(TokenizationType e) { |
| const size_t index = static_cast<int>(e); |
| return EnumNamesTokenizationType()[index]; |
| } |
| |
| } // namespace FeatureProcessorOptions_ |
| |
| struct CompressedBufferT : public flatbuffers::NativeTable { |
| typedef CompressedBuffer TableType; |
| std::vector<uint8_t> buffer; |
| int32_t uncompressed_size; |
| CompressedBufferT() |
| : uncompressed_size(0) { |
| } |
| }; |
| |
| struct CompressedBuffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef CompressedBufferT NativeTableType; |
| enum { |
| VT_BUFFER = 4, |
| VT_UNCOMPRESSED_SIZE = 6 |
| }; |
| const flatbuffers::Vector<uint8_t> *buffer() const { |
| return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_BUFFER); |
| } |
| int32_t uncompressed_size() const { |
| return GetField<int32_t>(VT_UNCOMPRESSED_SIZE, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_BUFFER) && |
| verifier.Verify(buffer()) && |
| VerifyField<int32_t>(verifier, VT_UNCOMPRESSED_SIZE) && |
| verifier.EndTable(); |
| } |
| CompressedBufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(CompressedBufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<CompressedBuffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CompressedBufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct CompressedBufferBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_buffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> buffer) { |
| fbb_.AddOffset(CompressedBuffer::VT_BUFFER, buffer); |
| } |
| void add_uncompressed_size(int32_t uncompressed_size) { |
| fbb_.AddElement<int32_t>(CompressedBuffer::VT_UNCOMPRESSED_SIZE, uncompressed_size, 0); |
| } |
| explicit CompressedBufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| CompressedBufferBuilder &operator=(const CompressedBufferBuilder &); |
| flatbuffers::Offset<CompressedBuffer> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<CompressedBuffer>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<CompressedBuffer> CreateCompressedBuffer( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<uint8_t>> buffer = 0, |
| int32_t uncompressed_size = 0) { |
| CompressedBufferBuilder builder_(_fbb); |
| builder_.add_uncompressed_size(uncompressed_size); |
| builder_.add_buffer(buffer); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<CompressedBuffer> CreateCompressedBufferDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<uint8_t> *buffer = nullptr, |
| int32_t uncompressed_size = 0) { |
| return libtextclassifier2::CreateCompressedBuffer( |
| _fbb, |
| buffer ? _fbb.CreateVector<uint8_t>(*buffer) : 0, |
| uncompressed_size); |
| } |
| |
| flatbuffers::Offset<CompressedBuffer> CreateCompressedBuffer(flatbuffers::FlatBufferBuilder &_fbb, const CompressedBufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct SelectionModelOptionsT : public flatbuffers::NativeTable { |
| typedef SelectionModelOptions TableType; |
| bool strip_unpaired_brackets; |
| int32_t symmetry_context_size; |
| int32_t batch_size; |
| bool always_classify_suggested_selection; |
| SelectionModelOptionsT() |
| : strip_unpaired_brackets(true), |
| symmetry_context_size(0), |
| batch_size(1024), |
| always_classify_suggested_selection(false) { |
| } |
| }; |
| |
| struct SelectionModelOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef SelectionModelOptionsT NativeTableType; |
| enum { |
| VT_STRIP_UNPAIRED_BRACKETS = 4, |
| VT_SYMMETRY_CONTEXT_SIZE = 6, |
| VT_BATCH_SIZE = 8, |
| VT_ALWAYS_CLASSIFY_SUGGESTED_SELECTION = 10 |
| }; |
| bool strip_unpaired_brackets() const { |
| return GetField<uint8_t>(VT_STRIP_UNPAIRED_BRACKETS, 1) != 0; |
| } |
| int32_t symmetry_context_size() const { |
| return GetField<int32_t>(VT_SYMMETRY_CONTEXT_SIZE, 0); |
| } |
| int32_t batch_size() const { |
| return GetField<int32_t>(VT_BATCH_SIZE, 1024); |
| } |
| bool always_classify_suggested_selection() const { |
| return GetField<uint8_t>(VT_ALWAYS_CLASSIFY_SUGGESTED_SELECTION, 0) != 0; |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint8_t>(verifier, VT_STRIP_UNPAIRED_BRACKETS) && |
| VerifyField<int32_t>(verifier, VT_SYMMETRY_CONTEXT_SIZE) && |
| VerifyField<int32_t>(verifier, VT_BATCH_SIZE) && |
| VerifyField<uint8_t>(verifier, VT_ALWAYS_CLASSIFY_SUGGESTED_SELECTION) && |
| verifier.EndTable(); |
| } |
| SelectionModelOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(SelectionModelOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<SelectionModelOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectionModelOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct SelectionModelOptionsBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_strip_unpaired_brackets(bool strip_unpaired_brackets) { |
| fbb_.AddElement<uint8_t>(SelectionModelOptions::VT_STRIP_UNPAIRED_BRACKETS, static_cast<uint8_t>(strip_unpaired_brackets), 1); |
| } |
| void add_symmetry_context_size(int32_t symmetry_context_size) { |
| fbb_.AddElement<int32_t>(SelectionModelOptions::VT_SYMMETRY_CONTEXT_SIZE, symmetry_context_size, 0); |
| } |
| void add_batch_size(int32_t batch_size) { |
| fbb_.AddElement<int32_t>(SelectionModelOptions::VT_BATCH_SIZE, batch_size, 1024); |
| } |
| void add_always_classify_suggested_selection(bool always_classify_suggested_selection) { |
| fbb_.AddElement<uint8_t>(SelectionModelOptions::VT_ALWAYS_CLASSIFY_SUGGESTED_SELECTION, static_cast<uint8_t>(always_classify_suggested_selection), 0); |
| } |
| explicit SelectionModelOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| SelectionModelOptionsBuilder &operator=(const SelectionModelOptionsBuilder &); |
| flatbuffers::Offset<SelectionModelOptions> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<SelectionModelOptions>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<SelectionModelOptions> CreateSelectionModelOptions( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| bool strip_unpaired_brackets = true, |
| int32_t symmetry_context_size = 0, |
| int32_t batch_size = 1024, |
| bool always_classify_suggested_selection = false) { |
| SelectionModelOptionsBuilder builder_(_fbb); |
| builder_.add_batch_size(batch_size); |
| builder_.add_symmetry_context_size(symmetry_context_size); |
| builder_.add_always_classify_suggested_selection(always_classify_suggested_selection); |
| builder_.add_strip_unpaired_brackets(strip_unpaired_brackets); |
| return builder_.Finish(); |
| } |
| |
| flatbuffers::Offset<SelectionModelOptions> CreateSelectionModelOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectionModelOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct ClassificationModelOptionsT : public flatbuffers::NativeTable { |
| typedef ClassificationModelOptions TableType; |
| int32_t phone_min_num_digits; |
| int32_t phone_max_num_digits; |
| int32_t address_min_num_tokens; |
| int32_t max_num_tokens; |
| ClassificationModelOptionsT() |
| : phone_min_num_digits(7), |
| phone_max_num_digits(15), |
| address_min_num_tokens(0), |
| max_num_tokens(-1) { |
| } |
| }; |
| |
| struct ClassificationModelOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef ClassificationModelOptionsT NativeTableType; |
| enum { |
| VT_PHONE_MIN_NUM_DIGITS = 4, |
| VT_PHONE_MAX_NUM_DIGITS = 6, |
| VT_ADDRESS_MIN_NUM_TOKENS = 8, |
| VT_MAX_NUM_TOKENS = 10 |
| }; |
| int32_t phone_min_num_digits() const { |
| return GetField<int32_t>(VT_PHONE_MIN_NUM_DIGITS, 7); |
| } |
| int32_t phone_max_num_digits() const { |
| return GetField<int32_t>(VT_PHONE_MAX_NUM_DIGITS, 15); |
| } |
| int32_t address_min_num_tokens() const { |
| return GetField<int32_t>(VT_ADDRESS_MIN_NUM_TOKENS, 0); |
| } |
| int32_t max_num_tokens() const { |
| return GetField<int32_t>(VT_MAX_NUM_TOKENS, -1); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int32_t>(verifier, VT_PHONE_MIN_NUM_DIGITS) && |
| VerifyField<int32_t>(verifier, VT_PHONE_MAX_NUM_DIGITS) && |
| VerifyField<int32_t>(verifier, VT_ADDRESS_MIN_NUM_TOKENS) && |
| VerifyField<int32_t>(verifier, VT_MAX_NUM_TOKENS) && |
| verifier.EndTable(); |
| } |
| ClassificationModelOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(ClassificationModelOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<ClassificationModelOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ClassificationModelOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct ClassificationModelOptionsBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_phone_min_num_digits(int32_t phone_min_num_digits) { |
| fbb_.AddElement<int32_t>(ClassificationModelOptions::VT_PHONE_MIN_NUM_DIGITS, phone_min_num_digits, 7); |
| } |
| void add_phone_max_num_digits(int32_t phone_max_num_digits) { |
| fbb_.AddElement<int32_t>(ClassificationModelOptions::VT_PHONE_MAX_NUM_DIGITS, phone_max_num_digits, 15); |
| } |
| void add_address_min_num_tokens(int32_t address_min_num_tokens) { |
| fbb_.AddElement<int32_t>(ClassificationModelOptions::VT_ADDRESS_MIN_NUM_TOKENS, address_min_num_tokens, 0); |
| } |
| void add_max_num_tokens(int32_t max_num_tokens) { |
| fbb_.AddElement<int32_t>(ClassificationModelOptions::VT_MAX_NUM_TOKENS, max_num_tokens, -1); |
| } |
| explicit ClassificationModelOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ClassificationModelOptionsBuilder &operator=(const ClassificationModelOptionsBuilder &); |
| flatbuffers::Offset<ClassificationModelOptions> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<ClassificationModelOptions>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<ClassificationModelOptions> CreateClassificationModelOptions( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| int32_t phone_min_num_digits = 7, |
| int32_t phone_max_num_digits = 15, |
| int32_t address_min_num_tokens = 0, |
| int32_t max_num_tokens = -1) { |
| ClassificationModelOptionsBuilder builder_(_fbb); |
| builder_.add_max_num_tokens(max_num_tokens); |
| builder_.add_address_min_num_tokens(address_min_num_tokens); |
| builder_.add_phone_max_num_digits(phone_max_num_digits); |
| builder_.add_phone_min_num_digits(phone_min_num_digits); |
| return builder_.Finish(); |
| } |
| |
| flatbuffers::Offset<ClassificationModelOptions> CreateClassificationModelOptions(flatbuffers::FlatBufferBuilder &_fbb, const ClassificationModelOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| namespace RegexModel_ { |
| |
| struct PatternT : public flatbuffers::NativeTable { |
| typedef Pattern TableType; |
| std::string collection_name; |
| std::string pattern; |
| libtextclassifier2::ModeFlag enabled_modes; |
| float target_classification_score; |
| float priority_score; |
| bool use_approximate_matching; |
| std::unique_ptr<libtextclassifier2::CompressedBufferT> compressed_pattern; |
| PatternT() |
| : enabled_modes(libtextclassifier2::ModeFlag_ALL), |
| target_classification_score(1.0f), |
| priority_score(0.0f), |
| use_approximate_matching(false) { |
| } |
| }; |
| |
| struct Pattern FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef PatternT NativeTableType; |
| enum { |
| VT_COLLECTION_NAME = 4, |
| VT_PATTERN = 6, |
| VT_ENABLED_MODES = 8, |
| VT_TARGET_CLASSIFICATION_SCORE = 10, |
| VT_PRIORITY_SCORE = 12, |
| VT_USE_APPROXIMATE_MATCHING = 14, |
| VT_COMPRESSED_PATTERN = 16 |
| }; |
| const flatbuffers::String *collection_name() const { |
| return GetPointer<const flatbuffers::String *>(VT_COLLECTION_NAME); |
| } |
| const flatbuffers::String *pattern() const { |
| return GetPointer<const flatbuffers::String *>(VT_PATTERN); |
| } |
| libtextclassifier2::ModeFlag enabled_modes() const { |
| return static_cast<libtextclassifier2::ModeFlag>(GetField<int32_t>(VT_ENABLED_MODES, 7)); |
| } |
| float target_classification_score() const { |
| return GetField<float>(VT_TARGET_CLASSIFICATION_SCORE, 1.0f); |
| } |
| float priority_score() const { |
| return GetField<float>(VT_PRIORITY_SCORE, 0.0f); |
| } |
| bool use_approximate_matching() const { |
| return GetField<uint8_t>(VT_USE_APPROXIMATE_MATCHING, 0) != 0; |
| } |
| const libtextclassifier2::CompressedBuffer *compressed_pattern() const { |
| return GetPointer<const libtextclassifier2::CompressedBuffer *>(VT_COMPRESSED_PATTERN); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_COLLECTION_NAME) && |
| verifier.Verify(collection_name()) && |
| VerifyOffset(verifier, VT_PATTERN) && |
| verifier.Verify(pattern()) && |
| VerifyField<int32_t>(verifier, VT_ENABLED_MODES) && |
| VerifyField<float>(verifier, VT_TARGET_CLASSIFICATION_SCORE) && |
| VerifyField<float>(verifier, VT_PRIORITY_SCORE) && |
| VerifyField<uint8_t>(verifier, VT_USE_APPROXIMATE_MATCHING) && |
| VerifyOffset(verifier, VT_COMPRESSED_PATTERN) && |
| verifier.VerifyTable(compressed_pattern()) && |
| verifier.EndTable(); |
| } |
| PatternT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(PatternT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<Pattern> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PatternT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct PatternBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_collection_name(flatbuffers::Offset<flatbuffers::String> collection_name) { |
| fbb_.AddOffset(Pattern::VT_COLLECTION_NAME, collection_name); |
| } |
| void add_pattern(flatbuffers::Offset<flatbuffers::String> pattern) { |
| fbb_.AddOffset(Pattern::VT_PATTERN, pattern); |
| } |
| void add_enabled_modes(libtextclassifier2::ModeFlag enabled_modes) { |
| fbb_.AddElement<int32_t>(Pattern::VT_ENABLED_MODES, static_cast<int32_t>(enabled_modes), 7); |
| } |
| void add_target_classification_score(float target_classification_score) { |
| fbb_.AddElement<float>(Pattern::VT_TARGET_CLASSIFICATION_SCORE, target_classification_score, 1.0f); |
| } |
| void add_priority_score(float priority_score) { |
| fbb_.AddElement<float>(Pattern::VT_PRIORITY_SCORE, priority_score, 0.0f); |
| } |
| void add_use_approximate_matching(bool use_approximate_matching) { |
| fbb_.AddElement<uint8_t>(Pattern::VT_USE_APPROXIMATE_MATCHING, static_cast<uint8_t>(use_approximate_matching), 0); |
| } |
| void add_compressed_pattern(flatbuffers::Offset<libtextclassifier2::CompressedBuffer> compressed_pattern) { |
| fbb_.AddOffset(Pattern::VT_COMPRESSED_PATTERN, compressed_pattern); |
| } |
| explicit PatternBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| PatternBuilder &operator=(const PatternBuilder &); |
| flatbuffers::Offset<Pattern> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<Pattern>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<Pattern> CreatePattern( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::String> collection_name = 0, |
| flatbuffers::Offset<flatbuffers::String> pattern = 0, |
| libtextclassifier2::ModeFlag enabled_modes = libtextclassifier2::ModeFlag_ALL, |
| float target_classification_score = 1.0f, |
| float priority_score = 0.0f, |
| bool use_approximate_matching = false, |
| flatbuffers::Offset<libtextclassifier2::CompressedBuffer> compressed_pattern = 0) { |
| PatternBuilder builder_(_fbb); |
| builder_.add_compressed_pattern(compressed_pattern); |
| builder_.add_priority_score(priority_score); |
| builder_.add_target_classification_score(target_classification_score); |
| builder_.add_enabled_modes(enabled_modes); |
| builder_.add_pattern(pattern); |
| builder_.add_collection_name(collection_name); |
| builder_.add_use_approximate_matching(use_approximate_matching); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<Pattern> CreatePatternDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const char *collection_name = nullptr, |
| const char *pattern = nullptr, |
| libtextclassifier2::ModeFlag enabled_modes = libtextclassifier2::ModeFlag_ALL, |
| float target_classification_score = 1.0f, |
| float priority_score = 0.0f, |
| bool use_approximate_matching = false, |
| flatbuffers::Offset<libtextclassifier2::CompressedBuffer> compressed_pattern = 0) { |
| return libtextclassifier2::RegexModel_::CreatePattern( |
| _fbb, |
| collection_name ? _fbb.CreateString(collection_name) : 0, |
| pattern ? _fbb.CreateString(pattern) : 0, |
| enabled_modes, |
| target_classification_score, |
| priority_score, |
| use_approximate_matching, |
| compressed_pattern); |
| } |
| |
| flatbuffers::Offset<Pattern> CreatePattern(flatbuffers::FlatBufferBuilder &_fbb, const PatternT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| } // namespace RegexModel_ |
| |
| struct RegexModelT : public flatbuffers::NativeTable { |
| typedef RegexModel TableType; |
| std::vector<std::unique_ptr<libtextclassifier2::RegexModel_::PatternT>> patterns; |
| RegexModelT() { |
| } |
| }; |
| |
| struct RegexModel FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef RegexModelT NativeTableType; |
| enum { |
| VT_PATTERNS = 4 |
| }; |
| const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>> *patterns() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>> *>(VT_PATTERNS); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_PATTERNS) && |
| verifier.Verify(patterns()) && |
| verifier.VerifyVectorOfTables(patterns()) && |
| verifier.EndTable(); |
| } |
| RegexModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(RegexModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<RegexModel> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegexModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct RegexModelBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_patterns(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>>> patterns) { |
| fbb_.AddOffset(RegexModel::VT_PATTERNS, patterns); |
| } |
| explicit RegexModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| RegexModelBuilder &operator=(const RegexModelBuilder &); |
| flatbuffers::Offset<RegexModel> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<RegexModel>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<RegexModel> CreateRegexModel( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>>> patterns = 0) { |
| RegexModelBuilder builder_(_fbb); |
| builder_.add_patterns(patterns); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<RegexModel> CreateRegexModelDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>> *patterns = nullptr) { |
| return libtextclassifier2::CreateRegexModel( |
| _fbb, |
| patterns ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>>(*patterns) : 0); |
| } |
| |
| flatbuffers::Offset<RegexModel> CreateRegexModel(flatbuffers::FlatBufferBuilder &_fbb, const RegexModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| namespace DatetimeModelPattern_ { |
| |
| struct RegexT : public flatbuffers::NativeTable { |
| typedef Regex TableType; |
| std::string pattern; |
| std::vector<libtextclassifier2::DatetimeGroupType> groups; |
| std::unique_ptr<libtextclassifier2::CompressedBufferT> compressed_pattern; |
| RegexT() { |
| } |
| }; |
| |
| struct Regex FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef RegexT NativeTableType; |
| enum { |
| VT_PATTERN = 4, |
| VT_GROUPS = 6, |
| VT_COMPRESSED_PATTERN = 8 |
| }; |
| const flatbuffers::String *pattern() const { |
| return GetPointer<const flatbuffers::String *>(VT_PATTERN); |
| } |
| const flatbuffers::Vector<int32_t> *groups() const { |
| return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_GROUPS); |
| } |
| const libtextclassifier2::CompressedBuffer *compressed_pattern() const { |
| return GetPointer<const libtextclassifier2::CompressedBuffer *>(VT_COMPRESSED_PATTERN); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_PATTERN) && |
| verifier.Verify(pattern()) && |
| VerifyOffset(verifier, VT_GROUPS) && |
| verifier.Verify(groups()) && |
| VerifyOffset(verifier, VT_COMPRESSED_PATTERN) && |
| verifier.VerifyTable(compressed_pattern()) && |
| verifier.EndTable(); |
| } |
| RegexT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(RegexT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<Regex> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegexT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct RegexBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_pattern(flatbuffers::Offset<flatbuffers::String> pattern) { |
| fbb_.AddOffset(Regex::VT_PATTERN, pattern); |
| } |
| void add_groups(flatbuffers::Offset<flatbuffers::Vector<int32_t>> groups) { |
| fbb_.AddOffset(Regex::VT_GROUPS, groups); |
| } |
| void add_compressed_pattern(flatbuffers::Offset<libtextclassifier2::CompressedBuffer> compressed_pattern) { |
| fbb_.AddOffset(Regex::VT_COMPRESSED_PATTERN, compressed_pattern); |
| } |
| explicit RegexBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| RegexBuilder &operator=(const RegexBuilder &); |
| flatbuffers::Offset<Regex> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<Regex>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<Regex> CreateRegex( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::String> pattern = 0, |
| flatbuffers::Offset<flatbuffers::Vector<int32_t>> groups = 0, |
| flatbuffers::Offset<libtextclassifier2::CompressedBuffer> compressed_pattern = 0) { |
| RegexBuilder builder_(_fbb); |
| builder_.add_compressed_pattern(compressed_pattern); |
| builder_.add_groups(groups); |
| builder_.add_pattern(pattern); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<Regex> CreateRegexDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const char *pattern = nullptr, |
| const std::vector<int32_t> *groups = nullptr, |
| flatbuffers::Offset<libtextclassifier2::CompressedBuffer> compressed_pattern = 0) { |
| return libtextclassifier2::DatetimeModelPattern_::CreateRegex( |
| _fbb, |
| pattern ? _fbb.CreateString(pattern) : 0, |
| groups ? _fbb.CreateVector<int32_t>(*groups) : 0, |
| compressed_pattern); |
| } |
| |
| flatbuffers::Offset<Regex> CreateRegex(flatbuffers::FlatBufferBuilder &_fbb, const RegexT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| } // namespace DatetimeModelPattern_ |
| |
| struct DatetimeModelPatternT : public flatbuffers::NativeTable { |
| typedef DatetimeModelPattern TableType; |
| std::vector<std::unique_ptr<libtextclassifier2::DatetimeModelPattern_::RegexT>> regexes; |
| std::vector<int32_t> locales; |
| float target_classification_score; |
| float priority_score; |
| ModeFlag enabled_modes; |
| DatetimeModelPatternT() |
| : target_classification_score(1.0f), |
| priority_score(0.0f), |
| enabled_modes(ModeFlag_ALL) { |
| } |
| }; |
| |
| struct DatetimeModelPattern FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DatetimeModelPatternT NativeTableType; |
| enum { |
| VT_REGEXES = 4, |
| VT_LOCALES = 6, |
| VT_TARGET_CLASSIFICATION_SCORE = 8, |
| VT_PRIORITY_SCORE = 10, |
| VT_ENABLED_MODES = 12 |
| }; |
| const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>> *regexes() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>> *>(VT_REGEXES); |
| } |
| const flatbuffers::Vector<int32_t> *locales() const { |
| return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_LOCALES); |
| } |
| float target_classification_score() const { |
| return GetField<float>(VT_TARGET_CLASSIFICATION_SCORE, 1.0f); |
| } |
| float priority_score() const { |
| return GetField<float>(VT_PRIORITY_SCORE, 0.0f); |
| } |
| ModeFlag enabled_modes() const { |
| return static_cast<ModeFlag>(GetField<int32_t>(VT_ENABLED_MODES, 7)); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_REGEXES) && |
| verifier.Verify(regexes()) && |
| verifier.VerifyVectorOfTables(regexes()) && |
| VerifyOffset(verifier, VT_LOCALES) && |
| verifier.Verify(locales()) && |
| VerifyField<float>(verifier, VT_TARGET_CLASSIFICATION_SCORE) && |
| VerifyField<float>(verifier, VT_PRIORITY_SCORE) && |
| VerifyField<int32_t>(verifier, VT_ENABLED_MODES) && |
| verifier.EndTable(); |
| } |
| DatetimeModelPatternT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(DatetimeModelPatternT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<DatetimeModelPattern> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelPatternT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct DatetimeModelPatternBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_regexes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>>> regexes) { |
| fbb_.AddOffset(DatetimeModelPattern::VT_REGEXES, regexes); |
| } |
| void add_locales(flatbuffers::Offset<flatbuffers::Vector<int32_t>> locales) { |
| fbb_.AddOffset(DatetimeModelPattern::VT_LOCALES, locales); |
| } |
| void add_target_classification_score(float target_classification_score) { |
| fbb_.AddElement<float>(DatetimeModelPattern::VT_TARGET_CLASSIFICATION_SCORE, target_classification_score, 1.0f); |
| } |
| void add_priority_score(float priority_score) { |
| fbb_.AddElement<float>(DatetimeModelPattern::VT_PRIORITY_SCORE, priority_score, 0.0f); |
| } |
| void add_enabled_modes(ModeFlag enabled_modes) { |
| fbb_.AddElement<int32_t>(DatetimeModelPattern::VT_ENABLED_MODES, static_cast<int32_t>(enabled_modes), 7); |
| } |
| explicit DatetimeModelPatternBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DatetimeModelPatternBuilder &operator=(const DatetimeModelPatternBuilder &); |
| flatbuffers::Offset<DatetimeModelPattern> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DatetimeModelPattern>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DatetimeModelPattern> CreateDatetimeModelPattern( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>>> regexes = 0, |
| flatbuffers::Offset<flatbuffers::Vector<int32_t>> locales = 0, |
| float target_classification_score = 1.0f, |
| float priority_score = 0.0f, |
| ModeFlag enabled_modes = ModeFlag_ALL) { |
| DatetimeModelPatternBuilder builder_(_fbb); |
| builder_.add_enabled_modes(enabled_modes); |
| builder_.add_priority_score(priority_score); |
| builder_.add_target_classification_score(target_classification_score); |
| builder_.add_locales(locales); |
| builder_.add_regexes(regexes); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelPattern> CreateDatetimeModelPatternDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>> *regexes = nullptr, |
| const std::vector<int32_t> *locales = nullptr, |
| float target_classification_score = 1.0f, |
| float priority_score = 0.0f, |
| ModeFlag enabled_modes = ModeFlag_ALL) { |
| return libtextclassifier2::CreateDatetimeModelPattern( |
| _fbb, |
| regexes ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>>(*regexes) : 0, |
| locales ? _fbb.CreateVector<int32_t>(*locales) : 0, |
| target_classification_score, |
| priority_score, |
| enabled_modes); |
| } |
| |
| flatbuffers::Offset<DatetimeModelPattern> CreateDatetimeModelPattern(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelPatternT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct DatetimeModelExtractorT : public flatbuffers::NativeTable { |
| typedef DatetimeModelExtractor TableType; |
| DatetimeExtractorType extractor; |
| std::string pattern; |
| std::vector<int32_t> locales; |
| std::unique_ptr<CompressedBufferT> compressed_pattern; |
| DatetimeModelExtractorT() |
| : extractor(DatetimeExtractorType_UNKNOWN_DATETIME_EXTRACTOR_TYPE) { |
| } |
| }; |
| |
| struct DatetimeModelExtractor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DatetimeModelExtractorT NativeTableType; |
| enum { |
| VT_EXTRACTOR = 4, |
| VT_PATTERN = 6, |
| VT_LOCALES = 8, |
| VT_COMPRESSED_PATTERN = 10 |
| }; |
| DatetimeExtractorType extractor() const { |
| return static_cast<DatetimeExtractorType>(GetField<int32_t>(VT_EXTRACTOR, 0)); |
| } |
| const flatbuffers::String *pattern() const { |
| return GetPointer<const flatbuffers::String *>(VT_PATTERN); |
| } |
| const flatbuffers::Vector<int32_t> *locales() const { |
| return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_LOCALES); |
| } |
| const CompressedBuffer *compressed_pattern() const { |
| return GetPointer<const CompressedBuffer *>(VT_COMPRESSED_PATTERN); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int32_t>(verifier, VT_EXTRACTOR) && |
| VerifyOffset(verifier, VT_PATTERN) && |
| verifier.Verify(pattern()) && |
| VerifyOffset(verifier, VT_LOCALES) && |
| verifier.Verify(locales()) && |
| VerifyOffset(verifier, VT_COMPRESSED_PATTERN) && |
| verifier.VerifyTable(compressed_pattern()) && |
| verifier.EndTable(); |
| } |
| DatetimeModelExtractorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(DatetimeModelExtractorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<DatetimeModelExtractor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelExtractorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct DatetimeModelExtractorBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_extractor(DatetimeExtractorType extractor) { |
| fbb_.AddElement<int32_t>(DatetimeModelExtractor::VT_EXTRACTOR, static_cast<int32_t>(extractor), 0); |
| } |
| void add_pattern(flatbuffers::Offset<flatbuffers::String> pattern) { |
| fbb_.AddOffset(DatetimeModelExtractor::VT_PATTERN, pattern); |
| } |
| void add_locales(flatbuffers::Offset<flatbuffers::Vector<int32_t>> locales) { |
| fbb_.AddOffset(DatetimeModelExtractor::VT_LOCALES, locales); |
| } |
| void add_compressed_pattern(flatbuffers::Offset<CompressedBuffer> compressed_pattern) { |
| fbb_.AddOffset(DatetimeModelExtractor::VT_COMPRESSED_PATTERN, compressed_pattern); |
| } |
| explicit DatetimeModelExtractorBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DatetimeModelExtractorBuilder &operator=(const DatetimeModelExtractorBuilder &); |
| flatbuffers::Offset<DatetimeModelExtractor> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DatetimeModelExtractor>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DatetimeModelExtractor> CreateDatetimeModelExtractor( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| DatetimeExtractorType extractor = DatetimeExtractorType_UNKNOWN_DATETIME_EXTRACTOR_TYPE, |
| flatbuffers::Offset<flatbuffers::String> pattern = 0, |
| flatbuffers::Offset<flatbuffers::Vector<int32_t>> locales = 0, |
| flatbuffers::Offset<CompressedBuffer> compressed_pattern = 0) { |
| DatetimeModelExtractorBuilder builder_(_fbb); |
| builder_.add_compressed_pattern(compressed_pattern); |
| builder_.add_locales(locales); |
| builder_.add_pattern(pattern); |
| builder_.add_extractor(extractor); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelExtractor> CreateDatetimeModelExtractorDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| DatetimeExtractorType extractor = DatetimeExtractorType_UNKNOWN_DATETIME_EXTRACTOR_TYPE, |
| const char *pattern = nullptr, |
| const std::vector<int32_t> *locales = nullptr, |
| flatbuffers::Offset<CompressedBuffer> compressed_pattern = 0) { |
| return libtextclassifier2::CreateDatetimeModelExtractor( |
| _fbb, |
| extractor, |
| pattern ? _fbb.CreateString(pattern) : 0, |
| locales ? _fbb.CreateVector<int32_t>(*locales) : 0, |
| compressed_pattern); |
| } |
| |
| flatbuffers::Offset<DatetimeModelExtractor> CreateDatetimeModelExtractor(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelExtractorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct DatetimeModelT : public flatbuffers::NativeTable { |
| typedef DatetimeModel TableType; |
| std::vector<std::string> locales; |
| std::vector<std::unique_ptr<DatetimeModelPatternT>> patterns; |
| std::vector<std::unique_ptr<DatetimeModelExtractorT>> extractors; |
| bool use_extractors_for_locating; |
| std::vector<int32_t> default_locales; |
| DatetimeModelT() |
| : use_extractors_for_locating(true) { |
| } |
| }; |
| |
| struct DatetimeModel FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DatetimeModelT NativeTableType; |
| enum { |
| VT_LOCALES = 4, |
| VT_PATTERNS = 6, |
| VT_EXTRACTORS = 8, |
| VT_USE_EXTRACTORS_FOR_LOCATING = 10, |
| VT_DEFAULT_LOCALES = 12 |
| }; |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *locales() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_LOCALES); |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<DatetimeModelPattern>> *patterns() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<DatetimeModelPattern>> *>(VT_PATTERNS); |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<DatetimeModelExtractor>> *extractors() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<DatetimeModelExtractor>> *>(VT_EXTRACTORS); |
| } |
| bool use_extractors_for_locating() const { |
| return GetField<uint8_t>(VT_USE_EXTRACTORS_FOR_LOCATING, 1) != 0; |
| } |
| const flatbuffers::Vector<int32_t> *default_locales() const { |
| return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DEFAULT_LOCALES); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_LOCALES) && |
| verifier.Verify(locales()) && |
| verifier.VerifyVectorOfStrings(locales()) && |
| VerifyOffset(verifier, VT_PATTERNS) && |
| verifier.Verify(patterns()) && |
| verifier.VerifyVectorOfTables(patterns()) && |
| VerifyOffset(verifier, VT_EXTRACTORS) && |
| verifier.Verify(extractors()) && |
| verifier.VerifyVectorOfTables(extractors()) && |
| VerifyField<uint8_t>(verifier, VT_USE_EXTRACTORS_FOR_LOCATING) && |
| VerifyOffset(verifier, VT_DEFAULT_LOCALES) && |
| verifier.Verify(default_locales()) && |
| verifier.EndTable(); |
| } |
| DatetimeModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(DatetimeModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<DatetimeModel> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct DatetimeModelBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_locales(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> locales) { |
| fbb_.AddOffset(DatetimeModel::VT_LOCALES, locales); |
| } |
| void add_patterns(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DatetimeModelPattern>>> patterns) { |
| fbb_.AddOffset(DatetimeModel::VT_PATTERNS, patterns); |
| } |
| void add_extractors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DatetimeModelExtractor>>> extractors) { |
| fbb_.AddOffset(DatetimeModel::VT_EXTRACTORS, extractors); |
| } |
| void add_use_extractors_for_locating(bool use_extractors_for_locating) { |
| fbb_.AddElement<uint8_t>(DatetimeModel::VT_USE_EXTRACTORS_FOR_LOCATING, static_cast<uint8_t>(use_extractors_for_locating), 1); |
| } |
| void add_default_locales(flatbuffers::Offset<flatbuffers::Vector<int32_t>> default_locales) { |
| fbb_.AddOffset(DatetimeModel::VT_DEFAULT_LOCALES, default_locales); |
| } |
| explicit DatetimeModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DatetimeModelBuilder &operator=(const DatetimeModelBuilder &); |
| flatbuffers::Offset<DatetimeModel> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DatetimeModel>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DatetimeModel> CreateDatetimeModel( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> locales = 0, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DatetimeModelPattern>>> patterns = 0, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DatetimeModelExtractor>>> extractors = 0, |
| bool use_extractors_for_locating = true, |
| flatbuffers::Offset<flatbuffers::Vector<int32_t>> default_locales = 0) { |
| DatetimeModelBuilder builder_(_fbb); |
| builder_.add_default_locales(default_locales); |
| builder_.add_extractors(extractors); |
| builder_.add_patterns(patterns); |
| builder_.add_locales(locales); |
| builder_.add_use_extractors_for_locating(use_extractors_for_locating); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModel> CreateDatetimeModelDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *locales = nullptr, |
| const std::vector<flatbuffers::Offset<DatetimeModelPattern>> *patterns = nullptr, |
| const std::vector<flatbuffers::Offset<DatetimeModelExtractor>> *extractors = nullptr, |
| bool use_extractors_for_locating = true, |
| const std::vector<int32_t> *default_locales = nullptr) { |
| return libtextclassifier2::CreateDatetimeModel( |
| _fbb, |
| locales ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*locales) : 0, |
| patterns ? _fbb.CreateVector<flatbuffers::Offset<DatetimeModelPattern>>(*patterns) : 0, |
| extractors ? _fbb.CreateVector<flatbuffers::Offset<DatetimeModelExtractor>>(*extractors) : 0, |
| use_extractors_for_locating, |
| default_locales ? _fbb.CreateVector<int32_t>(*default_locales) : 0); |
| } |
| |
| flatbuffers::Offset<DatetimeModel> CreateDatetimeModel(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| namespace DatetimeModelLibrary_ { |
| |
| struct ItemT : public flatbuffers::NativeTable { |
| typedef Item TableType; |
| std::string key; |
| std::unique_ptr<libtextclassifier2::DatetimeModelT> value; |
| ItemT() { |
| } |
| }; |
| |
| struct Item FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef ItemT NativeTableType; |
| enum { |
| VT_KEY = 4, |
| VT_VALUE = 6 |
| }; |
| const flatbuffers::String *key() const { |
| return GetPointer<const flatbuffers::String *>(VT_KEY); |
| } |
| const libtextclassifier2::DatetimeModel *value() const { |
| return GetPointer<const libtextclassifier2::DatetimeModel *>(VT_VALUE); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_KEY) && |
| verifier.Verify(key()) && |
| VerifyOffset(verifier, VT_VALUE) && |
| verifier.VerifyTable(value()) && |
| verifier.EndTable(); |
| } |
| ItemT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(ItemT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<Item> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ItemT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct ItemBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_key(flatbuffers::Offset<flatbuffers::String> key) { |
| fbb_.AddOffset(Item::VT_KEY, key); |
| } |
| void add_value(flatbuffers::Offset<libtextclassifier2::DatetimeModel> value) { |
| fbb_.AddOffset(Item::VT_VALUE, value); |
| } |
| explicit ItemBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ItemBuilder &operator=(const ItemBuilder &); |
| flatbuffers::Offset<Item> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<Item>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<Item> CreateItem( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::String> key = 0, |
| flatbuffers::Offset<libtextclassifier2::DatetimeModel> value = 0) { |
| ItemBuilder builder_(_fbb); |
| builder_.add_value(value); |
| builder_.add_key(key); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<Item> CreateItemDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const char *key = nullptr, |
| flatbuffers::Offset<libtextclassifier2::DatetimeModel> value = 0) { |
| return libtextclassifier2::DatetimeModelLibrary_::CreateItem( |
| _fbb, |
| key ? _fbb.CreateString(key) : 0, |
| value); |
| } |
| |
| flatbuffers::Offset<Item> CreateItem(flatbuffers::FlatBufferBuilder &_fbb, const ItemT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| } // namespace DatetimeModelLibrary_ |
| |
| struct DatetimeModelLibraryT : public flatbuffers::NativeTable { |
| typedef DatetimeModelLibrary TableType; |
| std::vector<std::unique_ptr<libtextclassifier2::DatetimeModelLibrary_::ItemT>> models; |
| DatetimeModelLibraryT() { |
| } |
| }; |
| |
| struct DatetimeModelLibrary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef DatetimeModelLibraryT NativeTableType; |
| enum { |
| VT_MODELS = 4 |
| }; |
| const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>> *models() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>> *>(VT_MODELS); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_MODELS) && |
| verifier.Verify(models()) && |
| verifier.VerifyVectorOfTables(models()) && |
| verifier.EndTable(); |
| } |
| DatetimeModelLibraryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(DatetimeModelLibraryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<DatetimeModelLibrary> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelLibraryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct DatetimeModelLibraryBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_models(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>>> models) { |
| fbb_.AddOffset(DatetimeModelLibrary::VT_MODELS, models); |
| } |
| explicit DatetimeModelLibraryBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| DatetimeModelLibraryBuilder &operator=(const DatetimeModelLibraryBuilder &); |
| flatbuffers::Offset<DatetimeModelLibrary> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<DatetimeModelLibrary>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<DatetimeModelLibrary> CreateDatetimeModelLibrary( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>>> models = 0) { |
| DatetimeModelLibraryBuilder builder_(_fbb); |
| builder_.add_models(models); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelLibrary> CreateDatetimeModelLibraryDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>> *models = nullptr) { |
| return libtextclassifier2::CreateDatetimeModelLibrary( |
| _fbb, |
| models ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>>(*models) : 0); |
| } |
| |
| flatbuffers::Offset<DatetimeModelLibrary> CreateDatetimeModelLibrary(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelLibraryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct ModelTriggeringOptionsT : public flatbuffers::NativeTable { |
| typedef ModelTriggeringOptions TableType; |
| float min_annotate_confidence; |
| ModeFlag enabled_modes; |
| ModelTriggeringOptionsT() |
| : min_annotate_confidence(0.0f), |
| enabled_modes(ModeFlag_ALL) { |
| } |
| }; |
| |
| struct ModelTriggeringOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef ModelTriggeringOptionsT NativeTableType; |
| enum { |
| VT_MIN_ANNOTATE_CONFIDENCE = 4, |
| VT_ENABLED_MODES = 6 |
| }; |
| float min_annotate_confidence() const { |
| return GetField<float>(VT_MIN_ANNOTATE_CONFIDENCE, 0.0f); |
| } |
| ModeFlag enabled_modes() const { |
| return static_cast<ModeFlag>(GetField<int32_t>(VT_ENABLED_MODES, 7)); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<float>(verifier, VT_MIN_ANNOTATE_CONFIDENCE) && |
| VerifyField<int32_t>(verifier, VT_ENABLED_MODES) && |
| verifier.EndTable(); |
| } |
| ModelTriggeringOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(ModelTriggeringOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<ModelTriggeringOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelTriggeringOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct ModelTriggeringOptionsBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_min_annotate_confidence(float min_annotate_confidence) { |
| fbb_.AddElement<float>(ModelTriggeringOptions::VT_MIN_ANNOTATE_CONFIDENCE, min_annotate_confidence, 0.0f); |
| } |
| void add_enabled_modes(ModeFlag enabled_modes) { |
| fbb_.AddElement<int32_t>(ModelTriggeringOptions::VT_ENABLED_MODES, static_cast<int32_t>(enabled_modes), 7); |
| } |
| explicit ModelTriggeringOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ModelTriggeringOptionsBuilder &operator=(const ModelTriggeringOptionsBuilder &); |
| flatbuffers::Offset<ModelTriggeringOptions> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<ModelTriggeringOptions>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<ModelTriggeringOptions> CreateModelTriggeringOptions( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| float min_annotate_confidence = 0.0f, |
| ModeFlag enabled_modes = ModeFlag_ALL) { |
| ModelTriggeringOptionsBuilder builder_(_fbb); |
| builder_.add_enabled_modes(enabled_modes); |
| builder_.add_min_annotate_confidence(min_annotate_confidence); |
| return builder_.Finish(); |
| } |
| |
| flatbuffers::Offset<ModelTriggeringOptions> CreateModelTriggeringOptions(flatbuffers::FlatBufferBuilder &_fbb, const ModelTriggeringOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct OutputOptionsT : public flatbuffers::NativeTable { |
| typedef OutputOptions TableType; |
| std::vector<std::string> filtered_collections_annotation; |
| std::vector<std::string> filtered_collections_classification; |
| std::vector<std::string> filtered_collections_selection; |
| OutputOptionsT() { |
| } |
| }; |
| |
| struct OutputOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef OutputOptionsT NativeTableType; |
| enum { |
| VT_FILTERED_COLLECTIONS_ANNOTATION = 4, |
| VT_FILTERED_COLLECTIONS_CLASSIFICATION = 6, |
| VT_FILTERED_COLLECTIONS_SELECTION = 8 |
| }; |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *filtered_collections_annotation() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_FILTERED_COLLECTIONS_ANNOTATION); |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *filtered_collections_classification() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_FILTERED_COLLECTIONS_CLASSIFICATION); |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *filtered_collections_selection() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_FILTERED_COLLECTIONS_SELECTION); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_FILTERED_COLLECTIONS_ANNOTATION) && |
| verifier.Verify(filtered_collections_annotation()) && |
| verifier.VerifyVectorOfStrings(filtered_collections_annotation()) && |
| VerifyOffset(verifier, VT_FILTERED_COLLECTIONS_CLASSIFICATION) && |
| verifier.Verify(filtered_collections_classification()) && |
| verifier.VerifyVectorOfStrings(filtered_collections_classification()) && |
| VerifyOffset(verifier, VT_FILTERED_COLLECTIONS_SELECTION) && |
| verifier.Verify(filtered_collections_selection()) && |
| verifier.VerifyVectorOfStrings(filtered_collections_selection()) && |
| verifier.EndTable(); |
| } |
| OutputOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(OutputOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<OutputOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OutputOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct OutputOptionsBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_filtered_collections_annotation(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> filtered_collections_annotation) { |
| fbb_.AddOffset(OutputOptions::VT_FILTERED_COLLECTIONS_ANNOTATION, filtered_collections_annotation); |
| } |
| void add_filtered_collections_classification(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> filtered_collections_classification) { |
| fbb_.AddOffset(OutputOptions::VT_FILTERED_COLLECTIONS_CLASSIFICATION, filtered_collections_classification); |
| } |
| void add_filtered_collections_selection(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> filtered_collections_selection) { |
| fbb_.AddOffset(OutputOptions::VT_FILTERED_COLLECTIONS_SELECTION, filtered_collections_selection); |
| } |
| explicit OutputOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| OutputOptionsBuilder &operator=(const OutputOptionsBuilder &); |
| flatbuffers::Offset<OutputOptions> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<OutputOptions>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<OutputOptions> CreateOutputOptions( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> filtered_collections_annotation = 0, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> filtered_collections_classification = 0, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> filtered_collections_selection = 0) { |
| OutputOptionsBuilder builder_(_fbb); |
| builder_.add_filtered_collections_selection(filtered_collections_selection); |
| builder_.add_filtered_collections_classification(filtered_collections_classification); |
| builder_.add_filtered_collections_annotation(filtered_collections_annotation); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<OutputOptions> CreateOutputOptionsDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *filtered_collections_annotation = nullptr, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *filtered_collections_classification = nullptr, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *filtered_collections_selection = nullptr) { |
| return libtextclassifier2::CreateOutputOptions( |
| _fbb, |
| filtered_collections_annotation ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*filtered_collections_annotation) : 0, |
| filtered_collections_classification ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*filtered_collections_classification) : 0, |
| filtered_collections_selection ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*filtered_collections_selection) : 0); |
| } |
| |
| flatbuffers::Offset<OutputOptions> CreateOutputOptions(flatbuffers::FlatBufferBuilder &_fbb, const OutputOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct ModelT : public flatbuffers::NativeTable { |
| typedef Model TableType; |
| std::string locales; |
| int32_t version; |
| std::string name; |
| std::unique_ptr<FeatureProcessorOptionsT> selection_feature_options; |
| std::unique_ptr<FeatureProcessorOptionsT> classification_feature_options; |
| std::vector<uint8_t> selection_model; |
| std::vector<uint8_t> classification_model; |
| std::vector<uint8_t> embedding_model; |
| std::unique_ptr<SelectionModelOptionsT> selection_options; |
| std::unique_ptr<ClassificationModelOptionsT> classification_options; |
| std::unique_ptr<RegexModelT> regex_model; |
| std::unique_ptr<DatetimeModelT> datetime_model; |
| std::unique_ptr<ModelTriggeringOptionsT> triggering_options; |
| ModeFlag enabled_modes; |
| bool snap_whitespace_selections; |
| std::unique_ptr<OutputOptionsT> output_options; |
| ModelT() |
| : version(0), |
| enabled_modes(ModeFlag_ALL), |
| snap_whitespace_selections(true) { |
| } |
| }; |
| |
| struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef ModelT NativeTableType; |
| enum { |
| VT_LOCALES = 4, |
| VT_VERSION = 6, |
| VT_NAME = 8, |
| VT_SELECTION_FEATURE_OPTIONS = 10, |
| VT_CLASSIFICATION_FEATURE_OPTIONS = 12, |
| VT_SELECTION_MODEL = 14, |
| VT_CLASSIFICATION_MODEL = 16, |
| VT_EMBEDDING_MODEL = 18, |
| VT_SELECTION_OPTIONS = 20, |
| VT_CLASSIFICATION_OPTIONS = 22, |
| VT_REGEX_MODEL = 24, |
| VT_DATETIME_MODEL = 26, |
| VT_TRIGGERING_OPTIONS = 28, |
| VT_ENABLED_MODES = 30, |
| VT_SNAP_WHITESPACE_SELECTIONS = 32, |
| VT_OUTPUT_OPTIONS = 34 |
| }; |
| const flatbuffers::String *locales() const { |
| return GetPointer<const flatbuffers::String *>(VT_LOCALES); |
| } |
| int32_t version() const { |
| return GetField<int32_t>(VT_VERSION, 0); |
| } |
| const flatbuffers::String *name() const { |
| return GetPointer<const flatbuffers::String *>(VT_NAME); |
| } |
| const FeatureProcessorOptions *selection_feature_options() const { |
| return GetPointer<const FeatureProcessorOptions *>(VT_SELECTION_FEATURE_OPTIONS); |
| } |
| const FeatureProcessorOptions *classification_feature_options() const { |
| return GetPointer<const FeatureProcessorOptions *>(VT_CLASSIFICATION_FEATURE_OPTIONS); |
| } |
| const flatbuffers::Vector<uint8_t> *selection_model() const { |
| return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SELECTION_MODEL); |
| } |
| const flatbuffers::Vector<uint8_t> *classification_model() const { |
| return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CLASSIFICATION_MODEL); |
| } |
| const flatbuffers::Vector<uint8_t> *embedding_model() const { |
| return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EMBEDDING_MODEL); |
| } |
| const SelectionModelOptions *selection_options() const { |
| return GetPointer<const SelectionModelOptions *>(VT_SELECTION_OPTIONS); |
| } |
| const ClassificationModelOptions *classification_options() const { |
| return GetPointer<const ClassificationModelOptions *>(VT_CLASSIFICATION_OPTIONS); |
| } |
| const RegexModel *regex_model() const { |
| return GetPointer<const RegexModel *>(VT_REGEX_MODEL); |
| } |
| const DatetimeModel *datetime_model() const { |
| return GetPointer<const DatetimeModel *>(VT_DATETIME_MODEL); |
| } |
| const ModelTriggeringOptions *triggering_options() const { |
| return GetPointer<const ModelTriggeringOptions *>(VT_TRIGGERING_OPTIONS); |
| } |
| ModeFlag enabled_modes() const { |
| return static_cast<ModeFlag>(GetField<int32_t>(VT_ENABLED_MODES, 7)); |
| } |
| bool snap_whitespace_selections() const { |
| return GetField<uint8_t>(VT_SNAP_WHITESPACE_SELECTIONS, 1) != 0; |
| } |
| const OutputOptions *output_options() const { |
| return GetPointer<const OutputOptions *>(VT_OUTPUT_OPTIONS); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_LOCALES) && |
| verifier.Verify(locales()) && |
| VerifyField<int32_t>(verifier, VT_VERSION) && |
| VerifyOffset(verifier, VT_NAME) && |
| verifier.Verify(name()) && |
| VerifyOffset(verifier, VT_SELECTION_FEATURE_OPTIONS) && |
| verifier.VerifyTable(selection_feature_options()) && |
| VerifyOffset(verifier, VT_CLASSIFICATION_FEATURE_OPTIONS) && |
| verifier.VerifyTable(classification_feature_options()) && |
| VerifyOffset(verifier, VT_SELECTION_MODEL) && |
| verifier.Verify(selection_model()) && |
| VerifyOffset(verifier, VT_CLASSIFICATION_MODEL) && |
| verifier.Verify(classification_model()) && |
| VerifyOffset(verifier, VT_EMBEDDING_MODEL) && |
| verifier.Verify(embedding_model()) && |
| VerifyOffset(verifier, VT_SELECTION_OPTIONS) && |
| verifier.VerifyTable(selection_options()) && |
| VerifyOffset(verifier, VT_CLASSIFICATION_OPTIONS) && |
| verifier.VerifyTable(classification_options()) && |
| VerifyOffset(verifier, VT_REGEX_MODEL) && |
| verifier.VerifyTable(regex_model()) && |
| VerifyOffset(verifier, VT_DATETIME_MODEL) && |
| verifier.VerifyTable(datetime_model()) && |
| VerifyOffset(verifier, VT_TRIGGERING_OPTIONS) && |
| verifier.VerifyTable(triggering_options()) && |
| VerifyField<int32_t>(verifier, VT_ENABLED_MODES) && |
| VerifyField<uint8_t>(verifier, VT_SNAP_WHITESPACE_SELECTIONS) && |
| VerifyOffset(verifier, VT_OUTPUT_OPTIONS) && |
| verifier.VerifyTable(output_options()) && |
| verifier.EndTable(); |
| } |
| ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct ModelBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_locales(flatbuffers::Offset<flatbuffers::String> locales) { |
| fbb_.AddOffset(Model::VT_LOCALES, locales); |
| } |
| void add_version(int32_t version) { |
| fbb_.AddElement<int32_t>(Model::VT_VERSION, version, 0); |
| } |
| void add_name(flatbuffers::Offset<flatbuffers::String> name) { |
| fbb_.AddOffset(Model::VT_NAME, name); |
| } |
| void add_selection_feature_options(flatbuffers::Offset<FeatureProcessorOptions> selection_feature_options) { |
| fbb_.AddOffset(Model::VT_SELECTION_FEATURE_OPTIONS, selection_feature_options); |
| } |
| void add_classification_feature_options(flatbuffers::Offset<FeatureProcessorOptions> classification_feature_options) { |
| fbb_.AddOffset(Model::VT_CLASSIFICATION_FEATURE_OPTIONS, classification_feature_options); |
| } |
| void add_selection_model(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> selection_model) { |
| fbb_.AddOffset(Model::VT_SELECTION_MODEL, selection_model); |
| } |
| void add_classification_model(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> classification_model) { |
| fbb_.AddOffset(Model::VT_CLASSIFICATION_MODEL, classification_model); |
| } |
| void add_embedding_model(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> embedding_model) { |
| fbb_.AddOffset(Model::VT_EMBEDDING_MODEL, embedding_model); |
| } |
| void add_selection_options(flatbuffers::Offset<SelectionModelOptions> selection_options) { |
| fbb_.AddOffset(Model::VT_SELECTION_OPTIONS, selection_options); |
| } |
| void add_classification_options(flatbuffers::Offset<ClassificationModelOptions> classification_options) { |
| fbb_.AddOffset(Model::VT_CLASSIFICATION_OPTIONS, classification_options); |
| } |
| void add_regex_model(flatbuffers::Offset<RegexModel> regex_model) { |
| fbb_.AddOffset(Model::VT_REGEX_MODEL, regex_model); |
| } |
| void add_datetime_model(flatbuffers::Offset<DatetimeModel> datetime_model) { |
| fbb_.AddOffset(Model::VT_DATETIME_MODEL, datetime_model); |
| } |
| void add_triggering_options(flatbuffers::Offset<ModelTriggeringOptions> triggering_options) { |
| fbb_.AddOffset(Model::VT_TRIGGERING_OPTIONS, triggering_options); |
| } |
| void add_enabled_modes(ModeFlag enabled_modes) { |
| fbb_.AddElement<int32_t>(Model::VT_ENABLED_MODES, static_cast<int32_t>(enabled_modes), 7); |
| } |
| void add_snap_whitespace_selections(bool snap_whitespace_selections) { |
| fbb_.AddElement<uint8_t>(Model::VT_SNAP_WHITESPACE_SELECTIONS, static_cast<uint8_t>(snap_whitespace_selections), 1); |
| } |
| void add_output_options(flatbuffers::Offset<OutputOptions> output_options) { |
| fbb_.AddOffset(Model::VT_OUTPUT_OPTIONS, output_options); |
| } |
| explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ModelBuilder &operator=(const ModelBuilder &); |
| flatbuffers::Offset<Model> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<Model>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<Model> CreateModel( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::String> locales = 0, |
| int32_t version = 0, |
| flatbuffers::Offset<flatbuffers::String> name = 0, |
| flatbuffers::Offset<FeatureProcessorOptions> selection_feature_options = 0, |
| flatbuffers::Offset<FeatureProcessorOptions> classification_feature_options = 0, |
| flatbuffers::Offset<flatbuffers::Vector<uint8_t>> selection_model = 0, |
| flatbuffers::Offset<flatbuffers::Vector<uint8_t>> classification_model = 0, |
| flatbuffers::Offset<flatbuffers::Vector<uint8_t>> embedding_model = 0, |
| flatbuffers::Offset<SelectionModelOptions> selection_options = 0, |
| flatbuffers::Offset<ClassificationModelOptions> classification_options = 0, |
| flatbuffers::Offset<RegexModel> regex_model = 0, |
| flatbuffers::Offset<DatetimeModel> datetime_model = 0, |
| flatbuffers::Offset<ModelTriggeringOptions> triggering_options = 0, |
| ModeFlag enabled_modes = ModeFlag_ALL, |
| bool snap_whitespace_selections = true, |
| flatbuffers::Offset<OutputOptions> output_options = 0) { |
| ModelBuilder builder_(_fbb); |
| builder_.add_output_options(output_options); |
| builder_.add_enabled_modes(enabled_modes); |
| builder_.add_triggering_options(triggering_options); |
| builder_.add_datetime_model(datetime_model); |
| builder_.add_regex_model(regex_model); |
| builder_.add_classification_options(classification_options); |
| builder_.add_selection_options(selection_options); |
| builder_.add_embedding_model(embedding_model); |
| builder_.add_classification_model(classification_model); |
| builder_.add_selection_model(selection_model); |
| builder_.add_classification_feature_options(classification_feature_options); |
| builder_.add_selection_feature_options(selection_feature_options); |
| builder_.add_name(name); |
| builder_.add_version(version); |
| builder_.add_locales(locales); |
| builder_.add_snap_whitespace_selections(snap_whitespace_selections); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<Model> CreateModelDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const char *locales = nullptr, |
| int32_t version = 0, |
| const char *name = nullptr, |
| flatbuffers::Offset<FeatureProcessorOptions> selection_feature_options = 0, |
| flatbuffers::Offset<FeatureProcessorOptions> classification_feature_options = 0, |
| const std::vector<uint8_t> *selection_model = nullptr, |
| const std::vector<uint8_t> *classification_model = nullptr, |
| const std::vector<uint8_t> *embedding_model = nullptr, |
| flatbuffers::Offset<SelectionModelOptions> selection_options = 0, |
| flatbuffers::Offset<ClassificationModelOptions> classification_options = 0, |
| flatbuffers::Offset<RegexModel> regex_model = 0, |
| flatbuffers::Offset<DatetimeModel> datetime_model = 0, |
| flatbuffers::Offset<ModelTriggeringOptions> triggering_options = 0, |
| ModeFlag enabled_modes = ModeFlag_ALL, |
| bool snap_whitespace_selections = true, |
| flatbuffers::Offset<OutputOptions> output_options = 0) { |
| return libtextclassifier2::CreateModel( |
| _fbb, |
| locales ? _fbb.CreateString(locales) : 0, |
| version, |
| name ? _fbb.CreateString(name) : 0, |
| selection_feature_options, |
| classification_feature_options, |
| selection_model ? _fbb.CreateVector<uint8_t>(*selection_model) : 0, |
| classification_model ? _fbb.CreateVector<uint8_t>(*classification_model) : 0, |
| embedding_model ? _fbb.CreateVector<uint8_t>(*embedding_model) : 0, |
| selection_options, |
| classification_options, |
| regex_model, |
| datetime_model, |
| triggering_options, |
| enabled_modes, |
| snap_whitespace_selections, |
| output_options); |
| } |
| |
| flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct TokenizationCodepointRangeT : public flatbuffers::NativeTable { |
| typedef TokenizationCodepointRange TableType; |
| int32_t start; |
| int32_t end; |
| libtextclassifier2::TokenizationCodepointRange_::Role role; |
| int32_t script_id; |
| TokenizationCodepointRangeT() |
| : start(0), |
| end(0), |
| role(libtextclassifier2::TokenizationCodepointRange_::Role_DEFAULT_ROLE), |
| script_id(0) { |
| } |
| }; |
| |
| struct TokenizationCodepointRange FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef TokenizationCodepointRangeT NativeTableType; |
| enum { |
| VT_START = 4, |
| VT_END = 6, |
| VT_ROLE = 8, |
| VT_SCRIPT_ID = 10 |
| }; |
| int32_t start() const { |
| return GetField<int32_t>(VT_START, 0); |
| } |
| int32_t end() const { |
| return GetField<int32_t>(VT_END, 0); |
| } |
| libtextclassifier2::TokenizationCodepointRange_::Role role() const { |
| return static_cast<libtextclassifier2::TokenizationCodepointRange_::Role>(GetField<int32_t>(VT_ROLE, 0)); |
| } |
| int32_t script_id() const { |
| return GetField<int32_t>(VT_SCRIPT_ID, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int32_t>(verifier, VT_START) && |
| VerifyField<int32_t>(verifier, VT_END) && |
| VerifyField<int32_t>(verifier, VT_ROLE) && |
| VerifyField<int32_t>(verifier, VT_SCRIPT_ID) && |
| verifier.EndTable(); |
| } |
| TokenizationCodepointRangeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(TokenizationCodepointRangeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<TokenizationCodepointRange> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TokenizationCodepointRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct TokenizationCodepointRangeBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_start(int32_t start) { |
| fbb_.AddElement<int32_t>(TokenizationCodepointRange::VT_START, start, 0); |
| } |
| void add_end(int32_t end) { |
| fbb_.AddElement<int32_t>(TokenizationCodepointRange::VT_END, end, 0); |
| } |
| void add_role(libtextclassifier2::TokenizationCodepointRange_::Role role) { |
| fbb_.AddElement<int32_t>(TokenizationCodepointRange::VT_ROLE, static_cast<int32_t>(role), 0); |
| } |
| void add_script_id(int32_t script_id) { |
| fbb_.AddElement<int32_t>(TokenizationCodepointRange::VT_SCRIPT_ID, script_id, 0); |
| } |
| explicit TokenizationCodepointRangeBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| TokenizationCodepointRangeBuilder &operator=(const TokenizationCodepointRangeBuilder &); |
| flatbuffers::Offset<TokenizationCodepointRange> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<TokenizationCodepointRange>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<TokenizationCodepointRange> CreateTokenizationCodepointRange( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| int32_t start = 0, |
| int32_t end = 0, |
| libtextclassifier2::TokenizationCodepointRange_::Role role = libtextclassifier2::TokenizationCodepointRange_::Role_DEFAULT_ROLE, |
| int32_t script_id = 0) { |
| TokenizationCodepointRangeBuilder builder_(_fbb); |
| builder_.add_script_id(script_id); |
| builder_.add_role(role); |
| builder_.add_end(end); |
| builder_.add_start(start); |
| return builder_.Finish(); |
| } |
| |
| flatbuffers::Offset<TokenizationCodepointRange> CreateTokenizationCodepointRange(flatbuffers::FlatBufferBuilder &_fbb, const TokenizationCodepointRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| namespace FeatureProcessorOptions_ { |
| |
| struct CodepointRangeT : public flatbuffers::NativeTable { |
| typedef CodepointRange TableType; |
| int32_t start; |
| int32_t end; |
| CodepointRangeT() |
| : start(0), |
| end(0) { |
| } |
| }; |
| |
| struct CodepointRange FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef CodepointRangeT NativeTableType; |
| enum { |
| VT_START = 4, |
| VT_END = 6 |
| }; |
| int32_t start() const { |
| return GetField<int32_t>(VT_START, 0); |
| } |
| int32_t end() const { |
| return GetField<int32_t>(VT_END, 0); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int32_t>(verifier, VT_START) && |
| VerifyField<int32_t>(verifier, VT_END) && |
| verifier.EndTable(); |
| } |
| CodepointRangeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(CodepointRangeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<CodepointRange> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CodepointRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct CodepointRangeBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_start(int32_t start) { |
| fbb_.AddElement<int32_t>(CodepointRange::VT_START, start, 0); |
| } |
| void add_end(int32_t end) { |
| fbb_.AddElement<int32_t>(CodepointRange::VT_END, end, 0); |
| } |
| explicit CodepointRangeBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| CodepointRangeBuilder &operator=(const CodepointRangeBuilder &); |
| flatbuffers::Offset<CodepointRange> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<CodepointRange>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<CodepointRange> CreateCodepointRange( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| int32_t start = 0, |
| int32_t end = 0) { |
| CodepointRangeBuilder builder_(_fbb); |
| builder_.add_end(end); |
| builder_.add_start(start); |
| return builder_.Finish(); |
| } |
| |
| flatbuffers::Offset<CodepointRange> CreateCodepointRange(flatbuffers::FlatBufferBuilder &_fbb, const CodepointRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct BoundsSensitiveFeaturesT : public flatbuffers::NativeTable { |
| typedef BoundsSensitiveFeatures TableType; |
| bool enabled; |
| int32_t num_tokens_before; |
| int32_t num_tokens_inside_left; |
| int32_t num_tokens_inside_right; |
| int32_t num_tokens_after; |
| bool include_inside_bag; |
| bool include_inside_length; |
| bool score_single_token_spans_as_zero; |
| BoundsSensitiveFeaturesT() |
| : enabled(false), |
| num_tokens_before(0), |
| num_tokens_inside_left(0), |
| num_tokens_inside_right(0), |
| num_tokens_after(0), |
| include_inside_bag(false), |
| include_inside_length(false), |
| score_single_token_spans_as_zero(false) { |
| } |
| }; |
| |
| struct BoundsSensitiveFeatures FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef BoundsSensitiveFeaturesT NativeTableType; |
| enum { |
| VT_ENABLED = 4, |
| VT_NUM_TOKENS_BEFORE = 6, |
| VT_NUM_TOKENS_INSIDE_LEFT = 8, |
| VT_NUM_TOKENS_INSIDE_RIGHT = 10, |
| VT_NUM_TOKENS_AFTER = 12, |
| VT_INCLUDE_INSIDE_BAG = 14, |
| VT_INCLUDE_INSIDE_LENGTH = 16, |
| VT_SCORE_SINGLE_TOKEN_SPANS_AS_ZERO = 18 |
| }; |
| bool enabled() const { |
| return GetField<uint8_t>(VT_ENABLED, 0) != 0; |
| } |
| int32_t num_tokens_before() const { |
| return GetField<int32_t>(VT_NUM_TOKENS_BEFORE, 0); |
| } |
| int32_t num_tokens_inside_left() const { |
| return GetField<int32_t>(VT_NUM_TOKENS_INSIDE_LEFT, 0); |
| } |
| int32_t num_tokens_inside_right() const { |
| return GetField<int32_t>(VT_NUM_TOKENS_INSIDE_RIGHT, 0); |
| } |
| int32_t num_tokens_after() const { |
| return GetField<int32_t>(VT_NUM_TOKENS_AFTER, 0); |
| } |
| bool include_inside_bag() const { |
| return GetField<uint8_t>(VT_INCLUDE_INSIDE_BAG, 0) != 0; |
| } |
| bool include_inside_length() const { |
| return GetField<uint8_t>(VT_INCLUDE_INSIDE_LENGTH, 0) != 0; |
| } |
| bool score_single_token_spans_as_zero() const { |
| return GetField<uint8_t>(VT_SCORE_SINGLE_TOKEN_SPANS_AS_ZERO, 0) != 0; |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint8_t>(verifier, VT_ENABLED) && |
| VerifyField<int32_t>(verifier, VT_NUM_TOKENS_BEFORE) && |
| VerifyField<int32_t>(verifier, VT_NUM_TOKENS_INSIDE_LEFT) && |
| VerifyField<int32_t>(verifier, VT_NUM_TOKENS_INSIDE_RIGHT) && |
| VerifyField<int32_t>(verifier, VT_NUM_TOKENS_AFTER) && |
| VerifyField<uint8_t>(verifier, VT_INCLUDE_INSIDE_BAG) && |
| VerifyField<uint8_t>(verifier, VT_INCLUDE_INSIDE_LENGTH) && |
| VerifyField<uint8_t>(verifier, VT_SCORE_SINGLE_TOKEN_SPANS_AS_ZERO) && |
| verifier.EndTable(); |
| } |
| BoundsSensitiveFeaturesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(BoundsSensitiveFeaturesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<BoundsSensitiveFeatures> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BoundsSensitiveFeaturesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct BoundsSensitiveFeaturesBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_enabled(bool enabled) { |
| fbb_.AddElement<uint8_t>(BoundsSensitiveFeatures::VT_ENABLED, static_cast<uint8_t>(enabled), 0); |
| } |
| void add_num_tokens_before(int32_t num_tokens_before) { |
| fbb_.AddElement<int32_t>(BoundsSensitiveFeatures::VT_NUM_TOKENS_BEFORE, num_tokens_before, 0); |
| } |
| void add_num_tokens_inside_left(int32_t num_tokens_inside_left) { |
| fbb_.AddElement<int32_t>(BoundsSensitiveFeatures::VT_NUM_TOKENS_INSIDE_LEFT, num_tokens_inside_left, 0); |
| } |
| void add_num_tokens_inside_right(int32_t num_tokens_inside_right) { |
| fbb_.AddElement<int32_t>(BoundsSensitiveFeatures::VT_NUM_TOKENS_INSIDE_RIGHT, num_tokens_inside_right, 0); |
| } |
| void add_num_tokens_after(int32_t num_tokens_after) { |
| fbb_.AddElement<int32_t>(BoundsSensitiveFeatures::VT_NUM_TOKENS_AFTER, num_tokens_after, 0); |
| } |
| void add_include_inside_bag(bool include_inside_bag) { |
| fbb_.AddElement<uint8_t>(BoundsSensitiveFeatures::VT_INCLUDE_INSIDE_BAG, static_cast<uint8_t>(include_inside_bag), 0); |
| } |
| void add_include_inside_length(bool include_inside_length) { |
| fbb_.AddElement<uint8_t>(BoundsSensitiveFeatures::VT_INCLUDE_INSIDE_LENGTH, static_cast<uint8_t>(include_inside_length), 0); |
| } |
| void add_score_single_token_spans_as_zero(bool score_single_token_spans_as_zero) { |
| fbb_.AddElement<uint8_t>(BoundsSensitiveFeatures::VT_SCORE_SINGLE_TOKEN_SPANS_AS_ZERO, static_cast<uint8_t>(score_single_token_spans_as_zero), 0); |
| } |
| explicit BoundsSensitiveFeaturesBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| BoundsSensitiveFeaturesBuilder &operator=(const BoundsSensitiveFeaturesBuilder &); |
| flatbuffers::Offset<BoundsSensitiveFeatures> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<BoundsSensitiveFeatures>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<BoundsSensitiveFeatures> CreateBoundsSensitiveFeatures( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| bool enabled = false, |
| int32_t num_tokens_before = 0, |
| int32_t num_tokens_inside_left = 0, |
| int32_t num_tokens_inside_right = 0, |
| int32_t num_tokens_after = 0, |
| bool include_inside_bag = false, |
| bool include_inside_length = false, |
| bool score_single_token_spans_as_zero = false) { |
| BoundsSensitiveFeaturesBuilder builder_(_fbb); |
| builder_.add_num_tokens_after(num_tokens_after); |
| builder_.add_num_tokens_inside_right(num_tokens_inside_right); |
| builder_.add_num_tokens_inside_left(num_tokens_inside_left); |
| builder_.add_num_tokens_before(num_tokens_before); |
| builder_.add_score_single_token_spans_as_zero(score_single_token_spans_as_zero); |
| builder_.add_include_inside_length(include_inside_length); |
| builder_.add_include_inside_bag(include_inside_bag); |
| builder_.add_enabled(enabled); |
| return builder_.Finish(); |
| } |
| |
| flatbuffers::Offset<BoundsSensitiveFeatures> CreateBoundsSensitiveFeatures(flatbuffers::FlatBufferBuilder &_fbb, const BoundsSensitiveFeaturesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| struct AlternativeCollectionMapEntryT : public flatbuffers::NativeTable { |
| typedef AlternativeCollectionMapEntry TableType; |
| std::string key; |
| std::string value; |
| AlternativeCollectionMapEntryT() { |
| } |
| }; |
| |
| struct AlternativeCollectionMapEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef AlternativeCollectionMapEntryT NativeTableType; |
| enum { |
| VT_KEY = 4, |
| VT_VALUE = 6 |
| }; |
| const flatbuffers::String *key() const { |
| return GetPointer<const flatbuffers::String *>(VT_KEY); |
| } |
| const flatbuffers::String *value() const { |
| return GetPointer<const flatbuffers::String *>(VT_VALUE); |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_KEY) && |
| verifier.Verify(key()) && |
| VerifyOffset(verifier, VT_VALUE) && |
| verifier.Verify(value()) && |
| verifier.EndTable(); |
| } |
| AlternativeCollectionMapEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(AlternativeCollectionMapEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<AlternativeCollectionMapEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AlternativeCollectionMapEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct AlternativeCollectionMapEntryBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_key(flatbuffers::Offset<flatbuffers::String> key) { |
| fbb_.AddOffset(AlternativeCollectionMapEntry::VT_KEY, key); |
| } |
| void add_value(flatbuffers::Offset<flatbuffers::String> value) { |
| fbb_.AddOffset(AlternativeCollectionMapEntry::VT_VALUE, value); |
| } |
| explicit AlternativeCollectionMapEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| AlternativeCollectionMapEntryBuilder &operator=(const AlternativeCollectionMapEntryBuilder &); |
| flatbuffers::Offset<AlternativeCollectionMapEntry> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<AlternativeCollectionMapEntry>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<AlternativeCollectionMapEntry> CreateAlternativeCollectionMapEntry( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| flatbuffers::Offset<flatbuffers::String> key = 0, |
| flatbuffers::Offset<flatbuffers::String> value = 0) { |
| AlternativeCollectionMapEntryBuilder builder_(_fbb); |
| builder_.add_value(value); |
| builder_.add_key(key); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<AlternativeCollectionMapEntry> CreateAlternativeCollectionMapEntryDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| const char *key = nullptr, |
| const char *value = nullptr) { |
| return libtextclassifier2::FeatureProcessorOptions_::CreateAlternativeCollectionMapEntry( |
| _fbb, |
| key ? _fbb.CreateString(key) : 0, |
| value ? _fbb.CreateString(value) : 0); |
| } |
| |
| flatbuffers::Offset<AlternativeCollectionMapEntry> CreateAlternativeCollectionMapEntry(flatbuffers::FlatBufferBuilder &_fbb, const AlternativeCollectionMapEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| } // namespace FeatureProcessorOptions_ |
| |
| struct FeatureProcessorOptionsT : public flatbuffers::NativeTable { |
| typedef FeatureProcessorOptions TableType; |
| int32_t num_buckets; |
| int32_t embedding_size; |
| int32_t embedding_quantization_bits; |
| int32_t context_size; |
| int32_t max_selection_span; |
| std::vector<int32_t> chargram_orders; |
| int32_t max_word_length; |
| bool unicode_aware_features; |
| bool extract_case_feature; |
| bool extract_selection_mask_feature; |
| std::vector<std::string> regexp_feature; |
| bool remap_digits; |
| bool lowercase_tokens; |
| bool selection_reduced_output_space; |
| std::vector<std::string> collections; |
| int32_t default_collection; |
| bool only_use_line_with_click; |
| bool split_tokens_on_selection_boundaries; |
| std::vector<std::unique_ptr<TokenizationCodepointRangeT>> tokenization_codepoint_config; |
| libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod center_token_selection_method; |
| bool snap_label_span_boundaries_to_containing_tokens; |
| std::vector<std::unique_ptr<libtextclassifier2::FeatureProcessorOptions_::CodepointRangeT>> supported_codepoint_ranges; |
| std::vector<std::unique_ptr<libtextclassifier2::FeatureProcessorOptions_::CodepointRangeT>> internal_tokenizer_codepoint_ranges; |
| float min_supported_codepoint_ratio; |
| int32_t feature_version; |
| libtextclassifier2::FeatureProcessorOptions_::TokenizationType tokenization_type; |
| bool icu_preserve_whitespace_tokens; |
| std::vector<int32_t> ignored_span_boundary_codepoints; |
| std::unique_ptr<libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeaturesT> bounds_sensitive_features; |
| std::vector<std::string> allowed_chargrams; |
| bool tokenize_on_script_change; |
| FeatureProcessorOptionsT() |
| : num_buckets(-1), |
| embedding_size(-1), |
| embedding_quantization_bits(8), |
| context_size(-1), |
| max_selection_span(-1), |
| max_word_length(20), |
| unicode_aware_features(false), |
| extract_case_feature(false), |
| extract_selection_mask_feature(false), |
| remap_digits(false), |
| lowercase_tokens(false), |
| selection_reduced_output_space(true), |
| default_collection(-1), |
| only_use_line_with_click(false), |
| split_tokens_on_selection_boundaries(false), |
| center_token_selection_method(libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod_DEFAULT_CENTER_TOKEN_METHOD), |
| snap_label_span_boundaries_to_containing_tokens(false), |
| min_supported_codepoint_ratio(0.0f), |
| feature_version(0), |
| tokenization_type(libtextclassifier2::FeatureProcessorOptions_::TokenizationType_INTERNAL_TOKENIZER), |
| icu_preserve_whitespace_tokens(false), |
| tokenize_on_script_change(false) { |
| } |
| }; |
| |
| struct FeatureProcessorOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { |
| typedef FeatureProcessorOptionsT NativeTableType; |
| enum { |
| VT_NUM_BUCKETS = 4, |
| VT_EMBEDDING_SIZE = 6, |
| VT_EMBEDDING_QUANTIZATION_BITS = 8, |
| VT_CONTEXT_SIZE = 10, |
| VT_MAX_SELECTION_SPAN = 12, |
| VT_CHARGRAM_ORDERS = 14, |
| VT_MAX_WORD_LENGTH = 16, |
| VT_UNICODE_AWARE_FEATURES = 18, |
| VT_EXTRACT_CASE_FEATURE = 20, |
| VT_EXTRACT_SELECTION_MASK_FEATURE = 22, |
| VT_REGEXP_FEATURE = 24, |
| VT_REMAP_DIGITS = 26, |
| VT_LOWERCASE_TOKENS = 28, |
| VT_SELECTION_REDUCED_OUTPUT_SPACE = 30, |
| VT_COLLECTIONS = 32, |
| VT_DEFAULT_COLLECTION = 34, |
| VT_ONLY_USE_LINE_WITH_CLICK = 36, |
| VT_SPLIT_TOKENS_ON_SELECTION_BOUNDARIES = 38, |
| VT_TOKENIZATION_CODEPOINT_CONFIG = 40, |
| VT_CENTER_TOKEN_SELECTION_METHOD = 42, |
| VT_SNAP_LABEL_SPAN_BOUNDARIES_TO_CONTAINING_TOKENS = 44, |
| VT_SUPPORTED_CODEPOINT_RANGES = 46, |
| VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES = 48, |
| VT_MIN_SUPPORTED_CODEPOINT_RATIO = 50, |
| VT_FEATURE_VERSION = 52, |
| VT_TOKENIZATION_TYPE = 54, |
| VT_ICU_PRESERVE_WHITESPACE_TOKENS = 56, |
| VT_IGNORED_SPAN_BOUNDARY_CODEPOINTS = 58, |
| VT_BOUNDS_SENSITIVE_FEATURES = 60, |
| VT_ALLOWED_CHARGRAMS = 62, |
| VT_TOKENIZE_ON_SCRIPT_CHANGE = 64 |
| }; |
| int32_t num_buckets() const { |
| return GetField<int32_t>(VT_NUM_BUCKETS, -1); |
| } |
| int32_t embedding_size() const { |
| return GetField<int32_t>(VT_EMBEDDING_SIZE, -1); |
| } |
| int32_t embedding_quantization_bits() const { |
| return GetField<int32_t>(VT_EMBEDDING_QUANTIZATION_BITS, 8); |
| } |
| int32_t context_size() const { |
| return GetField<int32_t>(VT_CONTEXT_SIZE, -1); |
| } |
| int32_t max_selection_span() const { |
| return GetField<int32_t>(VT_MAX_SELECTION_SPAN, -1); |
| } |
| const flatbuffers::Vector<int32_t> *chargram_orders() const { |
| return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_CHARGRAM_ORDERS); |
| } |
| int32_t max_word_length() const { |
| return GetField<int32_t>(VT_MAX_WORD_LENGTH, 20); |
| } |
| bool unicode_aware_features() const { |
| return GetField<uint8_t>(VT_UNICODE_AWARE_FEATURES, 0) != 0; |
| } |
| bool extract_case_feature() const { |
| return GetField<uint8_t>(VT_EXTRACT_CASE_FEATURE, 0) != 0; |
| } |
| bool extract_selection_mask_feature() const { |
| return GetField<uint8_t>(VT_EXTRACT_SELECTION_MASK_FEATURE, 0) != 0; |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *regexp_feature() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_REGEXP_FEATURE); |
| } |
| bool remap_digits() const { |
| return GetField<uint8_t>(VT_REMAP_DIGITS, 0) != 0; |
| } |
| bool lowercase_tokens() const { |
| return GetField<uint8_t>(VT_LOWERCASE_TOKENS, 0) != 0; |
| } |
| bool selection_reduced_output_space() const { |
| return GetField<uint8_t>(VT_SELECTION_REDUCED_OUTPUT_SPACE, 1) != 0; |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *collections() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_COLLECTIONS); |
| } |
| int32_t default_collection() const { |
| return GetField<int32_t>(VT_DEFAULT_COLLECTION, -1); |
| } |
| bool only_use_line_with_click() const { |
| return GetField<uint8_t>(VT_ONLY_USE_LINE_WITH_CLICK, 0) != 0; |
| } |
| bool split_tokens_on_selection_boundaries() const { |
| return GetField<uint8_t>(VT_SPLIT_TOKENS_ON_SELECTION_BOUNDARIES, 0) != 0; |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<TokenizationCodepointRange>> *tokenization_codepoint_config() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TokenizationCodepointRange>> *>(VT_TOKENIZATION_CODEPOINT_CONFIG); |
| } |
| libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod center_token_selection_method() const { |
| return static_cast<libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod>(GetField<int32_t>(VT_CENTER_TOKEN_SELECTION_METHOD, 0)); |
| } |
| bool snap_label_span_boundaries_to_containing_tokens() const { |
| return GetField<uint8_t>(VT_SNAP_LABEL_SPAN_BOUNDARIES_TO_CONTAINING_TOKENS, 0) != 0; |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> *supported_codepoint_ranges() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> *>(VT_SUPPORTED_CODEPOINT_RANGES); |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> *internal_tokenizer_codepoint_ranges() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> *>(VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES); |
| } |
| float min_supported_codepoint_ratio() const { |
| return GetField<float>(VT_MIN_SUPPORTED_CODEPOINT_RATIO, 0.0f); |
| } |
| int32_t feature_version() const { |
| return GetField<int32_t>(VT_FEATURE_VERSION, 0); |
| } |
| libtextclassifier2::FeatureProcessorOptions_::TokenizationType tokenization_type() const { |
| return static_cast<libtextclassifier2::FeatureProcessorOptions_::TokenizationType>(GetField<int32_t>(VT_TOKENIZATION_TYPE, 1)); |
| } |
| bool icu_preserve_whitespace_tokens() const { |
| return GetField<uint8_t>(VT_ICU_PRESERVE_WHITESPACE_TOKENS, 0) != 0; |
| } |
| const flatbuffers::Vector<int32_t> *ignored_span_boundary_codepoints() const { |
| return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_IGNORED_SPAN_BOUNDARY_CODEPOINTS); |
| } |
| const libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeatures *bounds_sensitive_features() const { |
| return GetPointer<const libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeatures *>(VT_BOUNDS_SENSITIVE_FEATURES); |
| } |
| const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *allowed_chargrams() const { |
| return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_ALLOWED_CHARGRAMS); |
| } |
| bool tokenize_on_script_change() const { |
| return GetField<uint8_t>(VT_TOKENIZE_ON_SCRIPT_CHANGE, 0) != 0; |
| } |
| bool Verify(flatbuffers::Verifier &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<int32_t>(verifier, VT_NUM_BUCKETS) && |
| VerifyField<int32_t>(verifier, VT_EMBEDDING_SIZE) && |
| VerifyField<int32_t>(verifier, VT_EMBEDDING_QUANTIZATION_BITS) && |
| VerifyField<int32_t>(verifier, VT_CONTEXT_SIZE) && |
| VerifyField<int32_t>(verifier, VT_MAX_SELECTION_SPAN) && |
| VerifyOffset(verifier, VT_CHARGRAM_ORDERS) && |
| verifier.Verify(chargram_orders()) && |
| VerifyField<int32_t>(verifier, VT_MAX_WORD_LENGTH) && |
| VerifyField<uint8_t>(verifier, VT_UNICODE_AWARE_FEATURES) && |
| VerifyField<uint8_t>(verifier, VT_EXTRACT_CASE_FEATURE) && |
| VerifyField<uint8_t>(verifier, VT_EXTRACT_SELECTION_MASK_FEATURE) && |
| VerifyOffset(verifier, VT_REGEXP_FEATURE) && |
| verifier.Verify(regexp_feature()) && |
| verifier.VerifyVectorOfStrings(regexp_feature()) && |
| VerifyField<uint8_t>(verifier, VT_REMAP_DIGITS) && |
| VerifyField<uint8_t>(verifier, VT_LOWERCASE_TOKENS) && |
| VerifyField<uint8_t>(verifier, VT_SELECTION_REDUCED_OUTPUT_SPACE) && |
| VerifyOffset(verifier, VT_COLLECTIONS) && |
| verifier.Verify(collections()) && |
| verifier.VerifyVectorOfStrings(collections()) && |
| VerifyField<int32_t>(verifier, VT_DEFAULT_COLLECTION) && |
| VerifyField<uint8_t>(verifier, VT_ONLY_USE_LINE_WITH_CLICK) && |
| VerifyField<uint8_t>(verifier, VT_SPLIT_TOKENS_ON_SELECTION_BOUNDARIES) && |
| VerifyOffset(verifier, VT_TOKENIZATION_CODEPOINT_CONFIG) && |
| verifier.Verify(tokenization_codepoint_config()) && |
| verifier.VerifyVectorOfTables(tokenization_codepoint_config()) && |
| VerifyField<int32_t>(verifier, VT_CENTER_TOKEN_SELECTION_METHOD) && |
| VerifyField<uint8_t>(verifier, VT_SNAP_LABEL_SPAN_BOUNDARIES_TO_CONTAINING_TOKENS) && |
| VerifyOffset(verifier, VT_SUPPORTED_CODEPOINT_RANGES) && |
| verifier.Verify(supported_codepoint_ranges()) && |
| verifier.VerifyVectorOfTables(supported_codepoint_ranges()) && |
| VerifyOffset(verifier, VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES) && |
| verifier.Verify(internal_tokenizer_codepoint_ranges()) && |
| verifier.VerifyVectorOfTables(internal_tokenizer_codepoint_ranges()) && |
| VerifyField<float>(verifier, VT_MIN_SUPPORTED_CODEPOINT_RATIO) && |
| VerifyField<int32_t>(verifier, VT_FEATURE_VERSION) && |
| VerifyField<int32_t>(verifier, VT_TOKENIZATION_TYPE) && |
| VerifyField<uint8_t>(verifier, VT_ICU_PRESERVE_WHITESPACE_TOKENS) && |
| VerifyOffset(verifier, VT_IGNORED_SPAN_BOUNDARY_CODEPOINTS) && |
| verifier.Verify(ignored_span_boundary_codepoints()) && |
| VerifyOffset(verifier, VT_BOUNDS_SENSITIVE_FEATURES) && |
| verifier.VerifyTable(bounds_sensitive_features()) && |
| VerifyOffset(verifier, VT_ALLOWED_CHARGRAMS) && |
| verifier.Verify(allowed_chargrams()) && |
| verifier.VerifyVectorOfStrings(allowed_chargrams()) && |
| VerifyField<uint8_t>(verifier, VT_TOKENIZE_ON_SCRIPT_CHANGE) && |
| verifier.EndTable(); |
| } |
| FeatureProcessorOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| void UnPackTo(FeatureProcessorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; |
| static flatbuffers::Offset<FeatureProcessorOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FeatureProcessorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| }; |
| |
| struct FeatureProcessorOptionsBuilder { |
| flatbuffers::FlatBufferBuilder &fbb_; |
| flatbuffers::uoffset_t start_; |
| void add_num_buckets(int32_t num_buckets) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_NUM_BUCKETS, num_buckets, -1); |
| } |
| void add_embedding_size(int32_t embedding_size) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_EMBEDDING_SIZE, embedding_size, -1); |
| } |
| void add_embedding_quantization_bits(int32_t embedding_quantization_bits) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_EMBEDDING_QUANTIZATION_BITS, embedding_quantization_bits, 8); |
| } |
| void add_context_size(int32_t context_size) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_CONTEXT_SIZE, context_size, -1); |
| } |
| void add_max_selection_span(int32_t max_selection_span) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_MAX_SELECTION_SPAN, max_selection_span, -1); |
| } |
| void add_chargram_orders(flatbuffers::Offset<flatbuffers::Vector<int32_t>> chargram_orders) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_CHARGRAM_ORDERS, chargram_orders); |
| } |
| void add_max_word_length(int32_t max_word_length) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_MAX_WORD_LENGTH, max_word_length, 20); |
| } |
| void add_unicode_aware_features(bool unicode_aware_features) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_UNICODE_AWARE_FEATURES, static_cast<uint8_t>(unicode_aware_features), 0); |
| } |
| void add_extract_case_feature(bool extract_case_feature) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_EXTRACT_CASE_FEATURE, static_cast<uint8_t>(extract_case_feature), 0); |
| } |
| void add_extract_selection_mask_feature(bool extract_selection_mask_feature) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_EXTRACT_SELECTION_MASK_FEATURE, static_cast<uint8_t>(extract_selection_mask_feature), 0); |
| } |
| void add_regexp_feature(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> regexp_feature) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_REGEXP_FEATURE, regexp_feature); |
| } |
| void add_remap_digits(bool remap_digits) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_REMAP_DIGITS, static_cast<uint8_t>(remap_digits), 0); |
| } |
| void add_lowercase_tokens(bool lowercase_tokens) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_LOWERCASE_TOKENS, static_cast<uint8_t>(lowercase_tokens), 0); |
| } |
| void add_selection_reduced_output_space(bool selection_reduced_output_space) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_SELECTION_REDUCED_OUTPUT_SPACE, static_cast<uint8_t>(selection_reduced_output_space), 1); |
| } |
| void add_collections(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> collections) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_COLLECTIONS, collections); |
| } |
| void add_default_collection(int32_t default_collection) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_DEFAULT_COLLECTION, default_collection, -1); |
| } |
| void add_only_use_line_with_click(bool only_use_line_with_click) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_ONLY_USE_LINE_WITH_CLICK, static_cast<uint8_t>(only_use_line_with_click), 0); |
| } |
| void add_split_tokens_on_selection_boundaries(bool split_tokens_on_selection_boundaries) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_SPLIT_TOKENS_ON_SELECTION_BOUNDARIES, static_cast<uint8_t>(split_tokens_on_selection_boundaries), 0); |
| } |
| void add_tokenization_codepoint_config(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TokenizationCodepointRange>>> tokenization_codepoint_config) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_TOKENIZATION_CODEPOINT_CONFIG, tokenization_codepoint_config); |
| } |
| void add_center_token_selection_method(libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod center_token_selection_method) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_CENTER_TOKEN_SELECTION_METHOD, static_cast<int32_t>(center_token_selection_method), 0); |
| } |
| void add_snap_label_span_boundaries_to_containing_tokens(bool snap_label_span_boundaries_to_containing_tokens) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_SNAP_LABEL_SPAN_BOUNDARIES_TO_CONTAINING_TOKENS, static_cast<uint8_t>(snap_label_span_boundaries_to_containing_tokens), 0); |
| } |
| void add_supported_codepoint_ranges(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>>> supported_codepoint_ranges) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_SUPPORTED_CODEPOINT_RANGES, supported_codepoint_ranges); |
| } |
| void add_internal_tokenizer_codepoint_ranges(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>>> internal_tokenizer_codepoint_ranges) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_INTERNAL_TOKENIZER_CODEPOINT_RANGES, internal_tokenizer_codepoint_ranges); |
| } |
| void add_min_supported_codepoint_ratio(float min_supported_codepoint_ratio) { |
| fbb_.AddElement<float>(FeatureProcessorOptions::VT_MIN_SUPPORTED_CODEPOINT_RATIO, min_supported_codepoint_ratio, 0.0f); |
| } |
| void add_feature_version(int32_t feature_version) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_FEATURE_VERSION, feature_version, 0); |
| } |
| void add_tokenization_type(libtextclassifier2::FeatureProcessorOptions_::TokenizationType tokenization_type) { |
| fbb_.AddElement<int32_t>(FeatureProcessorOptions::VT_TOKENIZATION_TYPE, static_cast<int32_t>(tokenization_type), 1); |
| } |
| void add_icu_preserve_whitespace_tokens(bool icu_preserve_whitespace_tokens) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_ICU_PRESERVE_WHITESPACE_TOKENS, static_cast<uint8_t>(icu_preserve_whitespace_tokens), 0); |
| } |
| void add_ignored_span_boundary_codepoints(flatbuffers::Offset<flatbuffers::Vector<int32_t>> ignored_span_boundary_codepoints) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_IGNORED_SPAN_BOUNDARY_CODEPOINTS, ignored_span_boundary_codepoints); |
| } |
| void add_bounds_sensitive_features(flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeatures> bounds_sensitive_features) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_BOUNDS_SENSITIVE_FEATURES, bounds_sensitive_features); |
| } |
| void add_allowed_chargrams(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> allowed_chargrams) { |
| fbb_.AddOffset(FeatureProcessorOptions::VT_ALLOWED_CHARGRAMS, allowed_chargrams); |
| } |
| void add_tokenize_on_script_change(bool tokenize_on_script_change) { |
| fbb_.AddElement<uint8_t>(FeatureProcessorOptions::VT_TOKENIZE_ON_SCRIPT_CHANGE, static_cast<uint8_t>(tokenize_on_script_change), 0); |
| } |
| explicit FeatureProcessorOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| FeatureProcessorOptionsBuilder &operator=(const FeatureProcessorOptionsBuilder &); |
| flatbuffers::Offset<FeatureProcessorOptions> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = flatbuffers::Offset<FeatureProcessorOptions>(end); |
| return o; |
| } |
| }; |
| |
| inline flatbuffers::Offset<FeatureProcessorOptions> CreateFeatureProcessorOptions( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| int32_t num_buckets = -1, |
| int32_t embedding_size = -1, |
| int32_t embedding_quantization_bits = 8, |
| int32_t context_size = -1, |
| int32_t max_selection_span = -1, |
| flatbuffers::Offset<flatbuffers::Vector<int32_t>> chargram_orders = 0, |
| int32_t max_word_length = 20, |
| bool unicode_aware_features = false, |
| bool extract_case_feature = false, |
| bool extract_selection_mask_feature = false, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> regexp_feature = 0, |
| bool remap_digits = false, |
| bool lowercase_tokens = false, |
| bool selection_reduced_output_space = true, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> collections = 0, |
| int32_t default_collection = -1, |
| bool only_use_line_with_click = false, |
| bool split_tokens_on_selection_boundaries = false, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TokenizationCodepointRange>>> tokenization_codepoint_config = 0, |
| libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod center_token_selection_method = libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod_DEFAULT_CENTER_TOKEN_METHOD, |
| bool snap_label_span_boundaries_to_containing_tokens = false, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>>> supported_codepoint_ranges = 0, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>>> internal_tokenizer_codepoint_ranges = 0, |
| float min_supported_codepoint_ratio = 0.0f, |
| int32_t feature_version = 0, |
| libtextclassifier2::FeatureProcessorOptions_::TokenizationType tokenization_type = libtextclassifier2::FeatureProcessorOptions_::TokenizationType_INTERNAL_TOKENIZER, |
| bool icu_preserve_whitespace_tokens = false, |
| flatbuffers::Offset<flatbuffers::Vector<int32_t>> ignored_span_boundary_codepoints = 0, |
| flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeatures> bounds_sensitive_features = 0, |
| flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> allowed_chargrams = 0, |
| bool tokenize_on_script_change = false) { |
| FeatureProcessorOptionsBuilder builder_(_fbb); |
| builder_.add_allowed_chargrams(allowed_chargrams); |
| builder_.add_bounds_sensitive_features(bounds_sensitive_features); |
| builder_.add_ignored_span_boundary_codepoints(ignored_span_boundary_codepoints); |
| builder_.add_tokenization_type(tokenization_type); |
| builder_.add_feature_version(feature_version); |
| builder_.add_min_supported_codepoint_ratio(min_supported_codepoint_ratio); |
| builder_.add_internal_tokenizer_codepoint_ranges(internal_tokenizer_codepoint_ranges); |
| builder_.add_supported_codepoint_ranges(supported_codepoint_ranges); |
| builder_.add_center_token_selection_method(center_token_selection_method); |
| builder_.add_tokenization_codepoint_config(tokenization_codepoint_config); |
| builder_.add_default_collection(default_collection); |
| builder_.add_collections(collections); |
| builder_.add_regexp_feature(regexp_feature); |
| builder_.add_max_word_length(max_word_length); |
| builder_.add_chargram_orders(chargram_orders); |
| builder_.add_max_selection_span(max_selection_span); |
| builder_.add_context_size(context_size); |
| builder_.add_embedding_quantization_bits(embedding_quantization_bits); |
| builder_.add_embedding_size(embedding_size); |
| builder_.add_num_buckets(num_buckets); |
| builder_.add_tokenize_on_script_change(tokenize_on_script_change); |
| builder_.add_icu_preserve_whitespace_tokens(icu_preserve_whitespace_tokens); |
| builder_.add_snap_label_span_boundaries_to_containing_tokens(snap_label_span_boundaries_to_containing_tokens); |
| builder_.add_split_tokens_on_selection_boundaries(split_tokens_on_selection_boundaries); |
| builder_.add_only_use_line_with_click(only_use_line_with_click); |
| builder_.add_selection_reduced_output_space(selection_reduced_output_space); |
| builder_.add_lowercase_tokens(lowercase_tokens); |
| builder_.add_remap_digits(remap_digits); |
| builder_.add_extract_selection_mask_feature(extract_selection_mask_feature); |
| builder_.add_extract_case_feature(extract_case_feature); |
| builder_.add_unicode_aware_features(unicode_aware_features); |
| return builder_.Finish(); |
| } |
| |
| inline flatbuffers::Offset<FeatureProcessorOptions> CreateFeatureProcessorOptionsDirect( |
| flatbuffers::FlatBufferBuilder &_fbb, |
| int32_t num_buckets = -1, |
| int32_t embedding_size = -1, |
| int32_t embedding_quantization_bits = 8, |
| int32_t context_size = -1, |
| int32_t max_selection_span = -1, |
| const std::vector<int32_t> *chargram_orders = nullptr, |
| int32_t max_word_length = 20, |
| bool unicode_aware_features = false, |
| bool extract_case_feature = false, |
| bool extract_selection_mask_feature = false, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *regexp_feature = nullptr, |
| bool remap_digits = false, |
| bool lowercase_tokens = false, |
| bool selection_reduced_output_space = true, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *collections = nullptr, |
| int32_t default_collection = -1, |
| bool only_use_line_with_click = false, |
| bool split_tokens_on_selection_boundaries = false, |
| const std::vector<flatbuffers::Offset<TokenizationCodepointRange>> *tokenization_codepoint_config = nullptr, |
| libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod center_token_selection_method = libtextclassifier2::FeatureProcessorOptions_::CenterTokenSelectionMethod_DEFAULT_CENTER_TOKEN_METHOD, |
| bool snap_label_span_boundaries_to_containing_tokens = false, |
| const std::vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> *supported_codepoint_ranges = nullptr, |
| const std::vector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> *internal_tokenizer_codepoint_ranges = nullptr, |
| float min_supported_codepoint_ratio = 0.0f, |
| int32_t feature_version = 0, |
| libtextclassifier2::FeatureProcessorOptions_::TokenizationType tokenization_type = libtextclassifier2::FeatureProcessorOptions_::TokenizationType_INTERNAL_TOKENIZER, |
| bool icu_preserve_whitespace_tokens = false, |
| const std::vector<int32_t> *ignored_span_boundary_codepoints = nullptr, |
| flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeatures> bounds_sensitive_features = 0, |
| const std::vector<flatbuffers::Offset<flatbuffers::String>> *allowed_chargrams = nullptr, |
| bool tokenize_on_script_change = false) { |
| return libtextclassifier2::CreateFeatureProcessorOptions( |
| _fbb, |
| num_buckets, |
| embedding_size, |
| embedding_quantization_bits, |
| context_size, |
| max_selection_span, |
| chargram_orders ? _fbb.CreateVector<int32_t>(*chargram_orders) : 0, |
| max_word_length, |
| unicode_aware_features, |
| extract_case_feature, |
| extract_selection_mask_feature, |
| regexp_feature ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*regexp_feature) : 0, |
| remap_digits, |
| lowercase_tokens, |
| selection_reduced_output_space, |
| collections ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*collections) : 0, |
| default_collection, |
| only_use_line_with_click, |
| split_tokens_on_selection_boundaries, |
| tokenization_codepoint_config ? _fbb.CreateVector<flatbuffers::Offset<TokenizationCodepointRange>>(*tokenization_codepoint_config) : 0, |
| center_token_selection_method, |
| snap_label_span_boundaries_to_containing_tokens, |
| supported_codepoint_ranges ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>>(*supported_codepoint_ranges) : 0, |
| internal_tokenizer_codepoint_ranges ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>>(*internal_tokenizer_codepoint_ranges) : 0, |
| min_supported_codepoint_ratio, |
| feature_version, |
| tokenization_type, |
| icu_preserve_whitespace_tokens, |
| ignored_span_boundary_codepoints ? _fbb.CreateVector<int32_t>(*ignored_span_boundary_codepoints) : 0, |
| bounds_sensitive_features, |
| allowed_chargrams ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*allowed_chargrams) : 0, |
| tokenize_on_script_change); |
| } |
| |
| flatbuffers::Offset<FeatureProcessorOptions> CreateFeatureProcessorOptions(flatbuffers::FlatBufferBuilder &_fbb, const FeatureProcessorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); |
| |
| inline CompressedBufferT *CompressedBuffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new CompressedBufferT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void CompressedBuffer::UnPackTo(CompressedBufferT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = buffer(); if (_e) { _o->buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffer[_i] = _e->Get(_i); } } }; |
| { auto _e = uncompressed_size(); _o->uncompressed_size = _e; }; |
| } |
| |
| inline flatbuffers::Offset<CompressedBuffer> CompressedBuffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CompressedBufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateCompressedBuffer(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<CompressedBuffer> CreateCompressedBuffer(flatbuffers::FlatBufferBuilder &_fbb, const CompressedBufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CompressedBufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _buffer = _o->buffer.size() ? _fbb.CreateVector(_o->buffer) : 0; |
| auto _uncompressed_size = _o->uncompressed_size; |
| return libtextclassifier2::CreateCompressedBuffer( |
| _fbb, |
| _buffer, |
| _uncompressed_size); |
| } |
| |
| inline SelectionModelOptionsT *SelectionModelOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new SelectionModelOptionsT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void SelectionModelOptions::UnPackTo(SelectionModelOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = strip_unpaired_brackets(); _o->strip_unpaired_brackets = _e; }; |
| { auto _e = symmetry_context_size(); _o->symmetry_context_size = _e; }; |
| { auto _e = batch_size(); _o->batch_size = _e; }; |
| { auto _e = always_classify_suggested_selection(); _o->always_classify_suggested_selection = _e; }; |
| } |
| |
| inline flatbuffers::Offset<SelectionModelOptions> SelectionModelOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectionModelOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateSelectionModelOptions(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<SelectionModelOptions> CreateSelectionModelOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectionModelOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectionModelOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _strip_unpaired_brackets = _o->strip_unpaired_brackets; |
| auto _symmetry_context_size = _o->symmetry_context_size; |
| auto _batch_size = _o->batch_size; |
| auto _always_classify_suggested_selection = _o->always_classify_suggested_selection; |
| return libtextclassifier2::CreateSelectionModelOptions( |
| _fbb, |
| _strip_unpaired_brackets, |
| _symmetry_context_size, |
| _batch_size, |
| _always_classify_suggested_selection); |
| } |
| |
| inline ClassificationModelOptionsT *ClassificationModelOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new ClassificationModelOptionsT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void ClassificationModelOptions::UnPackTo(ClassificationModelOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = phone_min_num_digits(); _o->phone_min_num_digits = _e; }; |
| { auto _e = phone_max_num_digits(); _o->phone_max_num_digits = _e; }; |
| { auto _e = address_min_num_tokens(); _o->address_min_num_tokens = _e; }; |
| { auto _e = max_num_tokens(); _o->max_num_tokens = _e; }; |
| } |
| |
| inline flatbuffers::Offset<ClassificationModelOptions> ClassificationModelOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ClassificationModelOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateClassificationModelOptions(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<ClassificationModelOptions> CreateClassificationModelOptions(flatbuffers::FlatBufferBuilder &_fbb, const ClassificationModelOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ClassificationModelOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _phone_min_num_digits = _o->phone_min_num_digits; |
| auto _phone_max_num_digits = _o->phone_max_num_digits; |
| auto _address_min_num_tokens = _o->address_min_num_tokens; |
| auto _max_num_tokens = _o->max_num_tokens; |
| return libtextclassifier2::CreateClassificationModelOptions( |
| _fbb, |
| _phone_min_num_digits, |
| _phone_max_num_digits, |
| _address_min_num_tokens, |
| _max_num_tokens); |
| } |
| |
| namespace RegexModel_ { |
| |
| inline PatternT *Pattern::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new PatternT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void Pattern::UnPackTo(PatternT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = collection_name(); if (_e) _o->collection_name = _e->str(); }; |
| { auto _e = pattern(); if (_e) _o->pattern = _e->str(); }; |
| { auto _e = enabled_modes(); _o->enabled_modes = _e; }; |
| { auto _e = target_classification_score(); _o->target_classification_score = _e; }; |
| { auto _e = priority_score(); _o->priority_score = _e; }; |
| { auto _e = use_approximate_matching(); _o->use_approximate_matching = _e; }; |
| { auto _e = compressed_pattern(); if (_e) _o->compressed_pattern = std::unique_ptr<libtextclassifier2::CompressedBufferT>(_e->UnPack(_resolver)); }; |
| } |
| |
| inline flatbuffers::Offset<Pattern> Pattern::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PatternT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreatePattern(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<Pattern> CreatePattern(flatbuffers::FlatBufferBuilder &_fbb, const PatternT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PatternT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _collection_name = _o->collection_name.empty() ? 0 : _fbb.CreateString(_o->collection_name); |
| auto _pattern = _o->pattern.empty() ? 0 : _fbb.CreateString(_o->pattern); |
| auto _enabled_modes = _o->enabled_modes; |
| auto _target_classification_score = _o->target_classification_score; |
| auto _priority_score = _o->priority_score; |
| auto _use_approximate_matching = _o->use_approximate_matching; |
| auto _compressed_pattern = _o->compressed_pattern ? CreateCompressedBuffer(_fbb, _o->compressed_pattern.get(), _rehasher) : 0; |
| return libtextclassifier2::RegexModel_::CreatePattern( |
| _fbb, |
| _collection_name, |
| _pattern, |
| _enabled_modes, |
| _target_classification_score, |
| _priority_score, |
| _use_approximate_matching, |
| _compressed_pattern); |
| } |
| |
| } // namespace RegexModel_ |
| |
| inline RegexModelT *RegexModel::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new RegexModelT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void RegexModel::UnPackTo(RegexModelT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = patterns(); if (_e) { _o->patterns.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->patterns[_i] = std::unique_ptr<libtextclassifier2::RegexModel_::PatternT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| } |
| |
| inline flatbuffers::Offset<RegexModel> RegexModel::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegexModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateRegexModel(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<RegexModel> CreateRegexModel(flatbuffers::FlatBufferBuilder &_fbb, const RegexModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RegexModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _patterns = _o->patterns.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::RegexModel_::Pattern>> (_o->patterns.size(), [](size_t i, _VectorArgs *__va) { return CreatePattern(*__va->__fbb, __va->__o->patterns[i].get(), __va->__rehasher); }, &_va ) : 0; |
| return libtextclassifier2::CreateRegexModel( |
| _fbb, |
| _patterns); |
| } |
| |
| namespace DatetimeModelPattern_ { |
| |
| inline RegexT *Regex::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new RegexT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void Regex::UnPackTo(RegexT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = pattern(); if (_e) _o->pattern = _e->str(); }; |
| { auto _e = groups(); if (_e) { _o->groups.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->groups[_i] = (DatetimeGroupType)_e->Get(_i); } } }; |
| { auto _e = compressed_pattern(); if (_e) _o->compressed_pattern = std::unique_ptr<libtextclassifier2::CompressedBufferT>(_e->UnPack(_resolver)); }; |
| } |
| |
| inline flatbuffers::Offset<Regex> Regex::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegexT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateRegex(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<Regex> CreateRegex(flatbuffers::FlatBufferBuilder &_fbb, const RegexT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RegexT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _pattern = _o->pattern.empty() ? 0 : _fbb.CreateString(_o->pattern); |
| auto _groups = _o->groups.size() ? _fbb.CreateVector((const int32_t*)_o->groups.data(), _o->groups.size()) : 0; |
| auto _compressed_pattern = _o->compressed_pattern ? CreateCompressedBuffer(_fbb, _o->compressed_pattern.get(), _rehasher) : 0; |
| return libtextclassifier2::DatetimeModelPattern_::CreateRegex( |
| _fbb, |
| _pattern, |
| _groups, |
| _compressed_pattern); |
| } |
| |
| } // namespace DatetimeModelPattern_ |
| |
| inline DatetimeModelPatternT *DatetimeModelPattern::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new DatetimeModelPatternT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void DatetimeModelPattern::UnPackTo(DatetimeModelPatternT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = regexes(); if (_e) { _o->regexes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->regexes[_i] = std::unique_ptr<libtextclassifier2::DatetimeModelPattern_::RegexT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| { auto _e = locales(); if (_e) { _o->locales.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->locales[_i] = _e->Get(_i); } } }; |
| { auto _e = target_classification_score(); _o->target_classification_score = _e; }; |
| { auto _e = priority_score(); _o->priority_score = _e; }; |
| { auto _e = enabled_modes(); _o->enabled_modes = _e; }; |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelPattern> DatetimeModelPattern::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelPatternT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateDatetimeModelPattern(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelPattern> CreateDatetimeModelPattern(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelPatternT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DatetimeModelPatternT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _regexes = _o->regexes.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::DatetimeModelPattern_::Regex>> (_o->regexes.size(), [](size_t i, _VectorArgs *__va) { return CreateRegex(*__va->__fbb, __va->__o->regexes[i].get(), __va->__rehasher); }, &_va ) : 0; |
| auto _locales = _o->locales.size() ? _fbb.CreateVector(_o->locales) : 0; |
| auto _target_classification_score = _o->target_classification_score; |
| auto _priority_score = _o->priority_score; |
| auto _enabled_modes = _o->enabled_modes; |
| return libtextclassifier2::CreateDatetimeModelPattern( |
| _fbb, |
| _regexes, |
| _locales, |
| _target_classification_score, |
| _priority_score, |
| _enabled_modes); |
| } |
| |
| inline DatetimeModelExtractorT *DatetimeModelExtractor::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new DatetimeModelExtractorT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void DatetimeModelExtractor::UnPackTo(DatetimeModelExtractorT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = extractor(); _o->extractor = _e; }; |
| { auto _e = pattern(); if (_e) _o->pattern = _e->str(); }; |
| { auto _e = locales(); if (_e) { _o->locales.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->locales[_i] = _e->Get(_i); } } }; |
| { auto _e = compressed_pattern(); if (_e) _o->compressed_pattern = std::unique_ptr<CompressedBufferT>(_e->UnPack(_resolver)); }; |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelExtractor> DatetimeModelExtractor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelExtractorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateDatetimeModelExtractor(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelExtractor> CreateDatetimeModelExtractor(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelExtractorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DatetimeModelExtractorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _extractor = _o->extractor; |
| auto _pattern = _o->pattern.empty() ? 0 : _fbb.CreateString(_o->pattern); |
| auto _locales = _o->locales.size() ? _fbb.CreateVector(_o->locales) : 0; |
| auto _compressed_pattern = _o->compressed_pattern ? CreateCompressedBuffer(_fbb, _o->compressed_pattern.get(), _rehasher) : 0; |
| return libtextclassifier2::CreateDatetimeModelExtractor( |
| _fbb, |
| _extractor, |
| _pattern, |
| _locales, |
| _compressed_pattern); |
| } |
| |
| inline DatetimeModelT *DatetimeModel::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new DatetimeModelT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void DatetimeModel::UnPackTo(DatetimeModelT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = locales(); if (_e) { _o->locales.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->locales[_i] = _e->Get(_i)->str(); } } }; |
| { auto _e = patterns(); if (_e) { _o->patterns.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->patterns[_i] = std::unique_ptr<DatetimeModelPatternT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| { auto _e = extractors(); if (_e) { _o->extractors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->extractors[_i] = std::unique_ptr<DatetimeModelExtractorT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| { auto _e = use_extractors_for_locating(); _o->use_extractors_for_locating = _e; }; |
| { auto _e = default_locales(); if (_e) { _o->default_locales.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->default_locales[_i] = _e->Get(_i); } } }; |
| } |
| |
| inline flatbuffers::Offset<DatetimeModel> DatetimeModel::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateDatetimeModel(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModel> CreateDatetimeModel(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DatetimeModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _locales = _o->locales.size() ? _fbb.CreateVectorOfStrings(_o->locales) : 0; |
| auto _patterns = _o->patterns.size() ? _fbb.CreateVector<flatbuffers::Offset<DatetimeModelPattern>> (_o->patterns.size(), [](size_t i, _VectorArgs *__va) { return CreateDatetimeModelPattern(*__va->__fbb, __va->__o->patterns[i].get(), __va->__rehasher); }, &_va ) : 0; |
| auto _extractors = _o->extractors.size() ? _fbb.CreateVector<flatbuffers::Offset<DatetimeModelExtractor>> (_o->extractors.size(), [](size_t i, _VectorArgs *__va) { return CreateDatetimeModelExtractor(*__va->__fbb, __va->__o->extractors[i].get(), __va->__rehasher); }, &_va ) : 0; |
| auto _use_extractors_for_locating = _o->use_extractors_for_locating; |
| auto _default_locales = _o->default_locales.size() ? _fbb.CreateVector(_o->default_locales) : 0; |
| return libtextclassifier2::CreateDatetimeModel( |
| _fbb, |
| _locales, |
| _patterns, |
| _extractors, |
| _use_extractors_for_locating, |
| _default_locales); |
| } |
| |
| namespace DatetimeModelLibrary_ { |
| |
| inline ItemT *Item::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new ItemT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void Item::UnPackTo(ItemT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = key(); if (_e) _o->key = _e->str(); }; |
| { auto _e = value(); if (_e) _o->value = std::unique_ptr<libtextclassifier2::DatetimeModelT>(_e->UnPack(_resolver)); }; |
| } |
| |
| inline flatbuffers::Offset<Item> Item::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ItemT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateItem(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<Item> CreateItem(flatbuffers::FlatBufferBuilder &_fbb, const ItemT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ItemT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _key = _o->key.empty() ? 0 : _fbb.CreateString(_o->key); |
| auto _value = _o->value ? CreateDatetimeModel(_fbb, _o->value.get(), _rehasher) : 0; |
| return libtextclassifier2::DatetimeModelLibrary_::CreateItem( |
| _fbb, |
| _key, |
| _value); |
| } |
| |
| } // namespace DatetimeModelLibrary_ |
| |
| inline DatetimeModelLibraryT *DatetimeModelLibrary::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new DatetimeModelLibraryT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void DatetimeModelLibrary::UnPackTo(DatetimeModelLibraryT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = models(); if (_e) { _o->models.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->models[_i] = std::unique_ptr<libtextclassifier2::DatetimeModelLibrary_::ItemT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelLibrary> DatetimeModelLibrary::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelLibraryT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateDatetimeModelLibrary(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<DatetimeModelLibrary> CreateDatetimeModelLibrary(flatbuffers::FlatBufferBuilder &_fbb, const DatetimeModelLibraryT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DatetimeModelLibraryT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _models = _o->models.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::DatetimeModelLibrary_::Item>> (_o->models.size(), [](size_t i, _VectorArgs *__va) { return CreateItem(*__va->__fbb, __va->__o->models[i].get(), __va->__rehasher); }, &_va ) : 0; |
| return libtextclassifier2::CreateDatetimeModelLibrary( |
| _fbb, |
| _models); |
| } |
| |
| inline ModelTriggeringOptionsT *ModelTriggeringOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new ModelTriggeringOptionsT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void ModelTriggeringOptions::UnPackTo(ModelTriggeringOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = min_annotate_confidence(); _o->min_annotate_confidence = _e; }; |
| { auto _e = enabled_modes(); _o->enabled_modes = _e; }; |
| } |
| |
| inline flatbuffers::Offset<ModelTriggeringOptions> ModelTriggeringOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelTriggeringOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateModelTriggeringOptions(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<ModelTriggeringOptions> CreateModelTriggeringOptions(flatbuffers::FlatBufferBuilder &_fbb, const ModelTriggeringOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelTriggeringOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _min_annotate_confidence = _o->min_annotate_confidence; |
| auto _enabled_modes = _o->enabled_modes; |
| return libtextclassifier2::CreateModelTriggeringOptions( |
| _fbb, |
| _min_annotate_confidence, |
| _enabled_modes); |
| } |
| |
| inline OutputOptionsT *OutputOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new OutputOptionsT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void OutputOptions::UnPackTo(OutputOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = filtered_collections_annotation(); if (_e) { _o->filtered_collections_annotation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->filtered_collections_annotation[_i] = _e->Get(_i)->str(); } } }; |
| { auto _e = filtered_collections_classification(); if (_e) { _o->filtered_collections_classification.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->filtered_collections_classification[_i] = _e->Get(_i)->str(); } } }; |
| { auto _e = filtered_collections_selection(); if (_e) { _o->filtered_collections_selection.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->filtered_collections_selection[_i] = _e->Get(_i)->str(); } } }; |
| } |
| |
| inline flatbuffers::Offset<OutputOptions> OutputOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OutputOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateOutputOptions(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<OutputOptions> CreateOutputOptions(flatbuffers::FlatBufferBuilder &_fbb, const OutputOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OutputOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _filtered_collections_annotation = _o->filtered_collections_annotation.size() ? _fbb.CreateVectorOfStrings(_o->filtered_collections_annotation) : 0; |
| auto _filtered_collections_classification = _o->filtered_collections_classification.size() ? _fbb.CreateVectorOfStrings(_o->filtered_collections_classification) : 0; |
| auto _filtered_collections_selection = _o->filtered_collections_selection.size() ? _fbb.CreateVectorOfStrings(_o->filtered_collections_selection) : 0; |
| return libtextclassifier2::CreateOutputOptions( |
| _fbb, |
| _filtered_collections_annotation, |
| _filtered_collections_classification, |
| _filtered_collections_selection); |
| } |
| |
| inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new ModelT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = locales(); if (_e) _o->locales = _e->str(); }; |
| { auto _e = version(); _o->version = _e; }; |
| { auto _e = name(); if (_e) _o->name = _e->str(); }; |
| { auto _e = selection_feature_options(); if (_e) _o->selection_feature_options = std::unique_ptr<FeatureProcessorOptionsT>(_e->UnPack(_resolver)); }; |
| { auto _e = classification_feature_options(); if (_e) _o->classification_feature_options = std::unique_ptr<FeatureProcessorOptionsT>(_e->UnPack(_resolver)); }; |
| { auto _e = selection_model(); if (_e) { _o->selection_model.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->selection_model[_i] = _e->Get(_i); } } }; |
| { auto _e = classification_model(); if (_e) { _o->classification_model.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->classification_model[_i] = _e->Get(_i); } } }; |
| { auto _e = embedding_model(); if (_e) { _o->embedding_model.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_model[_i] = _e->Get(_i); } } }; |
| { auto _e = selection_options(); if (_e) _o->selection_options = std::unique_ptr<SelectionModelOptionsT>(_e->UnPack(_resolver)); }; |
| { auto _e = classification_options(); if (_e) _o->classification_options = std::unique_ptr<ClassificationModelOptionsT>(_e->UnPack(_resolver)); }; |
| { auto _e = regex_model(); if (_e) _o->regex_model = std::unique_ptr<RegexModelT>(_e->UnPack(_resolver)); }; |
| { auto _e = datetime_model(); if (_e) _o->datetime_model = std::unique_ptr<DatetimeModelT>(_e->UnPack(_resolver)); }; |
| { auto _e = triggering_options(); if (_e) _o->triggering_options = std::unique_ptr<ModelTriggeringOptionsT>(_e->UnPack(_resolver)); }; |
| { auto _e = enabled_modes(); _o->enabled_modes = _e; }; |
| { auto _e = snap_whitespace_selections(); _o->snap_whitespace_selections = _e; }; |
| { auto _e = output_options(); if (_e) _o->output_options = std::unique_ptr<OutputOptionsT>(_e->UnPack(_resolver)); }; |
| } |
| |
| inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateModel(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _locales = _o->locales.empty() ? 0 : _fbb.CreateString(_o->locales); |
| auto _version = _o->version; |
| auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); |
| auto _selection_feature_options = _o->selection_feature_options ? CreateFeatureProcessorOptions(_fbb, _o->selection_feature_options.get(), _rehasher) : 0; |
| auto _classification_feature_options = _o->classification_feature_options ? CreateFeatureProcessorOptions(_fbb, _o->classification_feature_options.get(), _rehasher) : 0; |
| auto _selection_model = _o->selection_model.size() ? _fbb.CreateVector(_o->selection_model) : 0; |
| auto _classification_model = _o->classification_model.size() ? _fbb.CreateVector(_o->classification_model) : 0; |
| auto _embedding_model = _o->embedding_model.size() ? _fbb.CreateVector(_o->embedding_model) : 0; |
| auto _selection_options = _o->selection_options ? CreateSelectionModelOptions(_fbb, _o->selection_options.get(), _rehasher) : 0; |
| auto _classification_options = _o->classification_options ? CreateClassificationModelOptions(_fbb, _o->classification_options.get(), _rehasher) : 0; |
| auto _regex_model = _o->regex_model ? CreateRegexModel(_fbb, _o->regex_model.get(), _rehasher) : 0; |
| auto _datetime_model = _o->datetime_model ? CreateDatetimeModel(_fbb, _o->datetime_model.get(), _rehasher) : 0; |
| auto _triggering_options = _o->triggering_options ? CreateModelTriggeringOptions(_fbb, _o->triggering_options.get(), _rehasher) : 0; |
| auto _enabled_modes = _o->enabled_modes; |
| auto _snap_whitespace_selections = _o->snap_whitespace_selections; |
| auto _output_options = _o->output_options ? CreateOutputOptions(_fbb, _o->output_options.get(), _rehasher) : 0; |
| return libtextclassifier2::CreateModel( |
| _fbb, |
| _locales, |
| _version, |
| _name, |
| _selection_feature_options, |
| _classification_feature_options, |
| _selection_model, |
| _classification_model, |
| _embedding_model, |
| _selection_options, |
| _classification_options, |
| _regex_model, |
| _datetime_model, |
| _triggering_options, |
| _enabled_modes, |
| _snap_whitespace_selections, |
| _output_options); |
| } |
| |
| inline TokenizationCodepointRangeT *TokenizationCodepointRange::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new TokenizationCodepointRangeT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void TokenizationCodepointRange::UnPackTo(TokenizationCodepointRangeT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = start(); _o->start = _e; }; |
| { auto _e = end(); _o->end = _e; }; |
| { auto _e = role(); _o->role = _e; }; |
| { auto _e = script_id(); _o->script_id = _e; }; |
| } |
| |
| inline flatbuffers::Offset<TokenizationCodepointRange> TokenizationCodepointRange::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TokenizationCodepointRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateTokenizationCodepointRange(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<TokenizationCodepointRange> CreateTokenizationCodepointRange(flatbuffers::FlatBufferBuilder &_fbb, const TokenizationCodepointRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TokenizationCodepointRangeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _start = _o->start; |
| auto _end = _o->end; |
| auto _role = _o->role; |
| auto _script_id = _o->script_id; |
| return libtextclassifier2::CreateTokenizationCodepointRange( |
| _fbb, |
| _start, |
| _end, |
| _role, |
| _script_id); |
| } |
| |
| namespace FeatureProcessorOptions_ { |
| |
| inline CodepointRangeT *CodepointRange::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new CodepointRangeT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void CodepointRange::UnPackTo(CodepointRangeT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = start(); _o->start = _e; }; |
| { auto _e = end(); _o->end = _e; }; |
| } |
| |
| inline flatbuffers::Offset<CodepointRange> CodepointRange::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CodepointRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateCodepointRange(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<CodepointRange> CreateCodepointRange(flatbuffers::FlatBufferBuilder &_fbb, const CodepointRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CodepointRangeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _start = _o->start; |
| auto _end = _o->end; |
| return libtextclassifier2::FeatureProcessorOptions_::CreateCodepointRange( |
| _fbb, |
| _start, |
| _end); |
| } |
| |
| inline BoundsSensitiveFeaturesT *BoundsSensitiveFeatures::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new BoundsSensitiveFeaturesT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void BoundsSensitiveFeatures::UnPackTo(BoundsSensitiveFeaturesT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = enabled(); _o->enabled = _e; }; |
| { auto _e = num_tokens_before(); _o->num_tokens_before = _e; }; |
| { auto _e = num_tokens_inside_left(); _o->num_tokens_inside_left = _e; }; |
| { auto _e = num_tokens_inside_right(); _o->num_tokens_inside_right = _e; }; |
| { auto _e = num_tokens_after(); _o->num_tokens_after = _e; }; |
| { auto _e = include_inside_bag(); _o->include_inside_bag = _e; }; |
| { auto _e = include_inside_length(); _o->include_inside_length = _e; }; |
| { auto _e = score_single_token_spans_as_zero(); _o->score_single_token_spans_as_zero = _e; }; |
| } |
| |
| inline flatbuffers::Offset<BoundsSensitiveFeatures> BoundsSensitiveFeatures::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BoundsSensitiveFeaturesT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateBoundsSensitiveFeatures(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<BoundsSensitiveFeatures> CreateBoundsSensitiveFeatures(flatbuffers::FlatBufferBuilder &_fbb, const BoundsSensitiveFeaturesT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BoundsSensitiveFeaturesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _enabled = _o->enabled; |
| auto _num_tokens_before = _o->num_tokens_before; |
| auto _num_tokens_inside_left = _o->num_tokens_inside_left; |
| auto _num_tokens_inside_right = _o->num_tokens_inside_right; |
| auto _num_tokens_after = _o->num_tokens_after; |
| auto _include_inside_bag = _o->include_inside_bag; |
| auto _include_inside_length = _o->include_inside_length; |
| auto _score_single_token_spans_as_zero = _o->score_single_token_spans_as_zero; |
| return libtextclassifier2::FeatureProcessorOptions_::CreateBoundsSensitiveFeatures( |
| _fbb, |
| _enabled, |
| _num_tokens_before, |
| _num_tokens_inside_left, |
| _num_tokens_inside_right, |
| _num_tokens_after, |
| _include_inside_bag, |
| _include_inside_length, |
| _score_single_token_spans_as_zero); |
| } |
| |
| inline AlternativeCollectionMapEntryT *AlternativeCollectionMapEntry::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new AlternativeCollectionMapEntryT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void AlternativeCollectionMapEntry::UnPackTo(AlternativeCollectionMapEntryT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = key(); if (_e) _o->key = _e->str(); }; |
| { auto _e = value(); if (_e) _o->value = _e->str(); }; |
| } |
| |
| inline flatbuffers::Offset<AlternativeCollectionMapEntry> AlternativeCollectionMapEntry::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AlternativeCollectionMapEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateAlternativeCollectionMapEntry(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<AlternativeCollectionMapEntry> CreateAlternativeCollectionMapEntry(flatbuffers::FlatBufferBuilder &_fbb, const AlternativeCollectionMapEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AlternativeCollectionMapEntryT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _key = _o->key.empty() ? 0 : _fbb.CreateString(_o->key); |
| auto _value = _o->value.empty() ? 0 : _fbb.CreateString(_o->value); |
| return libtextclassifier2::FeatureProcessorOptions_::CreateAlternativeCollectionMapEntry( |
| _fbb, |
| _key, |
| _value); |
| } |
| |
| } // namespace FeatureProcessorOptions_ |
| |
| inline FeatureProcessorOptionsT *FeatureProcessorOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { |
| auto _o = new FeatureProcessorOptionsT(); |
| UnPackTo(_o, _resolver); |
| return _o; |
| } |
| |
| inline void FeatureProcessorOptions::UnPackTo(FeatureProcessorOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { |
| (void)_o; |
| (void)_resolver; |
| { auto _e = num_buckets(); _o->num_buckets = _e; }; |
| { auto _e = embedding_size(); _o->embedding_size = _e; }; |
| { auto _e = embedding_quantization_bits(); _o->embedding_quantization_bits = _e; }; |
| { auto _e = context_size(); _o->context_size = _e; }; |
| { auto _e = max_selection_span(); _o->max_selection_span = _e; }; |
| { auto _e = chargram_orders(); if (_e) { _o->chargram_orders.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->chargram_orders[_i] = _e->Get(_i); } } }; |
| { auto _e = max_word_length(); _o->max_word_length = _e; }; |
| { auto _e = unicode_aware_features(); _o->unicode_aware_features = _e; }; |
| { auto _e = extract_case_feature(); _o->extract_case_feature = _e; }; |
| { auto _e = extract_selection_mask_feature(); _o->extract_selection_mask_feature = _e; }; |
| { auto _e = regexp_feature(); if (_e) { _o->regexp_feature.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->regexp_feature[_i] = _e->Get(_i)->str(); } } }; |
| { auto _e = remap_digits(); _o->remap_digits = _e; }; |
| { auto _e = lowercase_tokens(); _o->lowercase_tokens = _e; }; |
| { auto _e = selection_reduced_output_space(); _o->selection_reduced_output_space = _e; }; |
| { auto _e = collections(); if (_e) { _o->collections.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->collections[_i] = _e->Get(_i)->str(); } } }; |
| { auto _e = default_collection(); _o->default_collection = _e; }; |
| { auto _e = only_use_line_with_click(); _o->only_use_line_with_click = _e; }; |
| { auto _e = split_tokens_on_selection_boundaries(); _o->split_tokens_on_selection_boundaries = _e; }; |
| { auto _e = tokenization_codepoint_config(); if (_e) { _o->tokenization_codepoint_config.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tokenization_codepoint_config[_i] = std::unique_ptr<TokenizationCodepointRangeT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| { auto _e = center_token_selection_method(); _o->center_token_selection_method = _e; }; |
| { auto _e = snap_label_span_boundaries_to_containing_tokens(); _o->snap_label_span_boundaries_to_containing_tokens = _e; }; |
| { auto _e = supported_codepoint_ranges(); if (_e) { _o->supported_codepoint_ranges.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->supported_codepoint_ranges[_i] = std::unique_ptr<libtextclassifier2::FeatureProcessorOptions_::CodepointRangeT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| { auto _e = internal_tokenizer_codepoint_ranges(); if (_e) { _o->internal_tokenizer_codepoint_ranges.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->internal_tokenizer_codepoint_ranges[_i] = std::unique_ptr<libtextclassifier2::FeatureProcessorOptions_::CodepointRangeT>(_e->Get(_i)->UnPack(_resolver)); } } }; |
| { auto _e = min_supported_codepoint_ratio(); _o->min_supported_codepoint_ratio = _e; }; |
| { auto _e = feature_version(); _o->feature_version = _e; }; |
| { auto _e = tokenization_type(); _o->tokenization_type = _e; }; |
| { auto _e = icu_preserve_whitespace_tokens(); _o->icu_preserve_whitespace_tokens = _e; }; |
| { auto _e = ignored_span_boundary_codepoints(); if (_e) { _o->ignored_span_boundary_codepoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->ignored_span_boundary_codepoints[_i] = _e->Get(_i); } } }; |
| { auto _e = bounds_sensitive_features(); if (_e) _o->bounds_sensitive_features = std::unique_ptr<libtextclassifier2::FeatureProcessorOptions_::BoundsSensitiveFeaturesT>(_e->UnPack(_resolver)); }; |
| { auto _e = allowed_chargrams(); if (_e) { _o->allowed_chargrams.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->allowed_chargrams[_i] = _e->Get(_i)->str(); } } }; |
| { auto _e = tokenize_on_script_change(); _o->tokenize_on_script_change = _e; }; |
| } |
| |
| inline flatbuffers::Offset<FeatureProcessorOptions> FeatureProcessorOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FeatureProcessorOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { |
| return CreateFeatureProcessorOptions(_fbb, _o, _rehasher); |
| } |
| |
| inline flatbuffers::Offset<FeatureProcessorOptions> CreateFeatureProcessorOptions(flatbuffers::FlatBufferBuilder &_fbb, const FeatureProcessorOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { |
| (void)_rehasher; |
| (void)_o; |
| struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FeatureProcessorOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; |
| auto _num_buckets = _o->num_buckets; |
| auto _embedding_size = _o->embedding_size; |
| auto _embedding_quantization_bits = _o->embedding_quantization_bits; |
| auto _context_size = _o->context_size; |
| auto _max_selection_span = _o->max_selection_span; |
| auto _chargram_orders = _o->chargram_orders.size() ? _fbb.CreateVector(_o->chargram_orders) : 0; |
| auto _max_word_length = _o->max_word_length; |
| auto _unicode_aware_features = _o->unicode_aware_features; |
| auto _extract_case_feature = _o->extract_case_feature; |
| auto _extract_selection_mask_feature = _o->extract_selection_mask_feature; |
| auto _regexp_feature = _o->regexp_feature.size() ? _fbb.CreateVectorOfStrings(_o->regexp_feature) : 0; |
| auto _remap_digits = _o->remap_digits; |
| auto _lowercase_tokens = _o->lowercase_tokens; |
| auto _selection_reduced_output_space = _o->selection_reduced_output_space; |
| auto _collections = _o->collections.size() ? _fbb.CreateVectorOfStrings(_o->collections) : 0; |
| auto _default_collection = _o->default_collection; |
| auto _only_use_line_with_click = _o->only_use_line_with_click; |
| auto _split_tokens_on_selection_boundaries = _o->split_tokens_on_selection_boundaries; |
| auto _tokenization_codepoint_config = _o->tokenization_codepoint_config.size() ? _fbb.CreateVector<flatbuffers::Offset<TokenizationCodepointRange>> (_o->tokenization_codepoint_config.size(), [](size_t i, _VectorArgs *__va) { return CreateTokenizationCodepointRange(*__va->__fbb, __va->__o->tokenization_codepoint_config[i].get(), __va->__rehasher); }, &_va ) : 0; |
| auto _center_token_selection_method = _o->center_token_selection_method; |
| auto _snap_label_span_boundaries_to_containing_tokens = _o->snap_label_span_boundaries_to_containing_tokens; |
| auto _supported_codepoint_ranges = _o->supported_codepoint_ranges.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> (_o->supported_codepoint_ranges.size(), [](size_t i, _VectorArgs *__va) { return CreateCodepointRange(*__va->__fbb, __va->__o->supported_codepoint_ranges[i].get(), __va->__rehasher); }, &_va ) : 0; |
| auto _internal_tokenizer_codepoint_ranges = _o->internal_tokenizer_codepoint_ranges.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier2::FeatureProcessorOptions_::CodepointRange>> (_o->internal_tokenizer_codepoint_ranges.size(), [](size_t i, _VectorArgs *__va) { return CreateCodepointRange(*__va->__fbb, __va->__o->internal_tokenizer_codepoint_ranges[i].get(), __va->__rehasher); }, &_va ) : 0; |
| auto _min_supported_codepoint_ratio = _o->min_supported_codepoint_ratio; |
| auto _feature_version = _o->feature_version; |
| auto _tokenization_type = _o->tokenization_type; |
| auto _icu_preserve_whitespace_tokens = _o->icu_preserve_whitespace_tokens; |
| auto _ignored_span_boundary_codepoints = _o->ignored_span_boundary_codepoints.size() ? _fbb.CreateVector(_o->ignored_span_boundary_codepoints) : 0; |
| auto _bounds_sensitive_features = _o->bounds_sensitive_features ? CreateBoundsSensitiveFeatures(_fbb, _o->bounds_sensitive_features.get(), _rehasher) : 0; |
| auto _allowed_chargrams = _o->allowed_chargrams.size() ? _fbb.CreateVectorOfStrings(_o->allowed_chargrams) : 0; |
| auto _tokenize_on_script_change = _o->tokenize_on_script_change; |
| return libtextclassifier2::CreateFeatureProcessorOptions( |
| _fbb, |
| _num_buckets, |
| _embedding_size, |
| _embedding_quantization_bits, |
| _context_size, |
| _max_selection_span, |
| _chargram_orders, |
| _max_word_length, |
| _unicode_aware_features, |
| _extract_case_feature, |
| _extract_selection_mask_feature, |
| _regexp_feature, |
| _remap_digits, |
| _lowercase_tokens, |
| _selection_reduced_output_space, |
| _collections, |
| _default_collection, |
| _only_use_line_with_click, |
| _split_tokens_on_selection_boundaries, |
| _tokenization_codepoint_config, |
| _center_token_selection_method, |
| _snap_label_span_boundaries_to_containing_tokens, |
| _supported_codepoint_ranges, |
| _internal_tokenizer_codepoint_ranges, |
| _min_supported_codepoint_ratio, |
| _feature_version, |
| _tokenization_type, |
| _icu_preserve_whitespace_tokens, |
| _ignored_span_boundary_codepoints, |
| _bounds_sensitive_features, |
| _allowed_chargrams, |
| _tokenize_on_script_change); |
| } |
| |
| inline const libtextclassifier2::Model *GetModel(const void *buf) { |
| return flatbuffers::GetRoot<libtextclassifier2::Model>(buf); |
| } |
| |
| inline const char *ModelIdentifier() { |
| return "TC2 "; |
| } |
| |
| inline bool ModelBufferHasIdentifier(const void *buf) { |
| return flatbuffers::BufferHasIdentifier( |
| buf, ModelIdentifier()); |
| } |
| |
| inline bool VerifyModelBuffer( |
| flatbuffers::Verifier &verifier) { |
| return verifier.VerifyBuffer<libtextclassifier2::Model>(ModelIdentifier()); |
| } |
| |
| inline void FinishModelBuffer( |
| flatbuffers::FlatBufferBuilder &fbb, |
| flatbuffers::Offset<libtextclassifier2::Model> root) { |
| fbb.Finish(root, ModelIdentifier()); |
| } |
| |
| inline std::unique_ptr<ModelT> UnPackModel( |
| const void *buf, |
| const flatbuffers::resolver_function_t *res = nullptr) { |
| return std::unique_ptr<ModelT>(GetModel(buf)->UnPack(res)); |
| } |
| |
| } // namespace libtextclassifier2 |
| |
| #endif // FLATBUFFERS_GENERATED_MODEL_LIBTEXTCLASSIFIER2_H_ |
