import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public synchronized static StorIOSQLite get(Context context) {
    if (INSTANCE != null) {
        return INSTANCE;
    }

    INSTANCE = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new StorIODbHelper(context))
            .addTypeMapping(StockUpdate.class, SQLiteTypeMapping.<StockUpdate>builder()
                    .putResolver(new StockUpdatePutResolver())
                    .getResolver(new StockUpdateGetResolver())
                    .deleteResolver(new StockUpdateDeleteResolver())
                    .build())
            .build();

    return INSTANCE;
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public synchronized static StorIOSQLite get(Context context) {
    if (INSTANCE != null) {
        return INSTANCE;
    }

    INSTANCE = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new StorIODbHelper(context))
            .addTypeMapping(StockUpdate.class, SQLiteTypeMapping.<StockUpdate>builder()
                    .putResolver(new StockUpdatePutResolver())
                    .getResolver(createGetResolver())
                    .deleteResolver(createDeleteResolver())
                    .build())
            .build();

    return INSTANCE;
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
/**
 * Initializes StorIO with all necessary resolvers
 */
private void initStorIO() {
    mStorIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new DbOpenHelper(this))
            .addTypeMapping(CommLinkModel.class, new CommLinkModelSQLiteTypeMapping())
            .addTypeMapping(ContentBlock1.class, new ContentBlock1SQLiteTypeMapping())
            .addTypeMapping(ContentBlock2.class, new ContentBlock2SQLiteTypeMapping())
            .addTypeMapping(ContentBlock4.class, new ContentBlock4SQLiteTypeMapping())
            .addTypeMapping(Wrapper.class, SQLiteTypeMapping.<Wrapper>builder()
                    .putResolver(new WrapperStorIOSQLitePutResolver())
                    .getResolver(new ContentWrapperGetResolver())
                    .deleteResolver(new WrapperStorIOSQLiteDeleteResolver())
                    .build())
            .addTypeMapping(UserSearchHistoryEntry.class, new UserSearchHistoryEntrySQLiteTypeMapping())
            .addTypeMapping(Forum.class, new ForumSQLiteTypeMapping())
            .addTypeMapping(Favorite.class, new FavoriteSQLiteTypeMapping())
            .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void pushNewUserSearchToDb(UserSearchHistoryEntry e) {
    // TODO: Add logic to the method to delete oldest entry if we have more entries than defined in MAX_USER_SEARCH_ENTRIES
    // also search for the handle and move the entry to the top instead of creating a duplicate

    DefaultStorIOSQLite storio = GtApplication.getInstance().getStorIOSQLite();

    storio.put()
            .object(e)
            .prepare()
            .asRxObservable()
            .subscribeOn(Schedulers.io())
            .subscribe(wrapperPutResults -> {
                getUserSearchHistory();
            }, throwable -> {
                Timber.d("Error putting %s entry to DB", e.handle);
                Timber.d(throwable.getCause().toString());
                Timber.d(throwable.toString());
            });
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void getFavorites() {
    DefaultStorIOSQLite storio = GtApplication.getInstance().getStorIOSQLite();
    Query q = Query.builder()
            .table(FavoritesTable.TABLE)
            .build();

    storio.get()
            .listOfObjects(Favorite.class)
            .withQuery(q)
            .prepare()
            .asRxObservable()
            .observeOn(Schedulers.io())
            .subscribe(favorites -> {
                Timber.d("Got %s faves", favorites.size());
            }, throwable -> {
                Timber.d("Error getting favorites from DB");
                Timber.d(throwable.getCause().toString());
                Timber.d(throwable.toString());
            });
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
/**
 * This is for use the GtActionCreator only.
 * This will also add the Favorite to the store
 *
 * @return An rx.Single for the favorites list
 */
private Single<HashMap<String, Favorite>> getFavoritesInternal(int type) {
    DefaultStorIOSQLite storio = GtApplication.getInstance().getStorIOSQLite();
    Query q = Query.builder()
            .table(FavoritesTable.TABLE)
            .where(FavoritesTable.COLUMN_TYPE + "=?")
            .whereArgs(type)
            .build();

    return storio.get()
            .listOfObjects(Favorite.class)
            .withQuery(q)
            .prepare()
            .asRxSingle()
            .map(favorites -> {
                HashMap<String, Favorite> hm = new HashMap<>(favorites.size());
                for (Favorite favorite : favorites) {
                    hm.put(favorite.reference, favorite);
                }
                return hm;
            });
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public static StorIOSQLite getStorIOSQLite(Context context) {
    if (mStorIOSQLite != null) {
        return mStorIOSQLite;
    }
    mStorIOSQLite = DefaultStorIOSQLite.builder()
        .sqliteOpenHelper(new DbOpenHelper(context))
        .addTypeMapping(Post.class, SQLiteTypeMapping.<Post>builder()
            // object that knows how to perform Put Operation (insert or update)
            .putResolver(new PostStorIOSQLitePutResolver())
            // object that knows how to perform Get Operation
            .getResolver(new PostStorIOSQLiteGetResolver())
            // object that knows how to perform Delete Operation
            .deleteResolver(new PostStorIOSQLiteDeleteResolver())
            .build())
        .addTypeMapping(Comment.class, SQLiteTypeMapping.<Comment>builder()
            .putResolver(new CommentStorIOSQLitePutResolver())
            .getResolver(new CommentStorIOSQLiteGetResolver())
            .deleteResolver(new CommentStorIOSQLiteDeleteResolver())
            .build())
        .build();

    return mStorIOSQLite;
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public static StorIOSQLite getStorIO(Context context) {
    if (mStorIOSQLite != null) {
        return mStorIOSQLite;
    }

    mStorIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new OpenHelper(context))
            .addTypeMapping(HistoryItem.class, SQLiteTypeMapping.<HistoryItem>builder()
                    .putResolver(new HistoryItemStorIOSQLitePutResolver())
                    .getResolver(new HistoryItemStorIOSQLiteGetResolver())
                    .deleteResolver(new HistoryItemStorIOSQLiteDeleteResolver())
                    .build())
    .build();

    return mStorIOSQLite;
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
@Provides @PerApp StorIOSQLite provideStorIOSQLite(RxBsuirOpenHelper openHelper, Gson gson) {
  return DefaultStorIOSQLite.builder()
      .sqliteOpenHelper(openHelper)
      .addTypeMapping(StudentGroup.class, SQLiteTypeMapping.<StudentGroup>builder().putResolver(
          new StudentGroupStorIOSQLitePutResolver())
          .getResolver(new StudentGroupStorIOSQLiteGetResolver())
          .deleteResolver(new StudentGroupStorIOSQLiteDeleteResolver())
          .build())
      .addTypeMapping(Lesson.class,
          SQLiteTypeMapping.<Lesson>builder().putResolver(new LessonStorIOSQLitePutResolver(gson))
              .getResolver(new LessonStorIOISQLiteGetResolver(gson))
              .deleteResolver(new LessonStorIOSQLiteDeleteResolver())
              .build())
      .addTypeMapping(Employee.class, SQLiteTypeMapping.<Employee>builder().putResolver(
          new EmployeeStorIOSQLitePutResolver(gson))
          .getResolver(new EmployeeStorIOISQLiteGetResolver(gson))
          .deleteResolver(new EmployeeStorIOSQLiteDeleteResolver())
          .build())
      .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
@Inject
public AppLocalDataStore(Context context) {
    mStorIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new DatabaseHelper(context))
            .addTypeMapping(TranslatePhrase.class,
                    new TranslatePhraseSQLiteTypeMapping())
            .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public void init(Context context) {
    storIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new DbOpenHelper(context))
            .addTypeMapping(Server.class, new ServerSQLiteTypeMapping())
            .addTypeMapping(User.class, new UserSQLiteTypeMapping())
            .addTypeMapping(Device.class, new DevicesTable.DeviceSQLiteTypeMapping())
            .addTypeMapping(Position.class, new PositionsTable.PositionSQLiteTypeMapping())
            .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public StorageService(Context context) {
    storIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new DbOpenHelper(context))
            .addTypeMapping(Server.class, new ServerSQLiteTypeMapping())
            .addTypeMapping(User.class, new UserSQLiteTypeMapping())
            .addTypeMapping(Device.class, new DevicesTable.DeviceSQLiteTypeMapping())
            .addTypeMapping(Position.class, new PositionsTable.PositionSQLiteTypeMapping())
            .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
@Test
public void nullSQLiteOpenHelper() {
    DefaultStorIOSQLite.Builder builder = DefaultStorIOSQLite.builder();
    expectedException.expect(NullPointerException.class);
    expectedException.expectMessage(equalTo("Please specify SQLiteOpenHelper instance"));
    expectedException.expectCause(nullValue(Throwable.class));
    //noinspection ConstantConditions
    builder.sqliteOpenHelper(null);
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public void TestAnimeTable() throws Exception {
    StorIOSQLite storIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(DBHelper.instance(getContext()))
            .addTypeMapping(Anime.class,
                    SQLiteTypeMapping.<Anime>builder()
                            .putResolver(new AnimeStorIOSQLitePutResolver())
                            .getResolver(new AnimeStorIOSQLiteGetResolver())
                            .deleteResolver(new AnimeStorIOSQLiteDeleteResolver())
                            .build())
            .build();
    storIOSQLite
            .delete()
            .byQuery(DeleteQuery.builder()
                            .table(Table.Anime.TABLE_NAME)
                            .build()
            ).prepare()
            .executeAsBlocking();

    Anime anime = new Anime();
    anime.setId(1);
    final String title = "Detective Conan";
    anime.setTitle(title);
    storIOSQLite.put()
            .object(anime)
            .prepare()
            .executeAsBlocking();

    Anime result = storIOSQLite.get()
            .listOfObjects(Anime.class)
            .withQuery(Query.builder()
                    .table(Table.Anime.TABLE_NAME)
                    .where(Table.Anime.ID + "= ?")
                    .whereArgs(1)
                    .build())
            .prepare()
            .executeAsBlocking()
            .get(0);
    Log.v("TITLE", result.getTitle());
    Assert.assertEquals(title, result.getTitle());
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public StorIOSQLite provideStorIOSQLite(@NonNull SQLiteOpenHelper sqLiteOpenHelper) {
    return DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(sqLiteOpenHelper)
            // ItemSQLiteTypeMapping is auto-generated at compile-time by StorIO
            .addTypeMapping(Item.class, new ItemSQLiteTypeMapping())
            .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public SQLiteStaticsStorage(Context context) {
    mStorIOSQLite = DefaultStorIOSQLite.builder()
            .sqliteOpenHelper(new SQLiteOpenHelper(context))
            .addTypeMapping(ScriptStaticsRecord.class, new ScriptStaticsRecordSQLiteTypeMapping())
            .build();
}
 

import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite; //导入依赖的package包/类
public DefaultStorIOSQLite getStorIOSQLite() {
    return mStorIOSQLite;
}