> allOffsets,
+) {
+ final object = PreviousPlaylistMusics(
+ id: id,
+ musics: reader.readStringList(offsets[0]),
+ );
+ return object;
+}
+
+P _previousPlaylistMusicsDeserializeProp(
+ IsarReader reader,
+ int propertyId,
+ int offset,
+ Map> allOffsets,
+) {
+ switch (propertyId) {
+ case 0:
+ return (reader.readStringList(offset)) as P;
+ default:
+ throw IsarError('Unknown property with id $propertyId');
+ }
+}
+
+Id _previousPlaylistMusicsGetId(PreviousPlaylistMusics object) {
+ return object.id;
+}
+
+List> _previousPlaylistMusicsGetLinks(
+ PreviousPlaylistMusics object,
+) {
+ return [];
+}
+
+void _previousPlaylistMusicsAttach(
+ IsarCollection col,
+ Id id,
+ PreviousPlaylistMusics object,
+) {
+ object.id = id;
+}
+
+extension PreviousPlaylistMusicsQueryWhereSort
+ on QueryBuilder {
+ QueryBuilder
+ anyId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(const IdWhereClause.any());
+ });
+ }
+}
+
+extension PreviousPlaylistMusicsQueryWhere
+ on
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QWhereClause
+ > {
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterWhereClause
+ >
+ idEqualTo(Id id) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ 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<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterWhereClause
+ >
+ idGreaterThan(Id id, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.greaterThan(lower: id, includeLower: include),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterWhereClause
+ >
+ idLessThan(Id id, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.lessThan(upper: id, includeUpper: include),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ 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 PreviousPlaylistMusicsQueryFilter
+ on
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QFilterCondition
+ > {
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ idEqualTo(Id value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'id', value: value),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ 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<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ 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<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ 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<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsIsNull() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ const FilterCondition.isNull(property: r'musics'),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsIsNotNull() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ const FilterCondition.isNotNull(property: r'musics'),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementEqualTo(String value, {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(
+ property: r'musics',
+ value: value,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementGreaterThan(
+ String value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(
+ include: include,
+ property: r'musics',
+ value: value,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementLessThan(
+ String value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.lessThan(
+ include: include,
+ property: r'musics',
+ value: value,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementBetween(
+ 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'musics',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementStartsWith(String value, {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.startsWith(
+ property: r'musics',
+ value: value,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementEndsWith(String value, {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.endsWith(
+ property: r'musics',
+ value: value,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementContains(String value, {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.contains(
+ property: r'musics',
+ value: value,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementMatches(String pattern, {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.matches(
+ property: r'musics',
+ wildcard: pattern,
+ caseSensitive: caseSensitive,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'musics', value: ''),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsElementIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(property: r'musics', value: ''),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsLengthEqualTo(int length) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(r'musics', length, true, length, true);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(r'musics', 0, true, 0, true);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(r'musics', 0, false, 999999, true);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsLengthLessThan(int length, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(r'musics', 0, true, length, include);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsLengthGreaterThan(int length, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(r'musics', length, include, 999999, true);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QAfterFilterCondition
+ >
+ musicsLengthBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'musics',
+ lower,
+ includeLower,
+ upper,
+ includeUpper,
+ );
+ });
+ }
+}
+
+extension PreviousPlaylistMusicsQueryObject
+ on
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QFilterCondition
+ > {}
+
+extension PreviousPlaylistMusicsQueryLinks
+ on
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QFilterCondition
+ > {}
+
+extension PreviousPlaylistMusicsQuerySortBy
+ on QueryBuilder {}
+
+extension PreviousPlaylistMusicsQuerySortThenBy
+ on
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QSortThenBy
+ > {
+ QueryBuilder
+ thenById() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ thenByIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.desc);
+ });
+ }
+}
+
+extension PreviousPlaylistMusicsQueryWhereDistinct
+ on QueryBuilder {
+ QueryBuilder
+ distinctByMusics() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'musics');
+ });
+ }
+}
+
+extension PreviousPlaylistMusicsQueryProperty
+ on
+ QueryBuilder<
+ PreviousPlaylistMusics,
+ PreviousPlaylistMusics,
+ QQueryProperty
+ > {
+ QueryBuilder idProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'id');
+ });
+ }
+
+ QueryBuilder?, QQueryOperations>
+ musicsProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'musics');
+ });
+ }
+}
+
+// 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 GetPreviousPlaylistCurrentIndexCollection on Isar {
+ IsarCollection
+ get previousPlaylistCurrentIndexs => this.collection();
+}
+
+const PreviousPlaylistCurrentIndexSchema = CollectionSchema(
+ name: r'PreviousPlaylistCurrentIndex',
+ id: -9036091697598573141,
+ properties: {
+ r'currentIndex': PropertySchema(
+ id: 0,
+ name: r'currentIndex',
+ type: IsarType.long,
+ ),
+ r'mediaId': PropertySchema(id: 1, name: r'mediaId', type: IsarType.long),
+ },
+ estimateSize: _previousPlaylistCurrentIndexEstimateSize,
+ serialize: _previousPlaylistCurrentIndexSerialize,
+ deserialize: _previousPlaylistCurrentIndexDeserialize,
+ deserializeProp: _previousPlaylistCurrentIndexDeserializeProp,
+ idName: r'id',
+ indexes: {},
+ links: {},
+ embeddedSchemas: {},
+ getId: _previousPlaylistCurrentIndexGetId,
+ getLinks: _previousPlaylistCurrentIndexGetLinks,
+ attach: _previousPlaylistCurrentIndexAttach,
+ version: '3.1.0',
+);
+
+int _previousPlaylistCurrentIndexEstimateSize(
+ PreviousPlaylistCurrentIndex object,
+ List offsets,
+ Map> allOffsets,
+) {
+ var bytesCount = offsets.last;
+ return bytesCount;
+}
+
+void _previousPlaylistCurrentIndexSerialize(
+ PreviousPlaylistCurrentIndex object,
+ IsarWriter writer,
+ List offsets,
+ Map> allOffsets,
+) {
+ writer.writeLong(offsets[0], object.currentIndex);
+ writer.writeLong(offsets[1], object.mediaId);
+}
+
+PreviousPlaylistCurrentIndex _previousPlaylistCurrentIndexDeserialize(
+ Id id,
+ IsarReader reader,
+ List offsets,
+ Map> allOffsets,
+) {
+ final object = PreviousPlaylistCurrentIndex(
+ currentIndex: reader.readLongOrNull(offsets[0]),
+ id: id,
+ mediaId: reader.readLong(offsets[1]),
+ );
+ return object;
+}
+
+P _previousPlaylistCurrentIndexDeserializeProp(
+ IsarReader reader,
+ int propertyId,
+ int offset,
+ Map> allOffsets,
+) {
+ switch (propertyId) {
+ case 0:
+ return (reader.readLongOrNull(offset)) as P;
+ case 1:
+ return (reader.readLong(offset)) as P;
+ default:
+ throw IsarError('Unknown property with id $propertyId');
+ }
+}
+
+Id _previousPlaylistCurrentIndexGetId(PreviousPlaylistCurrentIndex object) {
+ return object.id;
+}
+
+List> _previousPlaylistCurrentIndexGetLinks(
+ PreviousPlaylistCurrentIndex object,
+) {
+ return [];
+}
+
+void _previousPlaylistCurrentIndexAttach(
+ IsarCollection col,
+ Id id,
+ PreviousPlaylistCurrentIndex object,
+) {
+ object.id = id;
+}
+
+extension PreviousPlaylistCurrentIndexQueryWhereSort
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QWhere
+ > {
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterWhere
+ >
+ anyId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(const IdWhereClause.any());
+ });
+ }
+}
+
+extension PreviousPlaylistCurrentIndexQueryWhere
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QWhereClause
+ > {
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterWhereClause
+ >
+ idEqualTo(Id id) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ 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<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterWhereClause
+ >
+ idGreaterThan(Id id, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.greaterThan(lower: id, includeLower: include),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterWhereClause
+ >
+ idLessThan(Id id, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.lessThan(upper: id, includeUpper: include),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ 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 PreviousPlaylistCurrentIndexQueryFilter
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QFilterCondition
+ > {
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ currentIndexIsNull() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ const FilterCondition.isNull(property: r'currentIndex'),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ currentIndexIsNotNull() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ const FilterCondition.isNotNull(property: r'currentIndex'),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ currentIndexEqualTo(int? value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'currentIndex', value: value),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ currentIndexGreaterThan(int? value, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(
+ include: include,
+ property: r'currentIndex',
+ value: value,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ currentIndexLessThan(int? value, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.lessThan(
+ include: include,
+ property: r'currentIndex',
+ value: value,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ currentIndexBetween(
+ int? lower,
+ int? upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.between(
+ property: r'currentIndex',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ idEqualTo(Id value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'id', value: value),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ 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<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ 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<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ 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<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ mediaIdEqualTo(int value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'mediaId', value: value),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ mediaIdGreaterThan(int value, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(
+ include: include,
+ property: r'mediaId',
+ value: value,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ mediaIdLessThan(int value, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.lessThan(
+ include: include,
+ property: r'mediaId',
+ value: value,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterFilterCondition
+ >
+ mediaIdBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.between(
+ property: r'mediaId',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ),
+ );
+ });
+ }
+}
+
+extension PreviousPlaylistCurrentIndexQueryObject
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QFilterCondition
+ > {}
+
+extension PreviousPlaylistCurrentIndexQueryLinks
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QFilterCondition
+ > {}
+
+extension PreviousPlaylistCurrentIndexQuerySortBy
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QSortBy
+ > {
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ sortByCurrentIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'currentIndex', Sort.asc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ sortByCurrentIndexDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'currentIndex', Sort.desc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ sortByMediaId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.asc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ sortByMediaIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.desc);
+ });
+ }
+}
+
+extension PreviousPlaylistCurrentIndexQuerySortThenBy
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QSortThenBy
+ > {
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ thenByCurrentIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'currentIndex', Sort.asc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ thenByCurrentIndexDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'currentIndex', Sort.desc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ thenById() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.asc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ thenByIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.desc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ thenByMediaId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.asc);
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QAfterSortBy
+ >
+ thenByMediaIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.desc);
+ });
+ }
+}
+
+extension PreviousPlaylistCurrentIndexQueryWhereDistinct
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QDistinct
+ > {
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QDistinct
+ >
+ distinctByCurrentIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'currentIndex');
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QDistinct
+ >
+ distinctByMediaId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'mediaId');
+ });
+ }
+}
+
+extension PreviousPlaylistCurrentIndexQueryProperty
+ on
+ QueryBuilder<
+ PreviousPlaylistCurrentIndex,
+ PreviousPlaylistCurrentIndex,
+ QQueryProperty
+ > {
+ QueryBuilder
+ idProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'id');
+ });
+ }
+
+ QueryBuilder
+ currentIndexProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'currentIndex');
+ });
+ }
+
+ QueryBuilder
+ mediaIdProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'mediaId');
+ });
+ }
+}
+
+// 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 GetPreviousPlaylistPositionCollection on Isar {
+ IsarCollection get previousPlaylistPositions =>
+ this.collection();
+}
+
+const PreviousPlaylistPositionSchema = CollectionSchema(
+ name: r'PreviousPlaylistPosition',
+ id: 4468986416954213317,
+ properties: {
+ r'duration': PropertySchema(
+ id: 0,
+ name: r'duration',
+ type: IsarType.double,
+ ),
+ r'mediaId': PropertySchema(id: 1, name: r'mediaId', type: IsarType.long),
+ r'position': PropertySchema(
+ id: 2,
+ name: r'position',
+ type: IsarType.double,
+ ),
+ },
+ estimateSize: _previousPlaylistPositionEstimateSize,
+ serialize: _previousPlaylistPositionSerialize,
+ deserialize: _previousPlaylistPositionDeserialize,
+ deserializeProp: _previousPlaylistPositionDeserializeProp,
+ idName: r'id',
+ indexes: {},
+ links: {},
+ embeddedSchemas: {},
+ getId: _previousPlaylistPositionGetId,
+ getLinks: _previousPlaylistPositionGetLinks,
+ attach: _previousPlaylistPositionAttach,
+ version: '3.1.0',
+);
+
+int _previousPlaylistPositionEstimateSize(
+ PreviousPlaylistPosition object,
+ List offsets,
+ Map> allOffsets,
+) {
+ var bytesCount = offsets.last;
+ return bytesCount;
+}
+
+void _previousPlaylistPositionSerialize(
+ PreviousPlaylistPosition object,
+ IsarWriter writer,
+ List offsets,
+ Map> allOffsets,
+) {
+ writer.writeDouble(offsets[0], object.duration);
+ writer.writeLong(offsets[1], object.mediaId);
+ writer.writeDouble(offsets[2], object.position);
+}
+
+PreviousPlaylistPosition _previousPlaylistPositionDeserialize(
+ Id id,
+ IsarReader reader,
+ List offsets,
+ Map> allOffsets,
+) {
+ final object = PreviousPlaylistPosition(
+ duration: reader.readDouble(offsets[0]),
+ id: id,
+ mediaId: reader.readLong(offsets[1]),
+ position: reader.readDouble(offsets[2]),
+ );
+ return object;
+}
+
+P _previousPlaylistPositionDeserializeProp(
+ IsarReader reader,
+ int propertyId,
+ int offset,
+ Map> allOffsets,
+) {
+ switch (propertyId) {
+ case 0:
+ return (reader.readDouble(offset)) as P;
+ case 1:
+ return (reader.readLong(offset)) as P;
+ case 2:
+ return (reader.readDouble(offset)) as P;
+ default:
+ throw IsarError('Unknown property with id $propertyId');
+ }
+}
+
+Id _previousPlaylistPositionGetId(PreviousPlaylistPosition object) {
+ return object.id;
+}
+
+List> _previousPlaylistPositionGetLinks(
+ PreviousPlaylistPosition object,
+) {
+ return [];
+}
+
+void _previousPlaylistPositionAttach(
+ IsarCollection col,
+ Id id,
+ PreviousPlaylistPosition object,
+) {
+ object.id = id;
+}
+
+extension PreviousPlaylistPositionQueryWhereSort
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QWhere
+ > {
+ QueryBuilder
+ anyId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(const IdWhereClause.any());
+ });
+ }
+}
+
+extension PreviousPlaylistPositionQueryWhere
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QWhereClause
+ > {
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterWhereClause
+ >
+ idEqualTo(Id id) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ 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<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterWhereClause
+ >
+ idGreaterThan(Id id, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.greaterThan(lower: id, includeLower: include),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterWhereClause
+ >
+ idLessThan(Id id, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.lessThan(upper: id, includeUpper: include),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ 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 PreviousPlaylistPositionQueryFilter
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QFilterCondition
+ > {
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ durationEqualTo(double value, {double epsilon = Query.epsilon}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(
+ property: r'duration',
+ value: value,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ durationGreaterThan(
+ double value, {
+ bool include = false,
+ double epsilon = Query.epsilon,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(
+ include: include,
+ property: r'duration',
+ value: value,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ durationLessThan(
+ double value, {
+ bool include = false,
+ double epsilon = Query.epsilon,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.lessThan(
+ include: include,
+ property: r'duration',
+ value: value,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ durationBetween(
+ double lower,
+ double upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ double epsilon = Query.epsilon,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.between(
+ property: r'duration',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ idEqualTo(Id value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'id', value: value),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ 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<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ 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<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ 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<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ mediaIdEqualTo(int value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(property: r'mediaId', value: value),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ mediaIdGreaterThan(int value, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(
+ include: include,
+ property: r'mediaId',
+ value: value,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ mediaIdLessThan(int value, {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.lessThan(
+ include: include,
+ property: r'mediaId',
+ value: value,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ mediaIdBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.between(
+ property: r'mediaId',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ positionEqualTo(double value, {double epsilon = Query.epsilon}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.equalTo(
+ property: r'position',
+ value: value,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ positionGreaterThan(
+ double value, {
+ bool include = false,
+ double epsilon = Query.epsilon,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.greaterThan(
+ include: include,
+ property: r'position',
+ value: value,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ positionLessThan(
+ double value, {
+ bool include = false,
+ double epsilon = Query.epsilon,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.lessThan(
+ include: include,
+ property: r'position',
+ value: value,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QAfterFilterCondition
+ >
+ positionBetween(
+ double lower,
+ double upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ double epsilon = Query.epsilon,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(
+ FilterCondition.between(
+ property: r'position',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ epsilon: epsilon,
+ ),
+ );
+ });
+ }
+}
+
+extension PreviousPlaylistPositionQueryObject
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QFilterCondition
+ > {}
+
+extension PreviousPlaylistPositionQueryLinks
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QFilterCondition
+ > {}
+
+extension PreviousPlaylistPositionQuerySortBy
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QSortBy
+ > {
+ QueryBuilder
+ sortByDuration() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'duration', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ sortByDurationDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'duration', Sort.desc);
+ });
+ }
+
+ QueryBuilder
+ sortByMediaId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ sortByMediaIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.desc);
+ });
+ }
+
+ QueryBuilder
+ sortByPosition() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'position', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ sortByPositionDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'position', Sort.desc);
+ });
+ }
+}
+
+extension PreviousPlaylistPositionQuerySortThenBy
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QSortThenBy
+ > {
+ QueryBuilder
+ thenByDuration() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'duration', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ thenByDurationDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'duration', Sort.desc);
+ });
+ }
+
+ QueryBuilder
+ thenById() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ thenByIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.desc);
+ });
+ }
+
+ QueryBuilder
+ thenByMediaId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ thenByMediaIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'mediaId', Sort.desc);
+ });
+ }
+
+ QueryBuilder
+ thenByPosition() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'position', Sort.asc);
+ });
+ }
+
+ QueryBuilder
+ thenByPositionDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'position', Sort.desc);
+ });
+ }
+}
+
+extension PreviousPlaylistPositionQueryWhereDistinct
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QDistinct
+ > {
+ QueryBuilder
+ distinctByDuration() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'duration');
+ });
+ }
+
+ QueryBuilder
+ distinctByMediaId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'mediaId');
+ });
+ }
+
+ QueryBuilder
+ distinctByPosition() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'position');
+ });
+ }
+}
+
+extension PreviousPlaylistPositionQueryProperty
+ on
+ QueryBuilder<
+ PreviousPlaylistPosition,
+ PreviousPlaylistPosition,
+ QQueryProperty
+ > {
+ QueryBuilder idProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'id');
+ });
+ }
+
+ QueryBuilder
+ durationProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'duration');
+ });
+ }
+
+ QueryBuilder
+ mediaIdProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'mediaId');
+ });
+ }
+
+ QueryBuilder
+ positionProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'position');
+ });
+ }
+}
diff --git a/packages/player/lib/src/queue_item.dart b/packages/player/lib/src/models/queue_item.dart
similarity index 89%
rename from packages/player/lib/src/queue_item.dart
rename to packages/player/lib/src/models/queue_item.dart
index 7647a178..83540a6a 100644
--- a/packages/player/lib/src/queue_item.dart
+++ b/packages/player/lib/src/models/queue_item.dart
@@ -16,11 +16,7 @@ class QueueItem {
@override
int get hashCode => [originalPosition, position, item].hashCode;
- QueueItem copyWith({
- int? originalPosition,
- int? position,
- T? item,
- }) {
+ QueueItem copyWith({int? originalPosition, int? position, T? item}) {
return QueueItem(
originalPosition ?? this.originalPosition,
position ?? this.position,
diff --git a/packages/player/lib/src/player.dart b/packages/player/lib/src/player.dart
deleted file mode 100644
index e8738172..00000000
--- a/packages/player/lib/src/player.dart
+++ /dev/null
@@ -1,857 +0,0 @@
-import 'dart:async';
-import 'dart:math';
-import 'package:flutter/foundation.dart';
-import 'package:smaws/aws.dart';
-import 'package:flutter/services.dart';
-import 'package:smplayer/src/event.dart';
-import 'package:smplayer/src/event_type.dart';
-import 'package:smplayer/src/isar_service.dart';
-import 'package:smplayer/src/media.dart';
-import 'package:smplayer/src/duration_change_event.dart';
-import 'package:smplayer/src/position_change_event.dart';
-import 'package:smplayer/src/previous_playlist_model.dart';
-import 'package:smplayer/src/queue.dart';
-import 'package:smplayer/src/repeat_mode.dart';
-import 'package:mutex/mutex.dart';
-
-import 'player_state.dart';
-
-class Player {
- Player({
- required this.playerId,
- required this.cookieSigner,
- required this.localMediaValidator,
- this.initializeIsar = false,
- this.autoPlay = false,
- }) {
- _queue = Queue(
- beforeInitialize: () async => await _channel.invokeMethod('remove_all'),
- initializeIsar: this.initializeIsar,
- onInitialize: () async {
- await enqueueAll(
- items,
- alreadyAddedToStorage: true,
- shouldNotifyTransition: false,
- );
- },
- );
- player = this;
- }
- static const Ok = 1;
- static const NotOk = -1;
- static const CHANNEL = 'suamusica.com.br/player';
- static final MethodChannel _channel = const MethodChannel(CHANNEL)
- ..setMethodCallHandler(platformCallHandler);
-
- static late Player player;
- static bool logEnabled = false;
-
- bool _shallSendEvents = true;
- bool initializeIsar;
- bool externalPlayback = false;
- bool get itemsReady => _queue.itemsReady;
-
- CookiesForCustomPolicy? _cookies;
- PlayerState state = PlayerState.IDLE;
- static late Queue _queue;
- static RepeatMode _repeatMode = RepeatMode.REPEAT_MODE_OFF;
- static bool _shuffleEnabled = false;
- static int _idSum = 0;
- final mutex = Mutex();
-
- final String playerId;
-
- int get idSum => _idSum;
- set idSum(int value) => _idSum = value;
- bool get isShuffleEnabled => _shuffleEnabled;
- RepeatMode get repeatMode => _repeatMode;
-
- set setShuffleEnabled(bool value) => _shuffleEnabled = value;
- set repeatMode(RepeatMode value) => _repeatMode = value;
-
- final StreamController _eventStreamController =
- StreamController();
-
- final Future Function() cookieSigner;
- final String? Function(Media)? localMediaValidator;
- final bool autoPlay;
- final chromeCastEnabledEvents = [
- EventType.BEFORE_PLAY,
- EventType.NEXT,
- EventType.PREVIOUS,
- EventType.POSITION_CHANGE,
- EventType.REWIND,
- EventType.PLAY_REQUESTED,
- EventType.PAUSED,
- EventType.PLAYING,
- EventType.EXTERNAL_RESUME_REQUESTED,
- EventType.EXTERNAL_PAUSE_REQUESTED,
- EventType.SET_CURRENT_MEDIA_INDEX
- ];
-
- Stream? _stream;
-
- Stream get onEvent {
- _stream ??= _eventStreamController.stream.asBroadcastStream();
- return _stream!;
- }
-
- Future _invokeMethod(
- String method, [
- Map? arguments,
- ]) async {
- if (!_shallSendEvents) {
- return NotOk;
- }
- arguments ??= const {};
- final Map args = Map.of(arguments)
- ..['playerId'] = playerId
- ..['shallSendEvents'] = _shallSendEvents
- ..['externalplayback'] = externalPlayback;
-
- return _channel
- .invokeMethod(method, args)
- .then((result) => result ?? Future.value(Ok));
- }
-
- set setQueuePosition(int position) {
- _queue.setIndex = position;
- }
-
- Future updateMediaUri({required int id, String? uri}) async {
- _channel.invokeMethod('update_media_uri', {
- 'id': id,
- 'uri': uri,
- });
- return Ok;
- }
-
- Future removeNotification() async {
- await _channel.invokeMethod('remove_notification');
- return Ok;
- }
-
- Future enqueueAll(
- List items, {
- bool autoPlay = false,
- bool saveOnTop = false,
- bool alreadyAddedToStorage = false,
- bool shouldNotifyTransition = true,
- }) async {
- if (!alreadyAddedToStorage) {
- _queue.addAll(items, saveOnTop: saveOnTop);
- }
- if (_cookies == null || !_cookies!.isValid) {
- _log("Generating Cookies");
- _cookies = await cookieSigner();
- }
- String cookie = _cookies!.toHeaders();
- final int batchSize = 80;
- _idSum = 0;
- final List> batchArgs = items.map(
- (media) {
- _idSum += media.id;
- final localPath = localMediaValidator?.call(media);
- return {
- ...media
- .copyWith(
- url: localPath ?? media.url,
- )
- .toJson(),
- };
- },
- ).toList();
- for (int i = 0; i < batchArgs.length; i += batchSize) {
- final batch = batchArgs.sublist(i, min(i + batchSize, batchArgs.length));
- unawaited(
- _channel.invokeMethod(
- 'enqueue',
- {
- 'batch': batch,
- 'autoPlay': autoPlay,
- 'playerId': playerId,
- 'shallSendEvents': _shallSendEvents,
- 'externalplayback': externalPlayback,
- 'shouldNotifyTransition':
- batch.length > 1 ? false : shouldNotifyTransition,
- if (i == 0) ...{
- 'cookie': cookie,
- },
- },
- ),
- );
- }
-
- return Ok;
- }
-
- List organizeLists(
- bool saveOnTop,
- List items,
- List medias,
- ) {
- final List topList = saveOnTop ? medias : items;
- final List bottomList = saveOnTop ? items : medias;
-
- return [
- ...topList.toListStringCompressed,
- ...bottomList.toListStringCompressed
- ];
- }
-
- int removeByPosition({
- required List positionsToDelete,
- }) {
- _channel.invokeMethod('remove_in', {'indexesToDelete': positionsToDelete});
-
- return _queue.removeByPosition(
- positionsToDelete: positionsToDelete,
- isShuffle: isShuffleEnabled,
- );
- }
-
- Future removeAll() async {
- _queue.clear();
- setQueuePosition = 0;
- await IsarService.instance.removeAllMusics();
- _channel.invokeMethod('remove_all');
- return Ok;
- }
-
- Future adsPlaying() async {
- await _invokeMethod('ads_playing');
- return Ok;
- }
-
- int enableEvents() {
- this._shallSendEvents = true;
- return Ok;
- }
-
- int disableEvents() {
- this._shallSendEvents = false;
- return Ok;
- }
-
- Future restartQueue() async {
- final media = _queue.restart();
- return media;
- }
-
- Future reorder(
- int oldIndex,
- int newIndex,
- ) async {
- _queue.reorder(oldIndex, newIndex, isShuffleEnabled);
- debugPrint('#_queue.reorder: ${getPositionsList()}');
- _channel.invokeMethod('reorder', {
- 'oldIndex': oldIndex,
- 'newIndex': newIndex,
- 'positionsList': getPositionsList(),
- });
- return Ok;
- }
-
- Future clear() async => removeAll();
-
- Media? get currentMedia => _queue.current;
-
- int get previousPlaylistIndex => _queue.previousIndex;
- PreviousPlaylistPosition? get previousPlaylistPosition =>
- _queue.previousPosition;
-
- List get items => _queue.items;
- int get size => items.length;
-
- int get currentIndex => _queue.index;
-
- Future play({bool shouldPrepare = false}) async {
- await _invokeMethod(
- 'play',
- {
- 'shouldPrepare': shouldPrepare,
- },
- );
- return Ok;
- }
-
- Future disableNotificatonCommands() async {
- await _invokeMethod('disable_notification_commands');
- return Ok;
- }
-
- Future enableNotificatonCommands() async {
- await _invokeMethod('enable_notification_commands');
- return Ok;
- }
-
- Future playFromQueue(
- int pos, {
- Duration? position,
- bool loadOnly = false,
- }) async {
- if (!loadOnly) {
- _notifyPlayerStatusChangeEvent(EventType.PLAY_REQUESTED);
- }
- if (repeatMode == RepeatMode.REPEAT_MODE_ONE) {
- setRepeatMode("all");
- }
- return _channel.invokeMethod('playFromQueue', {
- 'position': pos,
- 'timePosition': position?.inMilliseconds,
- 'loadOnly': loadOnly,
- }).then((result) => result);
- }
-
- List> getPositionsList() {
- return [
- for (var item in _queue.storage)
- {
- 'originalPosition': item.originalPosition,
- }
- ];
- }
-
- Future forward() async {
- if (currentMedia == null) {
- return NotOk;
- }
- return _forward(currentMedia);
- }
-
- Future _forward(Media? media) async {
- if (media == null) {
- return NotOk;
- }
- final duration = Duration(milliseconds: await getDuration());
- _notifyPositionChangeEvent(this, duration, duration);
- _notifyForward(media);
- return stop();
- }
-
- Future toggleRepeatMode() async {
- return _channel.invokeMethod('repeat_mode').then((result) => result);
- }
-
- Future setRepeatMode(String mode) async {
- return _channel.invokeMethod(
- 'set_repeat_mode', {'mode': mode}).then((result) => result);
- }
-
- Future disableRepeatMode() async {
- return _channel
- .invokeMethod('disable_repeat_mode')
- .then((result) => result);
- }
-
- Future previous({bool isFromChromecast = false}) async {
- if (_queue.shouldRewind()) {
- seek(Duration(milliseconds: 0));
- print("#APP LOGS ==> shouldRewind");
- return Ok;
- }
-
- Media? media = _queue.possiblePrevious();
- if (isFromChromecast && media != null) {
- return _queue.items.indexOf(media);
- }
- if (media == null) {
- return null;
- }
- if (repeatMode == RepeatMode.REPEAT_MODE_ONE) {
- setRepeatMode("all");
- }
- return await _invokeMethod('previous');
- }
-
- Future next({bool isFromChromecast = false}) async {
- final media = _queue.possibleNext(repeatMode);
- if (isFromChromecast && media != null) {
- return _queue.items.indexOf(media);
- }
- if (media != null) {
- if (repeatMode == RepeatMode.REPEAT_MODE_ONE) {
- setRepeatMode("all");
- }
- return _invokeMethod('next');
- } else {
- return null;
- }
- }
-
- Future updateNotification({
- required bool isFavorite,
- required int id,
- }) async {
- return _channel.invokeMethod('update_notification', {
- 'isFavorite': isFavorite,
- 'idFavorite': id,
- }).then((result) => result);
- }
-
- Future pause() async {
- _notifyPlayerStatusChangeEvent(EventType.PAUSE_REQUEST);
- return await _invokeMethod('pause');
- }
-
- void addUsingPlayer(Event event) => _addUsingPlayer(player, event);
-
- Future stop() async {
- // _notifyPlayerStatusChangeEvent(EventType.STOP_REQUESTED);
- // final int result = await _invokeMethod('stop');
-
- // if (result == Ok) {
- // state = PlayerState.STOPPED;
- // _notifyPlayerStatusChangeEvent(EventType.STOPPED);
- // }
-
- // return result;
- return Ok;
- }
-
- Future release() async {
- _notifyPlayerStatusChangeEvent(EventType.RELEASE_REQUESTED);
- final int result = await _invokeMethod('release');
-
- if (result == Ok) {
- state = PlayerState.STOPPED;
- _notifyPlayerStatusChangeEvent(EventType.RELEASED);
- }
- _queue.dispose();
- return result;
- }
-
- Future toggleShuffle() async {
- if (!isShuffleEnabled) {
- _queue.shuffle();
- } else {
- _queue.unshuffle();
- }
- debugPrint('#_queue.shuffle: ${getPositionsList()}');
- _channel
- .invokeMethod('toggle_shuffle', {'positionsList': getPositionsList()});
- }
-
- Future