extends TabActivity {
+
+ private volatile H helper;
+ private volatile boolean created = false;
+ private volatile boolean destroyed = false;
+
+ /**
+ * Get a helper for this action.
+ */
+ public H getHelper() {
+ if (helper == null) {
+ if (!created) {
+ throw new IllegalStateException("A call has not been made to onCreate() yet so the helper is null");
+ } else if (destroyed) {
+ throw new IllegalStateException(
+ "A call to onDestroy has already been made and the helper cannot be used after that point");
+ } else {
+ throw new IllegalStateException("Helper is null for some unknown reason");
+ }
+ } else {
+ return helper;
+ }
+ }
+
+ /**
+ * Get a connection source for this action.
+ */
+ public ConnectionSource getConnectionSource() {
+ return getHelper().getConnectionSource();
+ }
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ if (helper == null) {
+ helper = getHelperInternal(this);
+ created = true;
+ }
+ super.onCreate(savedInstanceState);
+ }
+
+ @Override
+ protected void onDestroy() {
+ super.onDestroy();
+ releaseHelper(helper);
+ destroyed = true;
+ }
+
+ /**
+ * This is called internally by the class to populate the helper object instance. This should not be called directly
+ * by client code unless you know what you are doing. Use {@link #getHelper()} to get a helper instance. If you are
+ * managing your own helper creation, override this method to supply this activity with a helper instance.
+ *
+ *
+ * NOTE: If you override this method, you most likely will need to override the
+ * {@link #releaseHelper(OrmLiteSqliteOpenHelper)} method as well.
+ *
+ *
+ * @see OpenHelperManager#getHelper(Context)
+ */
+ protected H getHelperInternal(Context context) {
+ @SuppressWarnings({ "unchecked" })
+ H newHelper = (H) OpenHelperManager.getHelper(context);
+ return newHelper;
+ }
+
+ /**
+ * Release the helper instance created in {@link #getHelperInternal(Context)}. You most likely will not need to call
+ * this directly since {@link #onDestroy()} does it for you.
+ *
+ *
+ * NOTE: If you override this method, you most likely will need to override the
+ * {@link #getHelperInternal(Context)} method as well.
+ *
+ */
+ protected void releaseHelper(H helper) {
+ OpenHelperManager.releaseHelper();
+ this.helper = null;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteConfigUtil.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteConfigUtil.java
new file mode 100644
index 0000000..52c4596
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteConfigUtil.java
@@ -0,0 +1,339 @@
+package com.j256.ormlite.android.apptools;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileFilter;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.lang.reflect.Field;
+import java.sql.SQLException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.db.DatabaseType;
+import com.j256.ormlite.db.SqliteAndroidDatabaseType;
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.field.DatabaseFieldConfig;
+import com.j256.ormlite.field.ForeignCollectionField;
+import com.j256.ormlite.table.DatabaseTable;
+import com.j256.ormlite.table.DatabaseTableConfig;
+import com.j256.ormlite.table.DatabaseTableConfigLoader;
+
+/**
+ * Database configuration file helper class that is used to write a configuration file into the raw resource
+ * sub-directory to speed up DAO creation.
+ *
+ *
+ * With help from the user list and especially Ian Dees, we discovered that calls to annotation methods in Android are
+ * _very_ expensive because Method.equals() was doing a huge toString(). This was causing folks to see 2-3 seconds
+ * startup time when configuring 10-15 DAOs because of 1000s of calls to @DatabaseField methods. See this Android bug report.
+ *
+ *
+ *
+ * I added this utility class which writes a configuration file into the raw resource "res/raw" directory inside of your
+ * project containing the table and field names and associated details. This file can then be loaded into the
+ * {@link DaoManager} with the help of the
+ * {@link OrmLiteSqliteOpenHelper#OrmLiteSqliteOpenHelper(android.content.Context, String, android.database.sqlite.SQLiteDatabase.CursorFactory, int, int)}
+ * constructor. This means that you can configure your classes _without_ any runtime calls to annotations. It seems
+ * significantly faster.
+ *
+ *
+ *
+ * WARNING: Although this is fast, the big problem is that you have to remember to regenerate the config file
+ * whenever you edit one of your database classes. There is no way that I know of to do this automagically.
+ *
+ *
+ * @author graywatson
+ */
+public class OrmLiteConfigUtil {
+
+ /**
+ * Resource directory name that we are looking for.
+ */
+ protected static final String RESOURCE_DIR_NAME = "res";
+ /**
+ * Raw directory name that we are looking for.
+ */
+ protected static final String RAW_DIR_NAME = "raw";
+
+ /**
+ * Maximum recursion level while we are looking for source files.
+ */
+ protected static int maxFindSourceLevel = 20;
+
+ private static final DatabaseType databaseType = new SqliteAndroidDatabaseType();
+
+ /**
+ * A call through to {@link #writeConfigFile(String)} taking the file name from the single command line argument.
+ */
+ public static void main(String[] args) throws Exception {
+ if (args.length != 1) {
+ throw new IllegalArgumentException("Main can take a single file-name argument.");
+ }
+ writeConfigFile(args[0]);
+ }
+
+ /**
+ * Finds the annotated classes in the current directory or below and writes a configuration file to the file-name in
+ * the raw folder.
+ */
+ public static void writeConfigFile(String fileName) throws SQLException, IOException {
+ List> classList = new ArrayList>();
+ findAnnotatedClasses(classList, new File("."), 0);
+ writeConfigFile(fileName, classList.toArray(new Class[classList.size()]));
+ }
+
+ /**
+ * Writes a configuration fileName in the raw directory with the configuration for classes.
+ */
+ public static void writeConfigFile(String fileName, Class[] classes) throws SQLException, IOException {
+ File rawDir = findRawDir(new File("."));
+ if (rawDir == null) {
+ System.err.println("Could not find " + RAW_DIR_NAME + " directory which is typically in the "
+ + RESOURCE_DIR_NAME + " directory");
+ } else {
+ File configFile = new File(rawDir, fileName);
+ writeConfigFile(configFile, classes);
+ }
+ }
+
+ /**
+ * Finds the annotated classes in the current directory or below and writes a configuration file.
+ */
+ public static void writeConfigFile(File configFile) throws SQLException, IOException {
+ writeConfigFile(configFile, new File("."));
+ }
+
+ /**
+ * Finds the annotated classes in the specified search directory or below and writes a configuration file.
+ */
+ public static void writeConfigFile(File configFile, File searchDir) throws SQLException, IOException {
+ List> classList = new ArrayList>();
+ findAnnotatedClasses(classList, searchDir, 0);
+ writeConfigFile(configFile, classList.toArray(new Class[classList.size()]));
+ }
+
+ /**
+ * Write a configuration file with the configuration for classes.
+ */
+ public static void writeConfigFile(File configFile, Class[] classes) throws SQLException, IOException {
+ System.out.println("Writing configurations to " + configFile.getAbsolutePath());
+ writeConfigFile(new FileOutputStream(configFile), classes);
+ }
+
+ /**
+ * Write a configuration file to an output stream with the configuration for classes.
+ */
+ public static void writeConfigFile(OutputStream outputStream, File searchDir) throws SQLException, IOException {
+ List> classList = new ArrayList>();
+ findAnnotatedClasses(classList, searchDir, 0);
+ writeConfigFile(outputStream, classList.toArray(new Class[classList.size()]));
+ }
+
+ /**
+ * Write a configuration file to an output stream with the configuration for classes.
+ */
+ public static void writeConfigFile(OutputStream outputStream, Class[] classes) throws SQLException, IOException {
+ BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream), 4096);
+ try {
+ writeHeader(writer);
+ for (Class clazz : classes) {
+ writeConfigForTable(writer, clazz);
+ }
+ // NOTE: done is here because this is public
+ System.out.println("Done.");
+ } finally {
+ writer.close();
+ }
+ }
+
+ /**
+ * Look for the resource-directory in the current directory or the directories above. Then look for the
+ * raw-directory underneath the resource-directory.
+ */
+ protected static File findRawDir(File dir) {
+ for (int i = 0; dir != null && i < 20; i++) {
+ File rawDir = findResRawDir(dir);
+ if (rawDir != null) {
+ return rawDir;
+ }
+ dir = dir.getParentFile();
+ }
+ return null;
+ }
+
+ private static void writeHeader(BufferedWriter writer) throws IOException {
+ writer.append('#');
+ writer.newLine();
+ writer.append("# generated on ").append(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date()));
+ writer.newLine();
+ writer.append('#');
+ writer.newLine();
+ }
+
+ private static void findAnnotatedClasses(List> classList, File dir, int level) throws SQLException,
+ IOException {
+ for (File file : dir.listFiles()) {
+ if (file.isDirectory()) {
+ // recurse if we aren't deep enough
+ if (level < maxFindSourceLevel) {
+ findAnnotatedClasses(classList, file, level + 1);
+ }
+ continue;
+ }
+ // skip non .java files
+ if (!file.getName().endsWith(".java")) {
+ continue;
+ }
+ String packageName = getPackageOfClass(file);
+ if (packageName == null) {
+ System.err.println("Could not find package name for: " + file);
+ continue;
+ }
+ // get the filename and cut off the .java
+ String name = file.getName();
+ name = name.substring(0, name.length() - ".java".length());
+ String className = packageName + "." + name;
+ Class clazz;
+ try {
+ clazz = Class.forName(className);
+ } catch (Throwable t) {
+ // amazingly, this sometimes throws an Error
+ System.err.println("Could not load class file for: " + file);
+ System.err.println(" " + t);
+ continue;
+ }
+ if (classHasAnnotations(clazz)) {
+ classList.add(clazz);
+ }
+ // handle inner classes
+ try {
+ for (Class innerClazz : clazz.getDeclaredClasses()) {
+ if (classHasAnnotations(innerClazz)) {
+ classList.add(innerClazz);
+ }
+ }
+ } catch (Throwable t) {
+ // amazingly, this sometimes throws an Error
+ System.err.println("Could not load inner classes for: " + clazz);
+ System.err.println(" " + t);
+ continue;
+ }
+ }
+ }
+
+ private static void writeConfigForTable(BufferedWriter writer, Class clazz) throws SQLException, IOException {
+ String tableName = DatabaseTableConfig.extractTableName(clazz);
+ List fieldConfigs = new ArrayList();
+ // walk up the classes finding the fields
+ try {
+ for (Class working = clazz; working != null; working = working.getSuperclass()) {
+ for (Field field : working.getDeclaredFields()) {
+ DatabaseFieldConfig fieldConfig = DatabaseFieldConfig.fromField(databaseType, tableName, field);
+ if (fieldConfig != null) {
+ fieldConfigs.add(fieldConfig);
+ }
+ }
+ }
+ } catch (Error e) {
+ System.err.println("Skipping " + clazz + " because we got an error finding its definition: "
+ + e.getMessage());
+ return;
+ }
+ if (fieldConfigs.isEmpty()) {
+ System.out.println("Skipping " + clazz + " because no annotated fields found");
+ return;
+ }
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ DatabaseTableConfig tableConfig = new DatabaseTableConfig(clazz, tableName, fieldConfigs);
+ DatabaseTableConfigLoader.write(writer, tableConfig);
+ writer.append("#################################");
+ writer.newLine();
+ System.out.println("Wrote config for " + clazz);
+ }
+
+ private static boolean classHasAnnotations(Class clazz) {
+ while (clazz != null) {
+ if (clazz.getAnnotation(DatabaseTable.class) != null) {
+ return true;
+ }
+ Field[] fields;
+ try {
+ fields = clazz.getDeclaredFields();
+ } catch (Throwable t) {
+ // amazingly, this sometimes throws an Error
+ System.err.println("Could not load get delcared fields from: " + clazz);
+ System.err.println(" " + t);
+ return false;
+ }
+ for (Field field : fields) {
+ if (field.getAnnotation(DatabaseField.class) != null
+ || field.getAnnotation(ForeignCollectionField.class) != null) {
+ return true;
+ }
+ }
+ try {
+ clazz = clazz.getSuperclass();
+ } catch (Throwable t) {
+ // amazingly, this sometimes throws an Error
+ System.err.println("Could not get super class for: " + clazz);
+ System.err.println(" " + t);
+ return false;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Returns the package name of a file that has one of the annotations we are looking for.
+ *
+ * @return Package prefix string or null or no annotations.
+ */
+ private static String getPackageOfClass(File file) throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader(file));
+ try {
+ while (true) {
+ String line = reader.readLine();
+ if (line == null) {
+ return null;
+ }
+ if (line.contains("package")) {
+ String[] parts = line.split("[ \t;]");
+ if (parts.length > 1 && parts[0].equals("package")) {
+ return parts[1];
+ }
+ }
+ }
+ } finally {
+ reader.close();
+ }
+ }
+
+ /**
+ * Look for the resource directory with raw beneath it.
+ */
+ private static File findResRawDir(File dir) {
+ for (File file : dir.listFiles()) {
+ if (file.getName().equals(RESOURCE_DIR_NAME) && file.isDirectory()) {
+ File[] rawFiles = file.listFiles(new FileFilter() {
+ public boolean accept(File file) {
+ return file.getName().equals(RAW_DIR_NAME) && file.isDirectory();
+ }
+ });
+ if (rawFiles.length == 1) {
+ return rawFiles[0];
+ }
+ }
+ }
+ return null;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteCursorAdapter.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteCursorAdapter.java
new file mode 100644
index 0000000..3e9954d
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteCursorAdapter.java
@@ -0,0 +1,93 @@
+package com.j256.ormlite.android.apptools;
+
+import java.sql.SQLException;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.widget.CursorAdapter;
+
+import com.j256.ormlite.android.AndroidDatabaseResults;
+import com.j256.ormlite.stmt.PreparedQuery;
+
+/**
+ * Cursor adapter base class.
+ *
+ * @author emmby
+ */
+public abstract class OrmLiteCursorAdapter extends CursorAdapter {
+
+ protected PreparedQuery preparedQuery;
+
+ public OrmLiteCursorAdapter(Context context) {
+ super(context, null, false);
+ }
+
+ /**
+ * Bind the view to a particular item.
+ */
+ public abstract void bindView(ViewType itemView, Context context, T item);
+
+ /**
+ * Final to prevent subclasses from accidentally overriding. Intentional overriding can be accomplished by
+ * overriding {@link #doBindView(View, Context, Cursor)}.
+ *
+ * @see CursorAdapter#bindView(View, Context, Cursor)
+ */
+ @Override
+ public final void bindView(View itemView, Context context, Cursor cursor) {
+ doBindView(itemView, context, cursor);
+ }
+
+ /**
+ * This is here to make sure that the user really wants to override it.
+ */
+ protected void doBindView(View itemView, Context context, Cursor cursor) {
+ try {
+ @SuppressWarnings("unchecked")
+ ViewType itemViewType = (ViewType) itemView;
+ bindView(itemViewType, context, cursorToObject(cursor));
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Returns a T object at the current position.
+ */
+ public T getTypedItem(int position) {
+ try {
+ return cursorToObject((Cursor) super.getItem(position));
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Map a single row to our cursor object.
+ */
+ protected T cursorToObject(Cursor cursor) throws SQLException {
+ return preparedQuery.mapRow(new AndroidDatabaseResults(cursor, null));
+ }
+
+ /**
+ * Show not be used. Instead use {@link #changeCursor(Cursor, PreparedQuery)}
+ */
+ @Override
+ public final void changeCursor(Cursor cursor) {
+ throw new UnsupportedOperationException(
+ "Please use OrmLiteCursorAdapter.changeCursor(Cursor,PreparedQuery) instead");
+ }
+
+ /**
+ * Change the cursor associated with the prepared query.
+ */
+ public void changeCursor(Cursor cursor, PreparedQuery preparedQuery) {
+ setPreparedQuery(preparedQuery);
+ super.changeCursor(cursor);
+ }
+
+ public void setPreparedQuery(PreparedQuery preparedQuery) {
+ this.preparedQuery = preparedQuery;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteCursorLoader.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteCursorLoader.java
new file mode 100644
index 0000000..03ac9cf
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteCursorLoader.java
@@ -0,0 +1,131 @@
+package com.j256.ormlite.android.apptools;
+
+import static com.j256.ormlite.stmt.StatementBuilder.StatementType.SELECT;
+
+import java.sql.SQLException;
+
+import android.content.AsyncTaskLoader;
+import android.content.Context;
+import android.database.Cursor;
+
+import com.j256.ormlite.android.AndroidCompiledStatement;
+import com.j256.ormlite.dao.Dao;
+import com.j256.ormlite.dao.Dao.DaoObserver;
+import com.j256.ormlite.stmt.PreparedQuery;
+import com.j256.ormlite.support.DatabaseConnection;
+
+/**
+ * Cursor loader supported by later Android APIs that allows asynchronous content loading.
+ *
+ *
+ * NOTE: This should be the same as {@link com.j256.ormlite.android.apptools.support.OrmLiteCursorLoader}
+ * but this should import the normal version of the {@link AsyncTaskLoader}, not the support version.
+ *
+ *
+ * @author emmby
+ */
+public class OrmLiteCursorLoader extends AsyncTaskLoader implements DaoObserver {
+
+ protected Dao dao;
+ protected PreparedQuery query;
+ protected Cursor cursor;
+
+ public OrmLiteCursorLoader(Context context, Dao dao, PreparedQuery query) {
+ super(context);
+ this.dao = dao;
+ this.query = query;
+ }
+
+ @Override
+ public Cursor loadInBackground() {
+ Cursor cursor;
+ try {
+ DatabaseConnection connection = dao.getConnectionSource().getReadOnlyConnection();
+ AndroidCompiledStatement statement = (AndroidCompiledStatement) query.compile(connection, SELECT);
+ cursor = statement.getCursor();
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+
+ // fill the cursor with results
+ cursor.getCount();
+ return cursor;
+ }
+
+ @Override
+ public void deliverResult(Cursor newCursor) {
+ if (isReset()) {
+ // an async query came in while the loader is stopped
+ if (newCursor != null) {
+ newCursor.close();
+ }
+ return;
+ }
+
+ Cursor oldCursor = cursor;
+ cursor = newCursor;
+
+ if (isStarted()) {
+ super.deliverResult(newCursor);
+ }
+
+ // close the old cursor if necessary
+ if (oldCursor != null && oldCursor != newCursor && !oldCursor.isClosed()) {
+ oldCursor.close();
+ }
+ }
+
+ @Override
+ protected void onStartLoading() {
+ // start watching for dataset changes
+ dao.registerObserver(this);
+
+ if (cursor == null) {
+ forceLoad();
+ } else {
+ deliverResult(cursor);
+ if (takeContentChanged()) {
+ forceLoad();
+ }
+ }
+ }
+
+ @Override
+ protected void onStopLoading() {
+ cancelLoad();
+ }
+
+ @Override
+ public void onCanceled(Cursor cursor) {
+ if (cursor != null && !cursor.isClosed()) {
+ cursor.close();
+ }
+ }
+
+ @Override
+ protected void onReset() {
+ super.onReset();
+ onStopLoading();
+ if (cursor != null) {
+ if (!cursor.isClosed()) {
+ cursor.close();
+ }
+ cursor = null;
+ }
+
+ // stop watching for changes
+ dao.unregisterObserver(this);
+ }
+
+ public void onChange() {
+ onContentChanged();
+ }
+
+ public PreparedQuery getQuery() {
+ return query;
+ }
+
+ public void setQuery(PreparedQuery mQuery) {
+ this.query = mQuery;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLitePreparedQueryLoader.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLitePreparedQueryLoader.java
new file mode 100644
index 0000000..4771537
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLitePreparedQueryLoader.java
@@ -0,0 +1,55 @@
+package com.j256.ormlite.android.apptools;
+
+import java.sql.SQLException;
+import java.util.Collections;
+import java.util.List;
+
+import android.content.Context;
+import android.content.Loader;
+
+import com.j256.ormlite.dao.Dao;
+import com.j256.ormlite.stmt.PreparedQuery;
+
+/**
+ * A {@link Loader} implementation that queries specified {@link Dao} using a {@link PreparedQuery}.
+ *
+ * @author Egorand
+ */
+public class OrmLitePreparedQueryLoader extends BaseOrmLiteLoader {
+
+ private PreparedQuery preparedQuery;
+
+ public OrmLitePreparedQueryLoader(Context context) {
+ super(context);
+ }
+
+ public OrmLitePreparedQueryLoader(Context context, Dao dao, PreparedQuery preparedQuery) {
+ super(context, dao);
+ this.preparedQuery = preparedQuery;
+ }
+
+ @Override
+ public List loadInBackground() {
+ if (dao == null) {
+ throw new IllegalStateException("Dao is not initialized.");
+ }
+ if (preparedQuery == null) {
+ throw new IllegalStateException("PreparedQuery is not initialized.");
+ }
+ try {
+ return dao.query(preparedQuery);
+ } catch (SQLException e) {
+ // XXX: is this really the right thing to do? Maybe throw RuntimeException?
+ e.printStackTrace();
+ return Collections.emptyList();
+ }
+ }
+
+ public void setPreparedQuery(PreparedQuery preparedQuery) {
+ this.preparedQuery = preparedQuery;
+ }
+
+ public PreparedQuery getPreparedQuery() {
+ return preparedQuery;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteQueryForAllLoader.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteQueryForAllLoader.java
new file mode 100644
index 0000000..6add86c
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteQueryForAllLoader.java
@@ -0,0 +1,40 @@
+package com.j256.ormlite.android.apptools;
+
+import java.sql.SQLException;
+import java.util.Collections;
+import java.util.List;
+
+import android.content.Context;
+
+import com.j256.ormlite.dao.Dao;
+
+/**
+ * A Loader implementation that queries specified {@link com.j256.ormlite.dao.Dao} for all data, using the
+ * Dao.queryForAll() call.
+ *
+ * @author EgorAnd
+ */
+public class OrmLiteQueryForAllLoader extends BaseOrmLiteLoader {
+
+ public OrmLiteQueryForAllLoader(Context context) {
+ super(context);
+ }
+
+ public OrmLiteQueryForAllLoader(Context context, Dao dao) {
+ super(context, dao);
+ }
+
+ @Override
+ public List loadInBackground() {
+ if (dao == null) {
+ throw new IllegalStateException("Dao is not initialized.");
+ }
+ try {
+ return dao.queryForAll();
+ } catch (SQLException e) {
+ // XXX: is this really the right thing to do? Maybe throw RuntimeException?
+ e.printStackTrace();
+ return Collections.emptyList();
+ }
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteSqliteOpenHelper.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteSqliteOpenHelper.java
new file mode 100644
index 0000000..62a3f45
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/OrmLiteSqliteOpenHelper.java
@@ -0,0 +1,326 @@
+package com.j256.ormlite.android.apptools;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.sql.SQLException;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteDatabase.CursorFactory;
+import android.database.sqlite.SQLiteOpenHelper;
+
+import com.j256.ormlite.android.AndroidConnectionSource;
+import com.j256.ormlite.android.AndroidDatabaseConnection;
+import com.j256.ormlite.dao.Dao;
+import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.dao.RuntimeExceptionDao;
+import com.j256.ormlite.logger.Logger;
+import com.j256.ormlite.logger.LoggerFactory;
+import com.j256.ormlite.misc.IOUtils;
+import com.j256.ormlite.support.ConnectionSource;
+import com.j256.ormlite.support.DatabaseConnection;
+import com.j256.ormlite.table.DatabaseTableConfigLoader;
+
+/**
+ * SQLite database open helper which can be extended by your application to help manage when the application needs to
+ * create or upgrade its database.
+ *
+ * @author kevingalligan, graywatson
+ */
+public abstract class OrmLiteSqliteOpenHelper extends SQLiteOpenHelper {
+
+ protected static Logger logger = LoggerFactory.getLogger(OrmLiteSqliteOpenHelper.class);
+ protected AndroidConnectionSource connectionSource = new AndroidConnectionSource(this);
+
+ protected boolean cancelQueriesEnabled;
+ private volatile boolean isOpen = true;
+
+ /**
+ * @param context
+ * Associated content from the application. This is needed to locate the database.
+ * @param databaseName
+ * Name of the database we are opening.
+ * @param factory
+ * Cursor factory or null if none.
+ * @param databaseVersion
+ * Version of the database we are opening. This causes {@link #onUpgrade(SQLiteDatabase, int, int)} to be
+ * called if the stored database is a different version.
+ */
+ public OrmLiteSqliteOpenHelper(Context context, String databaseName, CursorFactory factory, int databaseVersion) {
+ super(context, databaseName, factory, databaseVersion);
+ logger.trace("{}: constructed connectionSource {}", this, connectionSource);
+ }
+
+ /**
+ * Same as the other constructor with the addition of a file-id of the table config-file. See
+ * {@link OrmLiteConfigUtil} for details.
+ *
+ * @param context
+ * Associated content from the application. This is needed to locate the database.
+ * @param databaseName
+ * Name of the database we are opening.
+ * @param factory
+ * Cursor factory or null if none.
+ * @param databaseVersion
+ * Version of the database we are opening. This causes {@link #onUpgrade(SQLiteDatabase, int, int)} to be
+ * called if the stored database is a different version.
+ * @param configFileId
+ * file-id which probably should be a R.raw.ormlite_config.txt or some static value.
+ */
+ public OrmLiteSqliteOpenHelper(Context context, String databaseName, CursorFactory factory, int databaseVersion,
+ int configFileId) {
+ this(context, databaseName, factory, databaseVersion, openFileId(context, configFileId));
+ }
+
+ /**
+ * Same as the other constructor with the addition of a config-file. See {@link OrmLiteConfigUtil} for details.
+ *
+ * @param context
+ * Associated content from the application. This is needed to locate the database.
+ * @param databaseName
+ * Name of the database we are opening.
+ * @param factory
+ * Cursor factory or null if none.
+ * @param databaseVersion
+ * Version of the database we are opening. This causes {@link #onUpgrade(SQLiteDatabase, int, int)} to be
+ * called if the stored database is a different version.
+ * @param configFile
+ * Configuration file to be loaded.
+ */
+ public OrmLiteSqliteOpenHelper(Context context, String databaseName, CursorFactory factory, int databaseVersion,
+ File configFile) {
+ this(context, databaseName, factory, databaseVersion, openFile(configFile));
+ }
+
+ /**
+ * Same as the other constructor with the addition of a input stream to the table config-file. See
+ * {@link OrmLiteConfigUtil} for details.
+ *
+ * @param context
+ * Associated content from the application. This is needed to locate the database.
+ * @param databaseName
+ * Name of the database we are opening.
+ * @param factory
+ * Cursor factory or null if none.
+ * @param databaseVersion
+ * Version of the database we are opening. This causes {@link #onUpgrade(SQLiteDatabase, int, int)} to be
+ * called if the stored database is a different version.
+ * @param stream
+ * Stream opened to the configuration file to be loaded. It will be closed when this method returns.
+ */
+ public OrmLiteSqliteOpenHelper(Context context, String databaseName, CursorFactory factory, int databaseVersion,
+ InputStream stream) {
+ super(context, databaseName, factory, databaseVersion);
+ if (stream == null) {
+ return;
+ }
+
+ // if a config file-id was specified then load it into the DaoManager
+ BufferedReader reader = null;
+ try {
+ reader = new BufferedReader(new InputStreamReader(stream), 4096);
+ stream = null;
+ DaoManager.addCachedDatabaseConfigs(DatabaseTableConfigLoader.loadDatabaseConfigFromReader(reader));
+ } catch (SQLException e) {
+ throw new IllegalStateException("Could not load object config file", e);
+ } finally {
+ IOUtils.closeQuietly(reader);
+ IOUtils.closeQuietly(stream);
+ }
+ }
+
+ /**
+ * What to do when your database needs to be created. Usually this entails creating the tables and loading any
+ * initial data.
+ *
+ *
+ * NOTE: You should use the connectionSource argument that is passed into this method call or the one
+ * returned by getConnectionSource(). If you use your own, a recursive call or other unexpected results may result.
+ *
+ *
+ * @param database
+ * Database being created.
+ * @param connectionSource
+ * To use get connections to the database to be created.
+ */
+ public abstract void onCreate(SQLiteDatabase database, ConnectionSource connectionSource);
+
+ /**
+ * What to do when your database needs to be updated. This could mean careful migration of old data to new data.
+ * Maybe adding or deleting database columns, etc..
+ *
+ *
+ * NOTE: You should use the connectionSource argument that is passed into this method call or the one
+ * returned by getConnectionSource(). If you use your own, a recursive call or other unexpected results may result.
+ *
+ *
+ * @param database
+ * Database being upgraded.
+ * @param connectionSource
+ * To use get connections to the database to be updated.
+ * @param oldVersion
+ * The version of the current database so we can know what to do to the database.
+ * @param newVersion
+ * The version that we are upgrading the database to.
+ */
+ public abstract void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion,
+ int newVersion);
+
+ /**
+ * Get the connection source associated with the helper.
+ */
+ public ConnectionSource getConnectionSource() {
+ if (!isOpen) {
+ // we don't throw this exception, but log it for debugging purposes
+ logger.warn(new IllegalStateException(), "Getting connectionSource was called after closed");
+ }
+ return connectionSource;
+ }
+
+ /**
+ * Satisfies the {@link SQLiteOpenHelper#onCreate(SQLiteDatabase)} interface method.
+ */
+ @Override
+ public final void onCreate(SQLiteDatabase db) {
+ ConnectionSource cs = getConnectionSource();
+ /*
+ * The method is called by Android database helper's get-database calls when Android detects that we need to
+ * create or update the database. So we have to use the database argument and save a connection to it on the
+ * AndroidConnectionSource, otherwise it will go recursive if the subclass calls getConnectionSource().
+ */
+ DatabaseConnection conn = cs.getSpecialConnection();
+ boolean clearSpecial = false;
+ if (conn == null) {
+ conn = new AndroidDatabaseConnection(db, true, cancelQueriesEnabled);
+ try {
+ cs.saveSpecialConnection(conn);
+ clearSpecial = true;
+ } catch (SQLException e) {
+ throw new IllegalStateException("Could not save special connection", e);
+ }
+ }
+ try {
+ onCreate(db, cs);
+ } finally {
+ if (clearSpecial) {
+ cs.clearSpecialConnection(conn);
+ }
+ }
+ }
+
+ /**
+ * Satisfies the {@link SQLiteOpenHelper#onUpgrade(SQLiteDatabase, int, int)} interface method.
+ */
+ @Override
+ public final void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+ ConnectionSource cs = getConnectionSource();
+ /*
+ * The method is called by Android database helper's get-database calls when Android detects that we need to
+ * create or update the database. So we have to use the database argument and save a connection to it on the
+ * AndroidConnectionSource, otherwise it will go recursive if the subclass calls getConnectionSource().
+ */
+ DatabaseConnection conn = cs.getSpecialConnection();
+ boolean clearSpecial = false;
+ if (conn == null) {
+ conn = new AndroidDatabaseConnection(db, true, cancelQueriesEnabled);
+ try {
+ cs.saveSpecialConnection(conn);
+ clearSpecial = true;
+ } catch (SQLException e) {
+ throw new IllegalStateException("Could not save special connection", e);
+ }
+ }
+ try {
+ onUpgrade(db, cs, oldVersion, newVersion);
+ } finally {
+ if (clearSpecial) {
+ cs.clearSpecialConnection(conn);
+ }
+ }
+ }
+
+ /**
+ * Close any open connections.
+ */
+ @Override
+ public void close() {
+ super.close();
+ connectionSource.close();
+ /*
+ * We used to set connectionSource to null here but now we just set the closed flag and then log heavily if
+ * someone uses getConectionSource() after this point.
+ */
+ isOpen = false;
+ }
+
+ /**
+ * Return true if the helper is still open. Once {@link #close()} is called then this will return false.
+ */
+ public boolean isOpen() {
+ return isOpen;
+ }
+
+ /**
+ * Get a DAO for our class. This uses the {@link DaoManager} to cache the DAO for future gets.
+ *
+ *
+ * NOTE: This routing does not return Dao<T, ID> because of casting issues if we are assigning it to a custom DAO.
+ * Grumble.
+ *
+ */
+ public , T> D getDao(Class clazz) throws SQLException {
+ // special reflection fu is now handled internally by create dao calling the database type
+ Dao dao = DaoManager.createDao(getConnectionSource(), clazz);
+ @SuppressWarnings("unchecked")
+ D castDao = (D) dao;
+ return castDao;
+ }
+
+ /**
+ * Get a RuntimeExceptionDao for our class. This uses the {@link DaoManager} to cache the DAO for future gets.
+ *
+ *
+ * NOTE: This routing does not return RuntimeExceptionDao<T, ID> because of casting issues if we are assigning it to
+ * a custom DAO. Grumble.
+ *
+ */
+ public , T> D getRuntimeExceptionDao(Class clazz) {
+ try {
+ Dao dao = getDao(clazz);
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ D castDao = (D) new RuntimeExceptionDao(dao);
+ return castDao;
+ } catch (SQLException e) {
+ throw new RuntimeException("Could not create RuntimeExcepitionDao for class " + clazz, e);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "@" + Integer.toHexString(super.hashCode());
+ }
+
+ private static InputStream openFileId(Context context, int fileId) {
+ InputStream stream = context.getResources().openRawResource(fileId);
+ if (stream == null) {
+ throw new IllegalStateException("Could not find object config file with id " + fileId);
+ }
+ return stream;
+ }
+
+ private static InputStream openFile(File configFile) {
+ try {
+ if (configFile == null) {
+ return null;
+ } else {
+ return new FileInputStream(configFile);
+ }
+ } catch (FileNotFoundException e) {
+ throw new IllegalArgumentException("Could not open config file " + configFile, e);
+ }
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/support/OrmLiteCursorLoader.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/support/OrmLiteCursorLoader.java
new file mode 100644
index 0000000..9bdf300
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/apptools/support/OrmLiteCursorLoader.java
@@ -0,0 +1,131 @@
+package com.j256.ormlite.android.apptools.support;
+
+import static com.j256.ormlite.stmt.StatementBuilder.StatementType.SELECT;
+
+import java.sql.SQLException;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.support.v4.content.AsyncTaskLoader;
+
+import com.j256.ormlite.android.AndroidCompiledStatement;
+import com.j256.ormlite.dao.Dao;
+import com.j256.ormlite.dao.Dao.DaoObserver;
+import com.j256.ormlite.stmt.PreparedQuery;
+import com.j256.ormlite.support.DatabaseConnection;
+
+/**
+ * Cursor loader supported by later Android APIs that allows asynchronous content loading.
+ *
+ *
+ * NOTE: This should be the same as {@link com.j256.ormlite.android.apptools.OrmLiteCursorLoader} but this
+ * should import the support library version of the {@link AsyncTaskLoader}.
+ *
+ *
+ * @author emmby
+ */
+public class OrmLiteCursorLoader extends AsyncTaskLoader implements DaoObserver {
+
+ protected Dao dao;
+ protected PreparedQuery query;
+ protected Cursor cursor;
+
+ public OrmLiteCursorLoader(Context context, Dao dao, PreparedQuery query) {
+ super(context);
+ this.dao = dao;
+ this.query = query;
+ }
+
+ @Override
+ public Cursor loadInBackground() {
+ Cursor cursor;
+ try {
+ DatabaseConnection connection = dao.getConnectionSource().getReadOnlyConnection();
+ AndroidCompiledStatement statement = (AndroidCompiledStatement) query.compile(connection, SELECT);
+ cursor = statement.getCursor();
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+
+ // fill the cursor with results
+ cursor.getCount();
+ return cursor;
+ }
+
+ @Override
+ public void deliverResult(Cursor newCursor) {
+ if (isReset()) {
+ // an async query came in while the loader is stopped
+ if (newCursor != null) {
+ newCursor.close();
+ }
+ return;
+ }
+
+ Cursor oldCursor = cursor;
+ cursor = newCursor;
+
+ if (isStarted()) {
+ super.deliverResult(newCursor);
+ }
+
+ // close the old cursor if necessary
+ if (oldCursor != null && oldCursor != newCursor && !oldCursor.isClosed()) {
+ oldCursor.close();
+ }
+ }
+
+ @Override
+ protected void onStartLoading() {
+ // start watching for dataset changes
+ dao.registerObserver(this);
+
+ if (cursor == null) {
+ forceLoad();
+ } else {
+ deliverResult(cursor);
+ if (takeContentChanged()) {
+ forceLoad();
+ }
+ }
+ }
+
+ @Override
+ protected void onStopLoading() {
+ cancelLoad();
+ }
+
+ @Override
+ public void onCanceled(Cursor cursor) {
+ if (cursor != null && !cursor.isClosed()) {
+ cursor.close();
+ }
+ }
+
+ @Override
+ protected void onReset() {
+ super.onReset();
+ onStopLoading();
+ if (cursor != null) {
+ if (!cursor.isClosed()) {
+ cursor.close();
+ }
+ cursor = null;
+ }
+
+ // stop watching for changes
+ dao.unregisterObserver(this);
+ }
+
+ public void onChange() {
+ onContentChanged();
+ }
+
+ public PreparedQuery getQuery() {
+ return query;
+ }
+
+ public void setQuery(PreparedQuery mQuery) {
+ this.query = mQuery;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/ApiCompatibility.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/ApiCompatibility.java
new file mode 100644
index 0000000..6d76e18
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/ApiCompatibility.java
@@ -0,0 +1,34 @@
+package com.j256.ormlite.android.compat;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+/**
+ * Compatibility interface to support various different versions of the Android API.
+ *
+ * @author graywatson
+ */
+public interface ApiCompatibility {
+
+ /**
+ * Perform a raw query on a database with an optional cancellation-hook.
+ */
+ public Cursor rawQuery(SQLiteDatabase db, String sql, String[] selectionArgs, CancellationHook cancellationHook);
+
+ /**
+ * Return a cancellation hook object that will be passed to the
+ * {@link #rawQuery(SQLiteDatabase, String, String[], CancellationHook)}. If not supported then this will return
+ * null.
+ */
+ public CancellationHook createCancellationHook();
+
+ /**
+ * Cancellation hook class returned by {@link ApiCompatibility#createCancellationHook()}.
+ */
+ public interface CancellationHook {
+ /**
+ * Cancel the associated query.
+ */
+ public void cancel();
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/ApiCompatibilityUtils.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/ApiCompatibilityUtils.java
new file mode 100644
index 0000000..25686dc
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/ApiCompatibilityUtils.java
@@ -0,0 +1,52 @@
+package com.j256.ormlite.android.compat;
+
+import android.os.Build;
+
+/**
+ * Utility class which loads the various classes based on which API version is being supported.
+ *
+ * @author graywatson
+ */
+@SuppressWarnings("unused")
+public class ApiCompatibilityUtils {
+
+ private static ApiCompatibility compatibility;
+
+ /**
+ * Copied from {@link Build.VERSION_CODES}. We don't use those codes because they won't be in certain versions of
+ * Build.
+ */
+ private static final int BASE = 1;
+ private static final int BASE_1_1 = 2;
+ private static final int CUPCAKE = 3;
+ private static final int DONUT = 4;
+ private static final int ECLAIR = 5;
+ private static final int ECLAIR_0_1 = 6;
+ private static final int ECLAIR_MR1 = 7;
+ private static final int FROYO = 8;
+ private static final int GINGERBREAD = 9;
+ private static final int GINGERBREAD_MR1 = 10;
+ private static final int HONEYCOMB = 11;
+ private static final int HONEYCOMB_MR1 = 12;
+ private static final int HONEYCOMB_MR2 = 13;
+ private static final int ICE_CREAM_SANDWICH = 14;
+ private static final int ICE_CREAM_SANDWICH_MR1 = 15;
+ private static final int JELLY_BEAN = 16;
+ private static final int JELLY_BEAN_MR1 = 17;
+ private static final int JELLY_BEAN_MR2 = 18;
+
+ static {
+ if (Build.VERSION.SDK_INT >= JELLY_BEAN) {
+ compatibility = new JellyBeanApiCompatibility();
+ } else {
+ compatibility = new BasicApiCompatibility();
+ }
+ }
+
+ /**
+ * Return the compatibility class that matches our build number.
+ */
+ public static ApiCompatibility getCompatibility() {
+ return compatibility;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/BasicApiCompatibility.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/BasicApiCompatibility.java
new file mode 100644
index 0000000..27be2c7
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/BasicApiCompatibility.java
@@ -0,0 +1,21 @@
+package com.j256.ormlite.android.compat;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+
+/**
+ * Basic class which provides no-op methods for all Android version.
+ *
+ * @author graywatson
+ */
+public class BasicApiCompatibility implements ApiCompatibility {
+
+ public Cursor rawQuery(SQLiteDatabase db, String sql, String[] selectionArgs, CancellationHook cancellationHook) {
+ // NOTE: cancellationHook will always be null
+ return db.rawQuery(sql, selectionArgs);
+ }
+
+ public CancellationHook createCancellationHook() {
+ return null;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/JellyBeanApiCompatibility.java b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/JellyBeanApiCompatibility.java
new file mode 100644
index 0000000..982e7f1
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/android/compat/JellyBeanApiCompatibility.java
@@ -0,0 +1,47 @@
+package com.j256.ormlite.android.compat;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.os.CancellationSignal;
+
+/**
+ * Basic class which provides no-op methods for all Android version.
+ *
+ *
+ * NOTE: Will show as in error if compiled with previous Android versions.
+ *
+ *
+ * @author graywatson
+ */
+public class JellyBeanApiCompatibility extends BasicApiCompatibility {
+
+ @Override
+ public Cursor rawQuery(SQLiteDatabase db, String sql, String[] selectionArgs, CancellationHook cancellationHook) {
+ if (cancellationHook == null) {
+ return db.rawQuery(sql, selectionArgs);
+ } else {
+ return db.rawQuery(sql, selectionArgs, ((JellyBeanCancellationHook) cancellationHook).cancellationSignal);
+ }
+ }
+
+ @Override
+ public CancellationHook createCancellationHook() {
+ return new JellyBeanCancellationHook();
+ }
+
+ /**
+ * Hook object that supports canceling a running query.
+ */
+ protected static class JellyBeanCancellationHook implements CancellationHook {
+
+ private final CancellationSignal cancellationSignal;
+
+ public JellyBeanCancellationHook() {
+ this.cancellationSignal = new CancellationSignal();
+ }
+
+ public void cancel() {
+ cancellationSignal.cancel();
+ }
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/core/LICENSE.txt b/MemeProject/app/src/main/java/com/j256/ormlite/core/LICENSE.txt
new file mode 100644
index 0000000..ff0417e
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/core/LICENSE.txt
@@ -0,0 +1,17 @@
+Copyright 2010 to 2011 by Gray Watson
+
+This file is part of the ORMLite package.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+The author may be contacted via http://ormlite.sourceforge.net/
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/core/README.txt b/MemeProject/app/src/main/java/com/j256/ormlite/core/README.txt
new file mode 100644
index 0000000..c7ec0db
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/core/README.txt
@@ -0,0 +1,15 @@
+This package provides the core functionality for the JDBC and Android packages. Users
+that are connecting to SQL databases via JDBC connections will need to download the
+ormlite-jdbc package as well. Android users should download the ormlite-android package
+as well as this core package.
+
+For more information, see the online documentation on the home page:
+
+ http://ormlite.com/
+
+Sources can be found online via Github:
+
+ https://github.com/j256/ormlite-core
+
+Enjoy,
+Gray Watson
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java
new file mode 100644
index 0000000..f25cd6e
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java
@@ -0,0 +1,1081 @@
+package com.j256.ormlite.dao;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.j256.ormlite.db.DatabaseType;
+import com.j256.ormlite.field.DataType;
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.field.FieldType;
+import com.j256.ormlite.misc.BaseDaoEnabled;
+import com.j256.ormlite.misc.SqlExceptionUtil;
+import com.j256.ormlite.stmt.DeleteBuilder;
+import com.j256.ormlite.stmt.GenericRowMapper;
+import com.j256.ormlite.stmt.PreparedDelete;
+import com.j256.ormlite.stmt.PreparedQuery;
+import com.j256.ormlite.stmt.PreparedUpdate;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.j256.ormlite.stmt.SelectArg;
+import com.j256.ormlite.stmt.SelectIterator;
+import com.j256.ormlite.stmt.StatementBuilder.StatementType;
+import com.j256.ormlite.stmt.StatementExecutor;
+import com.j256.ormlite.stmt.UpdateBuilder;
+import com.j256.ormlite.stmt.Where;
+import com.j256.ormlite.support.ConnectionSource;
+import com.j256.ormlite.support.DatabaseConnection;
+import com.j256.ormlite.support.DatabaseResults;
+import com.j256.ormlite.table.DatabaseTableConfig;
+import com.j256.ormlite.table.ObjectFactory;
+import com.j256.ormlite.table.TableInfo;
+
+/**
+ * Base class for the Database Access Objects that handle the reading and writing a class from the database.
+ *
+ *
+ * This class is also {@link Iterable} which means you can do a {@code for (T obj : dao)} type of loop code to iterate
+ * through the table of persisted objects. See {@link #iterator()}.
+ *
+ *
+ *
+ * NOTE: If you are using the Spring type wiring, {@link #initialize} should be called after all of the set
+ * methods. In Spring XML, init-method="initialize" should be used.
+ *
+ *
+ * @param
+ * The class that the code will be operating on.
+ * @param
+ * The class of the ID column associated with the class. The T class does not require an ID field. The class
+ * needs an ID parameter however so you can use Void or Object to satisfy the compiler.
+ * @author graywatson
+ */
+public abstract class BaseDaoImpl implements Dao {
+
+ private static final ThreadLocal>> daoConfigLevelLocal =
+ new ThreadLocal>>() {
+ @Override
+ protected List> initialValue() {
+ return new ArrayList>(10);
+ }
+ };
+ private static ReferenceObjectCache defaultObjectCache;
+ private static final Object constantObject = new Object();
+
+ protected StatementExecutor statementExecutor;
+ protected DatabaseType databaseType;
+ protected final Class dataClass;
+ protected DatabaseTableConfig tableConfig;
+ protected TableInfo tableInfo;
+ protected ConnectionSource connectionSource;
+ protected CloseableIterator lastIterator;
+ protected ObjectFactory objectFactory;
+
+ private boolean initialized;
+ private ObjectCache objectCache;
+ private Map daoObserverMap;
+
+ /**
+ * Construct our base DAO using Spring type wiring. The {@link ConnectionSource} must be set with the
+ * {@link #setConnectionSource} method afterwards and then the {@link #initialize()} method must be called. The
+ * dataClass provided must have its fields marked with {@link DatabaseField} annotations or the
+ * {@link #setTableConfig} method must be called before the {@link #initialize()} method is called.
+ *
+ *
+ * If you are using Spring then your should use: init-method="initialize"
+ *
+ *
+ * @param dataClass
+ * Class associated with this Dao. This must match the T class parameter.
+ */
+ protected BaseDaoImpl(Class dataClass) throws SQLException {
+ this(null, dataClass, null);
+ }
+
+ /**
+ * Construct our base DAO class. The dataClass provided must have its fields marked with {@link DatabaseField} or
+ * javax.persistance annotations.
+ *
+ * @param connectionSource
+ * Source of our database connections.
+ * @param dataClass
+ * Class associated with this Dao. This must match the T class parameter.
+ */
+ protected BaseDaoImpl(ConnectionSource connectionSource, Class dataClass) throws SQLException {
+ this(connectionSource, dataClass, null);
+ }
+
+ /**
+ * Construct our base DAO class.
+ *
+ * @param connectionSource
+ * Source of our database connections.
+ * @param tableConfig
+ * Hand or Spring wired table configuration information.
+ */
+ protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig tableConfig) throws SQLException {
+ this(connectionSource, tableConfig.getDataClass(), tableConfig);
+ }
+
+ private BaseDaoImpl(ConnectionSource connectionSource, Class dataClass, DatabaseTableConfig tableConfig)
+ throws SQLException {
+ this.dataClass = dataClass;
+ this.tableConfig = tableConfig;
+ if (connectionSource != null) {
+ this.connectionSource = connectionSource;
+ initialize();
+ }
+ }
+
+ /**
+ * Initialize the various DAO configurations after the various setters have been called.
+ */
+ public void initialize() throws SQLException {
+ if (initialized) {
+ // just skip it if already initialized
+ return;
+ }
+
+ if (connectionSource == null) {
+ throw new IllegalStateException("connectionSource was never set on " + getClass().getSimpleName());
+ }
+
+ databaseType = connectionSource.getDatabaseType();
+ if (databaseType == null) {
+ throw new IllegalStateException("connectionSource is getting a null DatabaseType in "
+ + getClass().getSimpleName());
+ }
+ if (tableConfig == null) {
+ tableInfo = new TableInfo(connectionSource, this, dataClass);
+ } else {
+ tableConfig.extractFieldTypes(connectionSource);
+ tableInfo = new TableInfo(databaseType, this, tableConfig);
+ }
+ statementExecutor = new StatementExecutor(databaseType, tableInfo, this);
+
+ /*
+ * This is a bit complex. Initially, when we were configuring the field types, external DAO information would be
+ * configured for auto-refresh, foreign BaseDaoEnabled classes, and foreign-collections. This would cause the
+ * system to go recursive and for class loops, a stack overflow.
+ *
+ * Then we fixed this by putting a level counter in the FieldType constructor that would stop the configurations
+ * when we reach some recursion level. But this created some bad problems because we were using the DaoManager
+ * to cache the created DAOs that had been constructed already limited by the level.
+ *
+ * What we do now is have a 2 phase initialization. The constructor initializes most of the fields but then we
+ * go back and call FieldType.configDaoInformation() after we are done. So for every DAO that is initialized
+ * here, we have to see if it is the top DAO. If not we save it for dao configuration later.
+ */
+ List> daoConfigList = daoConfigLevelLocal.get();
+ daoConfigList.add(this);
+ if (daoConfigList.size() > 1) {
+ // if we have recursed then just save the dao for later configuration
+ return;
+ }
+
+ try {
+ /*
+ * WARNING: We do _not_ use an iterator here because we may be adding to the list as we process it and we'll
+ * get exceptions otherwise. This is an ArrayList so the get(i) should be efficient.
+ *
+ * Also, do _not_ get a copy of daoConfigLevel.doArray because that array may be replaced by another, larger
+ * one during the recursion.
+ */
+ for (int i = 0; i < daoConfigList.size(); i++) {
+ BaseDaoImpl dao = daoConfigList.get(i);
+
+ /*
+ * Here's another complex bit. The first DAO that is being constructed as part of a DAO chain is not yet
+ * in the DaoManager cache. If we continue onward we might come back around and try to configure this
+ * DAO again. Forcing it into the cache here makes sure it won't be configured twice. This will cause it
+ * to be stuck in twice when it returns out to the DaoManager but that's a small price to pay. This also
+ * applies to self-referencing classes.
+ */
+ DaoManager.registerDao(connectionSource, dao);
+
+ try {
+ // config our fields which may go recursive
+ for (FieldType fieldType : dao.getTableInfo().getFieldTypes()) {
+ fieldType.configDaoInformation(connectionSource, dao.getDataClass());
+ }
+ } catch (SQLException e) {
+ // unregister the DAO we just pre-registered
+ DaoManager.unregisterDao(connectionSource, dao);
+ throw e;
+ }
+
+ // it's now been fully initialized
+ dao.initialized = true;
+ }
+ } finally {
+ // if we throw we want to clear our class hierarchy here
+ daoConfigList.clear();
+ daoConfigLevelLocal.remove();
+ }
+ }
+
+ public T queryForId(ID id) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.queryForId(connection, id, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public T queryForFirst(PreparedQuery preparedQuery) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.queryForFirst(connection, preparedQuery, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public List queryForAll() throws SQLException {
+ checkForInitialized();
+ return statementExecutor.queryForAll(connectionSource, objectCache);
+ }
+
+ public List queryForEq(String fieldName, Object value) throws SQLException {
+ return queryBuilder().where().eq(fieldName, value).query();
+ }
+
+ public QueryBuilder queryBuilder() {
+ checkForInitialized();
+ return new QueryBuilder(databaseType, tableInfo, this);
+ }
+
+ public UpdateBuilder updateBuilder() {
+ checkForInitialized();
+ return new UpdateBuilder(databaseType, tableInfo, this);
+ }
+
+ public DeleteBuilder deleteBuilder() {
+ checkForInitialized();
+ return new DeleteBuilder(databaseType, tableInfo, this);
+ }
+
+ public List query(PreparedQuery preparedQuery) throws SQLException {
+ checkForInitialized();
+ return statementExecutor.query(connectionSource, preparedQuery, objectCache);
+ }
+
+ public List queryForMatching(T matchObj) throws SQLException {
+ return queryForMatching(matchObj, false);
+ }
+
+ public List queryForMatchingArgs(T matchObj) throws SQLException {
+ return queryForMatching(matchObj, true);
+ }
+
+ public List queryForFieldValues(Map fieldValues) throws SQLException {
+ return queryForFieldValues(fieldValues, false);
+ }
+
+ public List queryForFieldValuesArgs(Map fieldValues) throws SQLException {
+ return queryForFieldValues(fieldValues, true);
+ }
+
+ public T queryForSameId(T data) throws SQLException {
+ checkForInitialized();
+ if (data == null) {
+ return null;
+ }
+ ID id = extractId(data);
+ if (id == null) {
+ return null;
+ } else {
+ return queryForId(id);
+ }
+ }
+
+ public int create(T data) throws SQLException {
+ checkForInitialized();
+ // ignore creating a null object
+ if (data == null) {
+ return 0;
+ }
+ if (data instanceof BaseDaoEnabled) {
+ @SuppressWarnings("unchecked")
+ BaseDaoEnabled daoEnabled = (BaseDaoEnabled) data;
+ daoEnabled.setDao(this);
+ }
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.create(connection, data, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int create(final Collection datas) throws SQLException {
+ checkForInitialized();
+ for (T data : datas) {
+ if (data instanceof BaseDaoEnabled) {
+ @SuppressWarnings("unchecked")
+ BaseDaoEnabled daoEnabled = (BaseDaoEnabled) data;
+ daoEnabled.setDao(this);
+ }
+ }
+ /*
+ * This is a little strange in that we get the connection but then the call-batch-task saves another one. I
+ * thought that it was an ok thing to do otherwise it made the call-batch-tasks more complicated.
+ */
+ final DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return callBatchTasks(new Callable() {
+ public Integer call() throws SQLException {
+ int modCount = 0;
+ for (T data : datas) {
+ modCount += statementExecutor.create(connection, data, objectCache);
+ }
+ return modCount;
+ }
+ });
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public T createIfNotExists(T data) throws SQLException {
+ if (data == null) {
+ return null;
+ }
+ T existing = queryForSameId(data);
+ if (existing == null) {
+ create(data);
+ return data;
+ } else {
+ return existing;
+ }
+ }
+
+ public CreateOrUpdateStatus createOrUpdate(T data) throws SQLException {
+ if (data == null) {
+ return new CreateOrUpdateStatus(false, false, 0);
+ }
+ ID id = extractId(data);
+ // assume we need to create it if there is no id
+ if (id == null || !idExists(id)) {
+ int numRows = create(data);
+ return new CreateOrUpdateStatus(true, false, numRows);
+ } else {
+ int numRows = update(data);
+ return new CreateOrUpdateStatus(false, true, numRows);
+ }
+ }
+
+ public int update(T data) throws SQLException {
+ checkForInitialized();
+ // ignore updating a null object
+ if (data == null) {
+ return 0;
+ }
+ if (data instanceof BaseDaoEnabled) {
+ @SuppressWarnings("unchecked")
+ BaseDaoEnabled daoEnabled = (BaseDaoEnabled) data;
+ daoEnabled.setDao(this);
+ }
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.update(connection, data, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int updateId(T data, ID newId) throws SQLException {
+ checkForInitialized();
+ // ignore updating a null object
+ if (data == null) {
+ return 0;
+ } else {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.updateId(connection, data, newId, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+ }
+
+ public int update(PreparedUpdate preparedUpdate) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.update(connection, preparedUpdate);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int refresh(T data) throws SQLException {
+ checkForInitialized();
+ // ignore refreshing a null object
+ if (data == null) {
+ return 0;
+ }
+ if (data instanceof BaseDaoEnabled) {
+ @SuppressWarnings("unchecked")
+ BaseDaoEnabled daoEnabled = (BaseDaoEnabled) data;
+ daoEnabled.setDao(this);
+ }
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.refresh(connection, data, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int delete(T data) throws SQLException {
+ checkForInitialized();
+ // ignore deleting a null object
+ if (data == null) {
+ return 0;
+ } else {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.delete(connection, data, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+ }
+
+ public int deleteById(ID id) throws SQLException {
+ checkForInitialized();
+ // ignore deleting a null id
+ if (id == null) {
+ return 0;
+ } else {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.deleteById(connection, id, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+ }
+
+ public int delete(Collection datas) throws SQLException {
+ checkForInitialized();
+ // ignore deleting a null object
+ if (datas == null || datas.isEmpty()) {
+ return 0;
+ } else {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.deleteObjects(connection, datas, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+ }
+
+ public int deleteIds(Collection ids) throws SQLException {
+ checkForInitialized();
+ // ignore deleting a null object
+ if (ids == null || ids.isEmpty()) {
+ return 0;
+ } else {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.deleteIds(connection, ids, objectCache);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+ }
+
+ public int delete(PreparedDelete preparedDelete) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.delete(connection, preparedDelete);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public CloseableIterator iterator() {
+ return iterator(DatabaseConnection.DEFAULT_RESULT_FLAGS);
+ }
+
+ public CloseableIterator closeableIterator() {
+ return iterator(DatabaseConnection.DEFAULT_RESULT_FLAGS);
+ }
+
+ public CloseableIterator iterator(int resultFlags) {
+ checkForInitialized();
+ lastIterator = createIterator(resultFlags);
+ return lastIterator;
+ }
+
+ public CloseableWrappedIterable getWrappedIterable() {
+ checkForInitialized();
+ return new CloseableWrappedIterableImpl(new CloseableIterable() {
+ public Iterator iterator() {
+ return closeableIterator();
+ }
+ public CloseableIterator closeableIterator() {
+ try {
+ return BaseDaoImpl.this.createIterator(DatabaseConnection.DEFAULT_RESULT_FLAGS);
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not build iterator for " + dataClass, e);
+ }
+ }
+ });
+ }
+
+ public CloseableWrappedIterable getWrappedIterable(final PreparedQuery preparedQuery) {
+ checkForInitialized();
+ return new CloseableWrappedIterableImpl(new CloseableIterable() {
+ public Iterator iterator() {
+ return closeableIterator();
+ }
+ public CloseableIterator closeableIterator() {
+ try {
+ return BaseDaoImpl.this.createIterator(preparedQuery, DatabaseConnection.DEFAULT_RESULT_FLAGS);
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not build prepared-query iterator for " + dataClass, e);
+ }
+ }
+ });
+ }
+
+ public void closeLastIterator() throws IOException {
+ if (lastIterator != null) {
+ lastIterator.close();
+ lastIterator = null;
+ }
+ }
+
+ public CloseableIterator iterator(PreparedQuery preparedQuery) throws SQLException {
+ return iterator(preparedQuery, DatabaseConnection.DEFAULT_RESULT_FLAGS);
+ }
+
+ public CloseableIterator iterator(PreparedQuery preparedQuery, int resultFlags) throws SQLException {
+ checkForInitialized();
+ lastIterator = createIterator(preparedQuery, resultFlags);
+ return lastIterator;
+ }
+
+ public GenericRawResults queryRaw(String query, String... arguments) throws SQLException {
+ checkForInitialized();
+ try {
+ return statementExecutor.queryRaw(connectionSource, query, arguments, objectCache);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not perform raw query for " + query, e);
+ }
+ }
+
+ public GenericRawResults queryRaw(String query, RawRowMapper mapper, String... arguments)
+ throws SQLException {
+ checkForInitialized();
+ try {
+ return statementExecutor.queryRaw(connectionSource, query, mapper, arguments, objectCache);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not perform raw query for " + query, e);
+ }
+ }
+
+ public GenericRawResults queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper mapper,
+ String... arguments) throws SQLException {
+ checkForInitialized();
+ try {
+ return statementExecutor.queryRaw(connectionSource, query, columnTypes, mapper, arguments, objectCache);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not perform raw query for " + query, e);
+ }
+ }
+
+ public GenericRawResults queryRaw(String query, DataType[] columnTypes, String... arguments)
+ throws SQLException {
+ checkForInitialized();
+ try {
+ return statementExecutor.queryRaw(connectionSource, query, columnTypes, arguments, objectCache);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not perform raw query for " + query, e);
+ }
+ }
+
+ public GenericRawResults queryRaw(String query, DatabaseResultsMapper mapper, String... arguments)
+ throws SQLException {
+ checkForInitialized();
+ try {
+ return statementExecutor.queryRaw(connectionSource, query, mapper, arguments, objectCache);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not perform raw query for " + query, e);
+ }
+ }
+
+ public long queryRawValue(String query, String... arguments) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.queryForLong(connection, query, arguments);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not perform raw value query for " + query, e);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int executeRaw(String statement, String... arguments) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.executeRaw(connection, statement, arguments);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not run raw execute statement " + statement, e);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int executeRawNoArgs(String statement) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.executeRawNoArgs(connection, statement);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not run raw execute statement " + statement, e);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public int updateRaw(String statement, String... arguments) throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return statementExecutor.updateRaw(connection, statement, arguments);
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not run raw update statement " + statement, e);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public CT callBatchTasks(Callable callable) throws SQLException {
+ checkForInitialized();
+ return statementExecutor.callBatchTasks(connectionSource, callable);
+ }
+
+ public String objectToString(T data) {
+ checkForInitialized();
+ return tableInfo.objectToString(data);
+ }
+
+ public boolean objectsEqual(T data1, T data2) throws SQLException {
+ checkForInitialized();
+ for (FieldType fieldType : tableInfo.getFieldTypes()) {
+ Object fieldObj1 = fieldType.extractJavaFieldValue(data1);
+ Object fieldObj2 = fieldType.extractJavaFieldValue(data2);
+ // we can't just do fieldObj1.equals(fieldObj2) because of byte[].equals()
+ if (!fieldType.getDataPersister().dataIsEqual(fieldObj1, fieldObj2)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public ID extractId(T data) throws SQLException {
+ checkForInitialized();
+ FieldType idField = tableInfo.getIdField();
+ if (idField == null) {
+ throw new SQLException("Class " + dataClass + " does not have an id field");
+ }
+ @SuppressWarnings("unchecked")
+ ID id = (ID) idField.extractJavaFieldValue(data);
+ return id;
+ }
+
+ public Class getDataClass() {
+ return dataClass;
+ }
+
+ public FieldType findForeignFieldType(Class clazz) {
+ checkForInitialized();
+ for (FieldType fieldType : tableInfo.getFieldTypes()) {
+ if (fieldType.getType() == clazz) {
+ return fieldType;
+ }
+ }
+ return null;
+ }
+
+ public boolean isUpdatable() {
+ return tableInfo.isUpdatable();
+ }
+
+ public boolean isTableExists() throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return connection.isTableExists(tableInfo.getTableName());
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public long countOf() throws SQLException {
+ checkForInitialized();
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.queryForCountStar(connection);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public long countOf(PreparedQuery preparedQuery) throws SQLException {
+ checkForInitialized();
+ if (preparedQuery.getType() != StatementType.SELECT_LONG) {
+ throw new IllegalArgumentException("Prepared query is not of type " + StatementType.SELECT_LONG
+ + ", you need to call QueryBuilder.setCountOf(true)");
+ }
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.queryForLong(connection, preparedQuery);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public void assignEmptyForeignCollection(T parent, String fieldName) throws SQLException {
+ makeEmptyForeignCollection(parent, fieldName);
+ }
+
+ public ForeignCollection getEmptyForeignCollection(String fieldName) throws SQLException {
+ return makeEmptyForeignCollection(null, fieldName);
+ }
+
+ public void setObjectCache(boolean enabled) throws SQLException {
+ if (enabled) {
+ if (objectCache == null) {
+ if (tableInfo.getIdField() == null) {
+ throw new SQLException("Class " + dataClass + " must have an id field to enable the object cache");
+ }
+ synchronized (BaseDaoImpl.class) {
+ if (defaultObjectCache == null) {
+ // only make one
+ defaultObjectCache = ReferenceObjectCache.makeWeakCache();
+ }
+ objectCache = defaultObjectCache;
+ }
+ objectCache.registerClass(dataClass);
+ }
+ } else {
+ if (objectCache != null) {
+ objectCache.clear(dataClass);
+ objectCache = null;
+ }
+ }
+ }
+
+ public void setObjectCache(ObjectCache objectCache) throws SQLException {
+ if (objectCache == null) {
+ if (this.objectCache != null) {
+ // help with GC-ing
+ this.objectCache.clear(dataClass);
+ this.objectCache = null;
+ }
+ } else {
+ if (this.objectCache != null && this.objectCache != objectCache) {
+ // help with GC-ing
+ this.objectCache.clear(dataClass);
+ }
+ if (tableInfo.getIdField() == null) {
+ throw new SQLException("Class " + dataClass + " must have an id field to enable the object cache");
+ }
+ this.objectCache = objectCache;
+ this.objectCache.registerClass(dataClass);
+ }
+ }
+
+ public ObjectCache getObjectCache() {
+ return objectCache;
+ }
+
+ public void clearObjectCache() {
+ if (objectCache != null) {
+ objectCache.clear(dataClass);
+ }
+ }
+
+ /**
+ * Special call mostly used in testing to clear the internal object caches so we can reset state.
+ */
+ public synchronized static void clearAllInternalObjectCaches() {
+ if (defaultObjectCache != null) {
+ defaultObjectCache.clearAll();
+ defaultObjectCache = null;
+ }
+ }
+
+ public T mapSelectStarRow(DatabaseResults results) throws SQLException {
+ return statementExecutor.getSelectStarRowMapper().mapRow(results);
+ }
+
+ public void notifyChanges() {
+ if (daoObserverMap != null) {
+ for (DaoObserver daoObserver : daoObserverMap.keySet()) {
+ daoObserver.onChange();
+ }
+ }
+ }
+
+ public void registerObserver(DaoObserver observer) {
+ if (daoObserverMap == null) {
+ /*
+ * We are doing this so no other systems need to pay the penalty for the new observer code. This seems like
+ * it would be a double-check locking bug but I don't think so. We are putting into a synchronized
+ * collection that locks so we should not have partial constructor issues.
+ */
+ synchronized (this) {
+ if (daoObserverMap == null) {
+ daoObserverMap = new ConcurrentHashMap();
+ }
+ }
+ }
+ // no values in the map
+ daoObserverMap.put(observer, constantObject);
+ }
+
+ public void unregisterObserver(DaoObserver observer) {
+ if (daoObserverMap != null) {
+ synchronized (daoObserverMap) {
+ daoObserverMap.remove(observer);
+ }
+ }
+ }
+
+ public GenericRowMapper getSelectStarRowMapper() throws SQLException {
+ return statementExecutor.getSelectStarRowMapper();
+ }
+
+ public RawRowMapper getRawRowMapper() {
+ return statementExecutor.getRawRowMapper();
+ }
+
+ public boolean idExists(ID id) throws SQLException {
+ DatabaseConnection connection = connectionSource.getReadOnlyConnection();
+ try {
+ return statementExecutor.ifExists(connection, id);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public DatabaseConnection startThreadConnection() throws SQLException {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ connectionSource.saveSpecialConnection(connection);
+ return connection;
+ }
+
+ public void endThreadConnection(DatabaseConnection connection) throws SQLException {
+ connectionSource.clearSpecialConnection(connection);
+ connectionSource.releaseConnection(connection);
+ }
+
+ public void setAutoCommit(boolean autoCommit) throws SQLException {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ setAutoCommit(connection, autoCommit);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public void setAutoCommit(DatabaseConnection connection, boolean autoCommit) throws SQLException {
+ connection.setAutoCommit(autoCommit);
+ }
+
+ public boolean isAutoCommit() throws SQLException {
+ DatabaseConnection connection = connectionSource.getReadWriteConnection();
+ try {
+ return isAutoCommit(connection);
+ } finally {
+ connectionSource.releaseConnection(connection);
+ }
+ }
+
+ public boolean isAutoCommit(DatabaseConnection connection) throws SQLException {
+ return connection.isAutoCommit();
+ }
+
+ public void commit(DatabaseConnection connection) throws SQLException {
+ connection.commit(null);
+ }
+
+ public void rollBack(DatabaseConnection connection) throws SQLException {
+ connection.rollback(null);
+ }
+
+ public ObjectFactory getObjectFactory() {
+ return objectFactory;
+ }
+
+ public void setObjectFactory(ObjectFactory objectFactory) {
+ checkForInitialized();
+ this.objectFactory = objectFactory;
+ }
+
+ /**
+ * Returns the table configuration information associated with the Dao's class or null if none.
+ */
+ public DatabaseTableConfig getTableConfig() {
+ return tableConfig;
+ }
+
+ /**
+ * Used by internal classes to get the table information structure for the Dao's class.
+ */
+ public TableInfo getTableInfo() {
+ return tableInfo;
+ }
+
+ public ConnectionSource getConnectionSource() {
+ return connectionSource;
+ }
+
+ public void setConnectionSource(ConnectionSource connectionSource) {
+ this.connectionSource = connectionSource;
+ }
+
+ /**
+ * Used if you want to configure the class for the Dao by hand or with spring instead of using the
+ * {@link DatabaseField} annotation in the class. This must be called before {@link #initialize}.
+ */
+ public void setTableConfig(DatabaseTableConfig tableConfig) {
+ this.tableConfig = tableConfig;
+ }
+
+ /**
+ * Helper method to create a Dao object without having to define a class. Dao classes are supposed to be convenient
+ * but if you have a lot of classes, they can seem to be a pain.
+ *
+ *
+ * NOTE: You should use {@link DaoManager#createDao(ConnectionSource, DatabaseTableConfig)} instead of this
+ * method so you won't have to create the DAO multiple times.
+ *
+ */
+ static Dao createDao(ConnectionSource connectionSource, Class clazz) throws SQLException {
+ return new BaseDaoImpl(connectionSource, clazz) {
+ };
+ }
+
+ /**
+ * Helper method to create a Dao object used by some internal methods that already have the {@link TableInfo}.
+ *
+ *
+ * NOTE: You should use {@link DaoManager#createDao(ConnectionSource, DatabaseTableConfig)} instead of this
+ * method so you won't have to create the DAO multiple times.
+ *
+ */
+ static Dao createDao(ConnectionSource connectionSource, DatabaseTableConfig tableConfig)
+ throws SQLException {
+ return new BaseDaoImpl(connectionSource, tableConfig) {
+ };
+ }
+
+ protected void checkForInitialized() {
+ if (!initialized) {
+ throw new IllegalStateException("you must call initialize() before you can use the dao");
+ }
+ }
+
+ private ForeignCollection makeEmptyForeignCollection(T parent, String fieldName) throws SQLException {
+ checkForInitialized();
+ ID id;
+ if (parent == null) {
+ id = null;
+ } else {
+ id = extractId(parent);
+ }
+ for (FieldType fieldType : tableInfo.getFieldTypes()) {
+ if (fieldType.getColumnName().equals(fieldName)) {
+ @SuppressWarnings("unchecked")
+ ForeignCollection collection = (ForeignCollection) fieldType.buildForeignCollection(parent, id);
+ if (parent != null) {
+ fieldType.assignField(parent, collection, true, null);
+ }
+ return collection;
+ }
+ }
+ throw new IllegalArgumentException("Could not find a field named " + fieldName);
+ }
+
+ private CloseableIterator createIterator(int resultFlags) {
+ try {
+ SelectIterator iterator =
+ statementExecutor.buildIterator(this, connectionSource, resultFlags, objectCache);
+ return iterator;
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not build iterator for " + dataClass, e);
+ }
+ }
+
+ private CloseableIterator createIterator(PreparedQuery preparedQuery, int resultFlags) throws SQLException {
+ try {
+ SelectIterator iterator =
+ statementExecutor.buildIterator(this, connectionSource, preparedQuery, objectCache, resultFlags);
+ return iterator;
+ } catch (SQLException e) {
+ throw SqlExceptionUtil.create("Could not build prepared-query iterator for " + dataClass, e);
+ }
+ }
+
+ private List queryForMatching(T matchObj, boolean useArgs) throws SQLException {
+ checkForInitialized();
+ QueryBuilder qb = queryBuilder();
+ Where where = qb.where();
+ int fieldC = 0;
+ for (FieldType fieldType : tableInfo.getFieldTypes()) {
+ Object fieldValue = fieldType.getFieldValueIfNotDefault(matchObj);
+ if (fieldValue != null) {
+ if (useArgs) {
+ fieldValue = new SelectArg(fieldValue);
+ }
+ where.eq(fieldType.getColumnName(), fieldValue);
+ fieldC++;
+ }
+ }
+ if (fieldC == 0) {
+ return Collections.emptyList();
+ } else {
+ where.and(fieldC);
+ return qb.query();
+ }
+ }
+
+ private List queryForFieldValues(Map fieldValues, boolean useArgs) throws SQLException {
+ checkForInitialized();
+ QueryBuilder qb = queryBuilder();
+ Where where = qb.where();
+ for (Map.Entry entry : fieldValues.entrySet()) {
+ Object fieldValue = entry.getValue();
+ if (useArgs) {
+ fieldValue = new SelectArg(fieldValue);
+ }
+ where.eq(entry.getKey(), fieldValue);
+ }
+ if (fieldValues.size() == 0) {
+ return Collections.emptyList();
+ } else {
+ where.and(fieldValues.size());
+ return qb.query();
+ }
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/BaseForeignCollection.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/BaseForeignCollection.java
new file mode 100644
index 0000000..b8ec8b0
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/BaseForeignCollection.java
@@ -0,0 +1,195 @@
+package com.j256.ormlite.dao;
+
+import java.io.Serializable;
+import java.sql.SQLException;
+import java.util.Collection;
+
+import com.j256.ormlite.field.FieldType;
+import com.j256.ormlite.field.ForeignCollectionField;
+import com.j256.ormlite.misc.IOUtils;
+import com.j256.ormlite.stmt.PreparedQuery;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.j256.ormlite.stmt.SelectArg;
+import com.j256.ormlite.stmt.mapped.MappedPreparedStmt;
+
+/**
+ * Base collection that is set on a field that as been marked with the {@link ForeignCollectionField} annotation when an
+ * object is refreshed or queried (i.e. not created).
+ *
+ *
+ * WARNING: Most likely for(;;) loops should not be used here since we need to be careful about closing the
+ * iterator.
+ *
+ *
+ * @author graywatson
+ */
+public abstract class BaseForeignCollection implements ForeignCollection, Serializable {
+
+ private static final long serialVersionUID = -5158840898186237589L;
+
+ protected transient final Dao dao;
+ private transient final FieldType foreignFieldType;
+ private transient final Object parentId;
+ private transient PreparedQuery preparedQuery;
+ private transient final String orderColumn;
+ private transient final boolean orderAscending;
+ private transient final Object parent;
+
+ protected BaseForeignCollection(Dao dao, Object parent, Object parentId, FieldType foreignFieldType,
+ String orderColumn, boolean orderAscending) {
+ this.dao = dao;
+ this.foreignFieldType = foreignFieldType;
+ this.parentId = parentId;
+ this.orderColumn = orderColumn;
+ this.orderAscending = orderAscending;
+ this.parent = parent;
+ }
+
+ /**
+ * Add an element to the collection. This will also add the item to the associated database table.
+ *
+ * @return Returns true if the item did not already exist in the collection otherwise false.
+ */
+ public boolean add(T data) {
+ try {
+ return addElement(data);
+ } catch (SQLException e) {
+ throw new IllegalStateException("Could not create data element in dao", e);
+ }
+ }
+
+ /**
+ * Add the collection of elements to this collection. This will also them to the associated database table.
+ *
+ * @return Returns true if any of the items did not already exist in the collection otherwise false.
+ */
+ public boolean addAll(Collection collection) {
+ boolean changed = false;
+ for (T data : collection) {
+ try {
+ if (addElement(data)) {
+ changed = true;
+ }
+ } catch (SQLException e) {
+ throw new IllegalStateException("Could not create data elements in dao", e);
+ }
+ }
+ return changed;
+ }
+
+ /**
+ * Remove the item from the collection and the associated database table.
+ *
+ * NOTE: we can't just do a dao.delete(data) because it has to be in the collection.
+ *
+ * @return True if the item was found in the collection otherwise false.
+ */
+ public abstract boolean remove(Object data);
+
+ /**
+ * Remove the items in the collection argument from the foreign collection and the associated database table.
+ *
+ * NOTE: we can't just do a for (...) dao.delete(item) because the items have to be in the collection.
+ *
+ * @return True if the item was found in the collection otherwise false.
+ */
+ public abstract boolean removeAll(Collection collection);
+
+ /**
+ * Uses the iterator to run through the dao and retain only the items that are in the passed in collection. This
+ * will remove the items from the associated database table as well.
+ *
+ * @return Returns true of the collection was changed at all otherwise false.
+ */
+ public boolean retainAll(Collection collection) {
+ if (dao == null) {
+ return false;
+ }
+ boolean changed = false;
+ CloseableIterator iterator = closeableIterator();
+ try {
+ while (iterator.hasNext()) {
+ T data = iterator.next();
+ if (!collection.contains(data)) {
+ iterator.remove();
+ changed = true;
+ }
+ }
+ return changed;
+ } finally {
+ IOUtils.closeQuietly(iterator);
+ }
+ }
+
+ /**
+ * Clears the collection and uses the iterator to run through the dao and delete all of the items in the collection
+ * from the associated database table. This is different from removing all of the elements in the table since this
+ * iterator is across just one item's foreign objects.
+ */
+ public void clear() {
+ if (dao == null) {
+ return;
+ }
+ CloseableIterator iterator = closeableIterator();
+ try {
+ while (iterator.hasNext()) {
+ iterator.next();
+ iterator.remove();
+ }
+ } finally {
+ IOUtils.closeQuietly(iterator);
+ }
+ }
+
+ public int update(T data) throws SQLException {
+ if (dao == null) {
+ return 0;
+ } else {
+ return dao.update(data);
+ }
+ }
+
+ public int refresh(T data) throws SQLException {
+ if (dao == null) {
+ return 0;
+ } else {
+ return dao.refresh(data);
+ }
+ }
+
+ public Dao getDao() {
+ return dao;
+ }
+
+ protected PreparedQuery getPreparedQuery() throws SQLException {
+ if (dao == null) {
+ return null;
+ }
+ if (preparedQuery == null) {
+ SelectArg fieldArg = new SelectArg();
+ fieldArg.setValue(parentId);
+ QueryBuilder qb = dao.queryBuilder();
+ if (orderColumn != null) {
+ qb.orderBy(orderColumn, orderAscending);
+ }
+ preparedQuery = qb.where().eq(foreignFieldType.getColumnName(), fieldArg).prepare();
+ if (preparedQuery instanceof MappedPreparedStmt) {
+ @SuppressWarnings("unchecked")
+ MappedPreparedStmt mappedStmt = ((MappedPreparedStmt) preparedQuery);
+ mappedStmt.setParentInformation(parent, parentId);
+ }
+ }
+ return preparedQuery;
+ }
+
+ private boolean addElement(T data) throws SQLException {
+ if (dao == null) {
+ return false;
+ }
+ if (parent != null && foreignFieldType.getFieldValueIfNotDefault(data) == null) {
+ foreignFieldType.assignField(data, parent, true, null);
+ }
+ dao.create(data);
+ return true;
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableIterable.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableIterable.java
new file mode 100644
index 0000000..224bdf2
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableIterable.java
@@ -0,0 +1,14 @@
+package com.j256.ormlite.dao;
+
+/**
+ * Extension to Iterable to provide a iterator() method that returns a {@link CloseableIterator}.
+ *
+ * @author graywatson
+ */
+public interface CloseableIterable extends Iterable {
+
+ /**
+ * Returns an iterator over a set of elements of type T which can be closed.
+ */
+ public CloseableIterator closeableIterator();
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableIterator.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableIterator.java
new file mode 100644
index 0000000..cb4893c
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableIterator.java
@@ -0,0 +1,73 @@
+package com.j256.ormlite.dao;
+
+import java.io.Closeable;
+import java.sql.SQLException;
+import java.util.Iterator;
+
+import com.j256.ormlite.support.DatabaseResults;
+
+/**
+ * Extension to Iterator to provide a close() method. This should be in the JDK.
+ *
+ *
+ * NOTE: You must call {@link CloseableIterator#close()} method when you are done otherwise the underlying SQL
+ * statement and connection may be kept open.
+ *
+ *
+ * @author graywatson
+ */
+public interface CloseableIterator extends Iterator, Closeable {
+
+ /**
+ * Close any underlying SQL statements but swallow any SQLExceptions.
+ */
+ public void closeQuietly();
+
+ /**
+ * Return the underlying database results object if any. May return null. This should not be used unless you know
+ * what you are doing.
+ */
+ public DatabaseResults getRawResults();
+
+ /**
+ * Move to the next item in the iterator without calling {@link #next()}.
+ */
+ public void moveToNext();
+
+ /**
+ * Move to the first result and return it or null if none. This may not work with the default iterator depending on
+ * your database.
+ */
+ public T first() throws SQLException;
+
+ /**
+ * Moves to the previous result and return it or null if none. This may not work with the default iterator depending
+ * on your database.
+ */
+ public T previous() throws SQLException;
+
+ /**
+ * Return the current result object that we have accessed or null if none.
+ */
+ public T current() throws SQLException;
+
+ /**
+ * Returns the {@link #next()} object in the table or null if none.
+ *
+ * @throws SQLException
+ * Throws a SQLException on error since {@link #next()} cannot throw because it is part of the
+ * {@link Iterator} definition. It will not throw if there is no next.
+ */
+ public T nextThrow() throws SQLException;
+
+ /**
+ * Move a relative position in the list and return that result or null if none. Moves forward (positive value) or
+ * backwards (negative value) the list of results. moveRelative(1) should be the same as {@link #next()}.
+ * moveRelative(-1) is the same as {@link #previous} result. This may not work with the default iterator depending
+ * on your database.
+ *
+ * @param offset
+ * Number of rows to move. Positive moves forward in the results. Negative moves backwards.
+ */
+ public T moveRelative(int offset) throws SQLException;
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableWrappedIterable.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableWrappedIterable.java
new file mode 100644
index 0000000..dba6710
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableWrappedIterable.java
@@ -0,0 +1,29 @@
+package com.j256.ormlite.dao;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+/**
+ * Extension to CloseableIterable which defines a class which has an iterator() method that returns a
+ * {@link CloseableIterator} but also can be closed itself. This allows us to do something like this pattern:
+ *
+ *
+ * CloseableWrappedIterable<Foo> wrapperIterable = fooDao.getCloseableIterable();
+ * try {
+ * for (Foo foo : wrapperIterable) {
+ * ...
+ * }
+ * } finally {
+ * wrapperIterable.close();
+ * }
+ *
+ *
+ * @author graywatson
+ */
+public interface CloseableWrappedIterable extends CloseableIterable, Closeable {
+
+ /**
+ * This will close the last iterator returned by the {@link #iterator()} method.
+ */
+ public void close() throws IOException;
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableWrappedIterableImpl.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableWrappedIterableImpl.java
new file mode 100644
index 0000000..a589abd
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/CloseableWrappedIterableImpl.java
@@ -0,0 +1,39 @@
+package com.j256.ormlite.dao;
+
+import java.io.IOException;
+
+import com.j256.ormlite.misc.IOUtils;
+
+/**
+ * Class which is used to help folks use for loops but still close at the end. This is a wrapper to allow multiple
+ * threads to iterate across the same dao or the same lazy collection at the same time. See
+ * {@link Dao#getWrappedIterable()} or {@link ForeignCollection#getWrappedIterable()}.
+ *
+ * @author graywatson
+ */
+public class CloseableWrappedIterableImpl implements CloseableWrappedIterable {
+
+ private final CloseableIterable iterable;
+ private CloseableIterator iterator;
+
+ public CloseableWrappedIterableImpl(CloseableIterable iterable) {
+ this.iterable = iterable;
+ }
+
+ public CloseableIterator iterator() {
+ return closeableIterator();
+ }
+
+ public CloseableIterator closeableIterator() {
+ IOUtils.closeQuietly(this);
+ iterator = iterable.closeableIterator();
+ return iterator;
+ }
+
+ public void close() throws IOException {
+ if (iterator != null) {
+ iterator.close();
+ iterator = null;
+ }
+ }
+}
diff --git a/MemeProject/app/src/main/java/com/j256/ormlite/dao/Dao.java b/MemeProject/app/src/main/java/com/j256/ormlite/dao/Dao.java
new file mode 100644
index 0000000..0a6d0fb
--- /dev/null
+++ b/MemeProject/app/src/main/java/com/j256/ormlite/dao/Dao.java
@@ -0,0 +1,891 @@
+package com.j256.ormlite.dao;
+
+import java.io.IOException;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+import com.j256.ormlite.field.DataType;
+import com.j256.ormlite.field.DatabaseField;
+import com.j256.ormlite.field.FieldType;
+import com.j256.ormlite.field.ForeignCollectionField;
+import com.j256.ormlite.stmt.DeleteBuilder;
+import com.j256.ormlite.stmt.GenericRowMapper;
+import com.j256.ormlite.stmt.PreparedDelete;
+import com.j256.ormlite.stmt.PreparedQuery;
+import com.j256.ormlite.stmt.PreparedUpdate;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.j256.ormlite.stmt.SelectArg;
+import com.j256.ormlite.stmt.UpdateBuilder;
+import com.j256.ormlite.support.ConnectionSource;
+import com.j256.ormlite.support.DatabaseConnection;
+import com.j256.ormlite.support.DatabaseResults;
+import com.j256.ormlite.table.ObjectFactory;
+
+/**
+ * The definition of the Database Access Objects that handle the reading and writing a class from the database. Kudos to
+ * Robert A. for the general concept of this hierarchy.
+ *
+ * @param
+ * The class that the code will be operating on.
+ * @param
+ * The class of the ID column associated with the class. The T class does not require an ID field. The class
+ * needs an ID parameter however so you can use Void or Object to satisfy the compiler.
+ * @author graywatson
+ */
+public interface Dao extends CloseableIterable {
+
+ /**
+ * Retrieves an object associated with a specific ID.
+ *
+ * @param id
+ * Identifier that matches a specific row in the database to find and return.
+ * @return The object that has the ID field which equals id or null if no matches.
+ * @throws SQLException
+ * on any SQL problems or if more than 1 item with the id are found in the database.
+ */
+ public T queryForId(ID id) throws SQLException;
+
+ /**
+ * Query for and return the first item in the object table which matches the PreparedQuery. See
+ * {@link #queryBuilder()} for more information. This can be used to return the object that matches a single unique
+ * column. You should use {@link #queryForId(Object)} if you want to query for the id column.
+ *
+ * @param preparedQuery
+ * Query used to match the objects in the database.
+ * @return The first object that matches the query.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public T queryForFirst(PreparedQuery preparedQuery) throws SQLException;
+
+ /**
+ * Query for all of the items in the object table. For medium sized or large tables, this may load a lot of objects
+ * into memory so you should consider using the {@link #iterator()} method instead.
+ *
+ * @return A list of all of the objects in the table.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public List queryForAll() throws SQLException;
+
+ /**
+ * Query for the items in the object table that match a simple where with a single field = value type of WHERE
+ * clause. This is a convenience method for calling queryBuilder().where().eq(fieldName, value).query().
+ *
+ * @return A list of the objects in the table that match the fieldName = value;
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public List queryForEq(String fieldName, Object value) throws SQLException;
+
+ /**
+ * Query for the rows in the database that match the object passed in as a parameter. Any fields in the matching
+ * object that are not the default value (null, false, 0, 0.0, etc.) are used as the matching parameters with AND.
+ * If you are worried about SQL quote escaping, you should use {@link #queryForMatchingArgs(Object)}.
+ */
+ public List queryForMatching(T matchObj) throws SQLException;
+
+ /**
+ * Same as {@link #queryForMatching(Object)} but this uses {@link SelectArg} and SQL ? arguments. This is slightly
+ * more expensive but you don't have to worry about SQL quote escaping.
+ */
+ public List queryForMatchingArgs(T matchObj) throws SQLException;
+
+ /**
+ * Query for the rows in the database that matches all of the field to value entries from the map passed in. If you
+ * are worried about SQL quote escaping, you should use {@link #queryForFieldValuesArgs(Map)}.
+ */
+ public List queryForFieldValues(Map fieldValues) throws SQLException;
+
+ /**
+ * Same as {@link #queryForFieldValues(Map)} but this uses {@link SelectArg} and SQL ? arguments. This is slightly
+ * more expensive but you don't have to worry about SQL quote escaping.
+ */
+ public List queryForFieldValuesArgs(Map fieldValues) throws SQLException;
+
+ /**
+ * Query for a data item in the table that has the same id as the data parameter.
+ */
+ public T queryForSameId(T data) throws SQLException;
+
+ /**
+ * Create and return a new query builder object which allows you to build a custom SELECT statement. You call
+ * methods on the builder to construct your statement and then call {@link QueryBuilder#prepare()} once you are
+ * ready to build. This returns a {@link PreparedQuery} object which gets passed to {@link #query(PreparedQuery)} or
+ * {@link #iterator(PreparedQuery)}.
+ */
+ public QueryBuilder queryBuilder();
+
+ /**
+ * Like {@link #queryBuilder()} but allows you to build an UPDATE statement. You can then call call
+ * {@link UpdateBuilder#prepare()} and pass the returned {@link PreparedUpdate} to {@link #update(PreparedUpdate)}.
+ */
+ public UpdateBuilder updateBuilder();
+
+ /**
+ * Like {@link #queryBuilder()} but allows you to build an DELETE statement. You can then call call
+ * {@link DeleteBuilder#prepare()} and pass the returned {@link PreparedDelete} to {@link #delete(PreparedDelete)}.
+ */
+ public DeleteBuilder deleteBuilder();
+
+ /**
+ * Query for the items in the object table which match the prepared query. See {@link #queryBuilder} for more
+ * information.
+ *
+ *
+ * NOTE: For medium sized or large tables, this may load a lot of objects into memory so you should consider
+ * using the {@link #iterator(PreparedQuery)} method instead.
+ *
+ *
+ * @param preparedQuery
+ * Query used to match the objects in the database.
+ * @return A list of all of the objects in the table that match the query.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public List query(PreparedQuery preparedQuery) throws SQLException;
+
+ /**
+ * Create a new row in the database from an object. If the object being created uses
+ * {@link DatabaseField#generatedId()} then the data parameter will be modified and set with the corresponding id
+ * from the database.
+ *
+ * @param data
+ * The data item that we are creating in the database.
+ * @return The number of rows updated in the database. This should be 1.
+ */
+ public int create(T data) throws SQLException;
+
+ /**
+ * Just like {@link #create(Object)} but with a collection of objects. This will wrap the creates using the same
+ * mechanism as {@link #callBatchTasks(Callable)}.
+ *
+ * @param datas
+ * The collection of data items that we are creating in the database.
+ * @return The number of rows updated in the database.
+ */
+ public int create(Collection datas) throws SQLException;
+
+ /**
+ * This is a convenience method to creating a data item but only if the ID does not already exist in the table. This
+ * extracts the id from the data parameter, does a {@link #queryForId(Object)} on it, returning the data if it
+ * exists. If it does not exist {@link #create(Object)} will be called with the parameter.
+ *
+ * @return Either the data parameter if it was inserted (now with the ID field set via the create method) or the
+ * data element that existed already in the database.
+ */
+ public T createIfNotExists(T data) throws SQLException;
+
+ /**
+ * This is a convenience method for creating an item in the database if it does not exist. The id is extracted from
+ * the data parameter and a query-by-id is made on the database. If a row in the database with the same id exists
+ * then all of the columns in the database will be updated from the fields in the data parameter. If the id is null
+ * (or 0 or some other default value) or doesn't exist in the database then the object will be created in the
+ * database. This also means that your data item must have an id field defined.
+ *
+ * @return Status object with the number of rows changed and whether an insert or update was performed.
+ */
+ public CreateOrUpdateStatus createOrUpdate(T data) throws SQLException;
+
+ /**
+ * Store the fields from an object to the database row corresponding to the id from the data parameter. If you have
+ * made changes to an object, this is how you persist those changes to the database. You cannot use this method to
+ * update the id field -- see {@link #updateId} .
+ *
+ *
+ * NOTE: This will not save changes made to foreign objects or to foreign collections.
+ *
+ *
+ * @param data
+ * The data item that we are updating in the database.
+ * @return The number of rows updated in the database. This should be 1.
+ * @throws SQLException
+ * on any SQL problems.
+ * @throws IllegalArgumentException
+ * If there is only an ID field in the object. See the {@link #updateId} method.
+ */
+ public int update(T data) throws SQLException;
+
+ /**
+ * Update the data parameter in the database to change its id to the newId parameter. The data must have its
+ * current (old) id set. If the id field has already changed then it cannot be updated. After the id has been
+ * updated in the database, the id field of the data parameter will also be changed.
+ *
+ *
+ * NOTE: Depending on the database type and the id type, you may be unable to change the id of the field.
+ *
+ *
+ * @param data
+ * The data item that we are updating in the database with the current id.
+ * @param newId
+ * The new id that you want to update the data with.
+ * @return The number of rows updated in the database. This should be 1.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public int updateId(T data, ID newId) throws SQLException;
+
+ /**
+ * Update all rows in the table according to the prepared statement parameter. To use this, the
+ * {@link UpdateBuilder} must have set-columns applied to it using the
+ * {@link UpdateBuilder#updateColumnValue(String, Object)} or
+ * {@link UpdateBuilder#updateColumnExpression(String, String)} methods.
+ *
+ * @param preparedUpdate
+ * A prepared statement to match database rows to be deleted and define the columns to update.
+ * @return The number of rows updated in the database.
+ * @throws SQLException
+ * on any SQL problems.
+ * @throws IllegalArgumentException
+ * If there is only an ID field in the object. See the {@link #updateId} method.
+ */
+ public int update(PreparedUpdate preparedUpdate) throws SQLException;
+
+ /**
+ * Does a query for the data parameter's id and copies in each of the field values from the database to refresh the
+ * data parameter. Any local object changes to persisted fields will be overwritten. If the database has been
+ * updated this brings your local object up to date.
+ *
+ * @param data
+ * The data item that we are refreshing with fields from the database.
+ * @return The number of rows found in the database that correspond to the data id. This should be 1.
+ * @throws SQLException
+ * on any SQL problems or if the data item is not found in the table or if more than 1 item is found
+ * with data's id.
+ */
+ public int refresh(T data) throws SQLException;
+
+ /**
+ * Delete the database row corresponding to the id from the data parameter.
+ *
+ * @param data
+ * The data item that we are deleting from the database.
+ * @return The number of rows updated in the database. This should be 1.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public int delete(T data) throws SQLException;
+
+ /**
+ * Delete an object from the database that has an id.
+ *
+ * @param id
+ * The id of the item that we are deleting from the database.
+ * @return The number of rows updated in the database. This should be 1.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public int deleteById(ID id) throws SQLException;
+
+ /**
+ * Delete a collection of objects from the database using an IN SQL clause. The ids are extracted from the datas
+ * parameter and used to remove the corresponding rows in the database with those ids.
+ *
+ * @param datas
+ * A collection of data items to be deleted.
+ * @return The number of rows updated in the database. This should be the size() of the collection.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public int delete(Collection datas) throws SQLException;
+
+ /**
+ * Delete the objects that match the collection of ids from the database using an IN SQL clause.
+ *
+ * @param ids
+ * A collection of data ids to be deleted.
+ * @return The number of rows updated in the database. This should be the size() of the collection.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public int deleteIds(Collection ids) throws SQLException;
+
+ /**
+ * Delete the objects that match the prepared statement parameter.
+ *
+ * @param preparedDelete
+ * A prepared statement to match database rows to be deleted.
+ * @return The number of rows updated in the database.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public int delete(PreparedDelete preparedDelete) throws SQLException;
+
+ /**
+ * This satisfies the {@link Iterable} interface for the class and allows you to iterate through the objects in the
+ * table using SQL. You can use code similar to the following:
+ *
+ *
+ * for (Account account : accountDao) { ... }
+ *
+ *
+ *
+ * WARNING: because the {@link Iterator#hasNext()}, {@link Iterator#next()}, etc. methods can only throw
+ * {@link RuntimeException}, the code has to wrap any {@link SQLException} with {@link IllegalStateException}. Make
+ * sure to catch {@link IllegalStateException} and look for a {@link SQLException} cause.
+ *
+ *
+ *
+ * WARNING: The underlying results object will only be closed if you page all the way to the end of the
+ * iterator using the for() loop or if you call {@link CloseableIterator#close()} directly. You can also call the
+ * {@link #closeLastIterator()} if you are not iterating across this DAO in multiple threads.
+ *
+ *
+ *
+ * NOTE: With this iterator you can only move forward through the object collection. See the
+ * {@link #iterator(int)} method to create a cursor that can go both directions.
+ *
+ *
+ * @return An iterator of the class that uses SQL to step across the database table.
+ *
+ * @throws IllegalStateException
+ * When it encounters a SQLException or in other cases.
+ */
+ public CloseableIterator iterator();
+
+ /**
+ * Same as {@link #iterator()} but while specifying flags for the results. This is necessary with certain database
+ * types. The resultFlags could be something like ResultSet.TYPE_SCROLL_INSENSITIVE or other values.
+ *
+ *
+ * WARNING: Depending on the database type the underlying connection may never be freed -- even if you go all
+ * of the way through the results. It is strongly recommended that you call the
+ * {@link CloseableIterator#close()} method when you are done with the iterator.
+ *
+ */
+ public CloseableIterator iterator(int resultFlags);
+
+ /**
+ * Same as {@link #iterator()} but with a prepared query parameter. See {@link #queryBuilder} for more information.
+ * You use it like the following:
+ *
+ *
+ * QueryBuilder<Account, String> qb = accountDao.queryBuilder();
+ * ... custom query builder methods
+ * CloseableIterator<Account> iterator = partialDao.iterator(qb.prepare());
+ * try {
+ * while (iterator.hasNext()) {
+ * Account account = iterator.next();
+ * ...
+ * }
+ * } finish {
+ * iterator.close();
+ * }
+ *
+ *
+ * @param preparedQuery
+ * Query used to iterate across a sub-set of the items in the database.
+ * @return An iterator for T.
+ * @throws SQLException
+ * on any SQL problems.
+ */
+ public CloseableIterator iterator(PreparedQuery preparedQuery) throws SQLException;
+
+ /**
+ * Same as {@link #iterator(PreparedQuery)} but while specifying flags for the results. This is necessary with
+ * certain database types.
+ */
+ public CloseableIterator iterator(PreparedQuery preparedQuery, int resultFlags) throws SQLException;
+
+ /**
+ *