Erweiterungen

2024-03-15 09:40:13 +01:00
1 parent 88dc13391d
commit 75787d51ff
@@ -0,0 +1,662 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'log_entry.dart';
+
+// **************************************************************************
+// IsarCollectionGenerator
+// **************************************************************************
+
+// coverage:ignore-file
+// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types
+
+extension GetLogEntryCollection on Isar {
+  IsarCollection<LogEntry> get logEntrys => this.collection();
+}
+
+const LogEntrySchema = CollectionSchema(
+  name: r'LogEntry',
+  id: -8268688274231935295,
+  properties: {
+    r'severity': PropertySchema(
+      id: 0,
+      name: r'severity',
+      type: IsarType.byte,
+      enumMap: _LogEntryseverityEnumValueMap,
+    ),
+    r'text': PropertySchema(
+      id: 1,
+      name: r'text',
+      type: IsarType.string,
+    ),
+    r'time': PropertySchema(
+      id: 2,
+      name: r'time',
+      type: IsarType.dateTime,
+    )
+  },
+  estimateSize: _logEntryEstimateSize,
+  serialize: _logEntrySerialize,
+  deserialize: _logEntryDeserialize,
+  deserializeProp: _logEntryDeserializeProp,
+  idName: r'id',
+  indexes: {},
+  links: {},
+  embeddedSchemas: {},
+  getId: _logEntryGetId,
+  getLinks: _logEntryGetLinks,
+  attach: _logEntryAttach,
+  version: '3.1.0+1',
+);
+
+int _logEntryEstimateSize(
+  LogEntry object,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  var bytesCount = offsets.last;
+  bytesCount += 3 + object.text.length * 3;
+  return bytesCount;
+}
+
+void _logEntrySerialize(
+  LogEntry object,
+  IsarWriter writer,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  writer.writeByte(offsets[0], object.severity.index);
+  writer.writeString(offsets[1], object.text);
+  writer.writeDateTime(offsets[2], object.time);
+}
+
+LogEntry _logEntryDeserialize(
+  Id id,
+  IsarReader reader,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  final object = LogEntry();
+  object.id = id;
+  object.severity =
+      _LogEntryseverityValueEnumMap[reader.readByteOrNull(offsets[0])] ??
+          LogEntrySeverityEnum.info;
+  object.text = reader.readString(offsets[1]);
+  object.time = reader.readDateTime(offsets[2]);
+  return object;
+}
+
+P _logEntryDeserializeProp<P>(
+  IsarReader reader,
+  int propertyId,
+  int offset,
+  Map<Type, List<int>> allOffsets,
+) {
+  switch (propertyId) {
+    case 0:
+      return (_LogEntryseverityValueEnumMap[reader.readByteOrNull(offset)] ??
+          LogEntrySeverityEnum.info) as P;
+    case 1:
+      return (reader.readString(offset)) as P;
+    case 2:
+      return (reader.readDateTime(offset)) as P;
+    default:
+      throw IsarError('Unknown property with id $propertyId');
+  }
+}
+
+const _LogEntryseverityEnumValueMap = {
+  'info': 0,
+  'debug': 1,
+  'error': 2,
+};
+const _LogEntryseverityValueEnumMap = {
+  0: LogEntrySeverityEnum.info,
+  1: LogEntrySeverityEnum.debug,
+  2: LogEntrySeverityEnum.error,
+};
+
+Id _logEntryGetId(LogEntry object) {
+  return object.id;
+}
+
+List<IsarLinkBase<dynamic>> _logEntryGetLinks(LogEntry object) {
+  return [];
+}
+
+void _logEntryAttach(IsarCollection<dynamic> col, Id id, LogEntry object) {
+  object.id = id;
+}
+
+extension LogEntryQueryWhereSort on QueryBuilder<LogEntry, LogEntry, QWhere> {
+  QueryBuilder<LogEntry, LogEntry, QAfterWhere> anyId() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(const IdWhereClause.any());
+    });
+  }
+}
+
+extension LogEntryQueryWhere on QueryBuilder<LogEntry, LogEntry, QWhereClause> {
+  QueryBuilder<LogEntry, LogEntry, QAfterWhereClause> idEqualTo(Id id) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(IdWhereClause.between(
+        lower: id,
+        upper: id,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterWhereClause> idNotEqualTo(Id id) {
+    return QueryBuilder.apply(this, (query) {
+      if (query.whereSort == Sort.asc) {
+        return query
+            .addWhereClause(
+              IdWhereClause.lessThan(upper: id, includeUpper: false),
+            )
+            .addWhereClause(
+              IdWhereClause.greaterThan(lower: id, includeLower: false),
+            );
+      } else {
+        return query
+            .addWhereClause(
+              IdWhereClause.greaterThan(lower: id, includeLower: false),
+            )
+            .addWhereClause(
+              IdWhereClause.lessThan(upper: id, includeUpper: false),
+            );
+      }
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterWhereClause> idGreaterThan(Id id,
+      {bool include = false}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IdWhereClause.greaterThan(lower: id, includeLower: include),
+      );
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterWhereClause> idLessThan(Id id,
+      {bool include = false}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IdWhereClause.lessThan(upper: id, includeUpper: include),
+      );
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterWhereClause> idBetween(
+    Id lowerId,
+    Id upperId, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(IdWhereClause.between(
+        lower: lowerId,
+        includeLower: includeLower,
+        upper: upperId,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+}
+
+extension LogEntryQueryFilter
+    on QueryBuilder<LogEntry, LogEntry, QFilterCondition> {
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> idEqualTo(Id value) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'id',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> idGreaterThan(
+    Id value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'id',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> idLessThan(
+    Id value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'id',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> idBetween(
+    Id lower,
+    Id upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'id',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> severityEqualTo(
+      LogEntrySeverityEnum value) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'severity',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> severityGreaterThan(
+    LogEntrySeverityEnum value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'severity',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> severityLessThan(
+    LogEntrySeverityEnum value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'severity',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> severityBetween(
+    LogEntrySeverityEnum lower,
+    LogEntrySeverityEnum upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'severity',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textEqualTo(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'text',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textGreaterThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'text',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textLessThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'text',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textBetween(
+    String lower,
+    String upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'text',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textStartsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.startsWith(
+        property: r'text',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textEndsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.endsWith(
+        property: r'text',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textContains(
+      String value,
+      {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.contains(
+        property: r'text',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textMatches(
+      String pattern,
+      {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.matches(
+        property: r'text',
+        wildcard: pattern,
+        caseSensitive: caseSensitive,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'text',
+        value: '',
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> textIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        property: r'text',
+        value: '',
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> timeEqualTo(
+      DateTime value) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'time',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> timeGreaterThan(
+    DateTime value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'time',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> timeLessThan(
+    DateTime value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'time',
+        value: value,
+      ));
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterFilterCondition> timeBetween(
+    DateTime lower,
+    DateTime upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'time',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
+    });
+  }
+}
+
+extension LogEntryQueryObject
+    on QueryBuilder<LogEntry, LogEntry, QFilterCondition> {}
+
+extension LogEntryQueryLinks
+    on QueryBuilder<LogEntry, LogEntry, QFilterCondition> {}
+
+extension LogEntryQuerySortBy on QueryBuilder<LogEntry, LogEntry, QSortBy> {
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> sortBySeverity() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'severity', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> sortBySeverityDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'severity', Sort.desc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> sortByText() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'text', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> sortByTextDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'text', Sort.desc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> sortByTime() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'time', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> sortByTimeDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'time', Sort.desc);
+    });
+  }
+}
+
+extension LogEntryQuerySortThenBy
+    on QueryBuilder<LogEntry, LogEntry, QSortThenBy> {
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenById() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'id', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenByIdDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'id', Sort.desc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenBySeverity() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'severity', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenBySeverityDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'severity', Sort.desc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenByText() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'text', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenByTextDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'text', Sort.desc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenByTime() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'time', Sort.asc);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QAfterSortBy> thenByTimeDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'time', Sort.desc);
+    });
+  }
+}
+
+extension LogEntryQueryWhereDistinct
+    on QueryBuilder<LogEntry, LogEntry, QDistinct> {
+  QueryBuilder<LogEntry, LogEntry, QDistinct> distinctBySeverity() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'severity');
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QDistinct> distinctByText(
+      {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'text', caseSensitive: caseSensitive);
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntry, QDistinct> distinctByTime() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'time');
+    });
+  }
+}
+
+extension LogEntryQueryProperty
+    on QueryBuilder<LogEntry, LogEntry, QQueryProperty> {
+  QueryBuilder<LogEntry, int, QQueryOperations> idProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'id');
+    });
+  }
+
+  QueryBuilder<LogEntry, LogEntrySeverityEnum, QQueryOperations>
+      severityProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'severity');
+    });
+  }
+
+  QueryBuilder<LogEntry, String, QQueryOperations> textProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'text');
+    });
+  }
+
+  QueryBuilder<LogEntry, DateTime, QQueryOperations> timeProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'time');
+    });
+  }
+}
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+LogEntry _$LogEntryFromJson(Map<String, dynamic> json) => LogEntry()
+  ..id = json['id'] as int
+  ..time = DateTime.parse(json['time'] as String)
+  ..severity = $enumDecode(_$LogEntrySeverityEnumEnumMap, json['severity'])
+  ..text = json['text'] as String;
+
+Map<String, dynamic> _$LogEntryToJson(LogEntry instance) => <String, dynamic>{
+      'id': instance.id,
+      'time': instance.time.toIso8601String(),
+      'severity': _$LogEntrySeverityEnumEnumMap[instance.severity]!,
+      'text': instance.text,
+    };
+
+const _$LogEntrySeverityEnumEnumMap = {
+  LogEntrySeverityEnum.info: 'info',
+  LogEntrySeverityEnum.debug: 'debug',
+  LogEntrySeverityEnum.error: 'error',
+};