$$CampusMapFloorsTableTableManager constructor

Implementation

$$CampusMapFloorsTableTableManager(
  _$AppDatabase db,
  $CampusMapFloorsTable table,
) : super(
      TableManagerState(
        db: db,
        table: table,
        createFilteringComposer: () =>
            $$CampusMapFloorsTableFilterComposer($db: db, $table: table),
        createOrderingComposer: () =>
            $$CampusMapFloorsTableOrderingComposer($db: db, $table: table),
        createComputedFieldComposer: () =>
            $$CampusMapFloorsTableAnnotationComposer($db: db, $table: table),
        updateCompanionCallback:
            ({
              Value<String> layerName = const Value.absent(),
              Value<String> building = const Value.absent(),
              Value<String> code = const Value.absent(),
              Value<DateTime?> fetchedAt = const Value.absent(),
              Value<int> rowid = const Value.absent(),
            }) => CampusMapFloorsCompanion(
              layerName: layerName,
              building: building,
              code: code,
              fetchedAt: fetchedAt,
              rowid: rowid,
            ),
        createCompanionCallback:
            ({
              required String layerName,
              required String building,
              required String code,
              Value<DateTime?> fetchedAt = const Value.absent(),
              Value<int> rowid = const Value.absent(),
            }) => CampusMapFloorsCompanion.insert(
              layerName: layerName,
              building: building,
              code: code,
              fetchedAt: fetchedAt,
              rowid: rowid,
            ),
        withReferenceMapper: (p0) => p0
            .map(
              (e) => (
                e.readTable<$CampusMapFloorsTable, MapFloorRecord>(table),
                $$CampusMapFloorsTableReferences(db, table, e),
              ),
            )
            .toList(),
        prefetchHooksCallback:
            ({building = false, campusMapRoomsRefs = false}) {
              return PrefetchHooks(
                db: db,
                explicitlyWatchedTables: [
                  if (campusMapRoomsRefs) db.campusMapRooms,
                ],
                addJoins:
                    <
                      T extends TableManagerState<
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic,
                        dynamic
                      >
                    >(state) {
                      if (building) {
                        state = state.withJoin(
                          currentTable: table,
                          currentColumn: table.building,
                          referencedTable: $$CampusMapFloorsTableReferences
                              ._buildingTable(db),
                          referencedColumn: $$CampusMapFloorsTableReferences
                              ._buildingTable(db)
                              .code,
                        ) as T;
                      }

                      return state;
                    },
                getPrefetchedDataCallback: (items) async {
                  return [
                    if (campusMapRoomsRefs)
                      await $_getPrefetchedData<
                        MapFloorRecord,
                        $CampusMapFloorsTable,
                        MapRoomRecord
                      >(
                        currentTable: table,
                        referencedTable: $$CampusMapFloorsTableReferences
                            ._campusMapRoomsRefsTable(db),
                        managerFromTypedResult: (p0) =>
                            $$CampusMapFloorsTableReferences(
                              db,
                              table,
                              p0,
                            ).campusMapRoomsRefs,
                        referencedItemsForCurrentItem:
                            (item, referencedItems) => referencedItems.where(
                              (e) => e.layerName == item.layerName,
                            ),
                        typedResults: items,
                      ),
                  ];
                },
              );
            },
      ),
    );