import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
@Override
public <T> EntityConverter<T> create(Cupboard cupboard, Class<T> type) {
    if (type == Book.class) {
        EntityConverter<Book> delegate = new ReflectiveEntityConverter<Book>(cupboard, Book.class) {
            @Override
            protected boolean isIgnored(Field field) {
                return super.isIgnored(field) || ExtraInfo.class == field.getType();
            }

            @Override
            public Book fromCursor(Cursor cursor) {
                Book book = super.fromCursor(cursor);
                book.title = "TITLE: "+book.title;
                return book;
            }
        };
        return (EntityConverter<T>) delegate;
    }
    return null;
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
@Provides @Singleton
Cupboard provideCupboard() {
    Cupboard cupboard = new CupboardBuilder()
            .registerFieldConverter(Intent.class, new IntentFieldConverter())
            .registerFieldConverter(Uri.class, new UriFieldConverter())
            .build();

    cupboard.register(Artwork.class);
    return cupboard;
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
/**
 * Constructor suitable for {@link nl.qbusict.cupboard.convert.EntityConverterFactory}s that only need minor
 * changes to the default behavior of this converter, not requiring a sub class.
 *
 * @param cupboard          the cupboard instance
 * @param entityClass       the entity class
 * @param ignoredFieldNames a collection of field names that should be ignored as an alternative to implementing {@link #isIgnored(java.lang.reflect.Field)}
 * @param additionalColumns a collection of additional columns that will be requested from the cursor
 */
public ReflectiveEntityConverter(Cupboard cupboard, Class<T> entityClass, Collection<String> ignoredFieldNames, Collection<Column> additionalColumns) {
    mCupboard = cupboard;
    mUseAnnotations = cupboard.isUseAnnotations();
    Field[] fields = getAllFields(entityClass);
    ArrayList<Column> columns = new ArrayList<Column>(fields.length);
    this.mClass = entityClass;
    List<Property> properties = new ArrayList<Property>();
    for (Field field : fields) {
        if (ignoredFieldNames.contains(field.getName()) || isIgnored(field)) {
            continue;
        }
        Type type = field.getGenericType();
        FieldConverter<?> converter = getFieldConverter(field);
        if (converter == null) {
            throw new IllegalArgumentException("Do not know how to convert field " + field.getName() + " in entity " + entityClass.getName() + " of type " + type);
        }
        if (converter.getColumnType() == null) {
            continue;
        }
        Property prop = new Property();
        prop.field = field;
        if (!field.isAccessible()) {
            field.setAccessible(true);
        }
        prop.name = getColumn(field);
        prop.type = field.getType();
        prop.fieldConverter = (FieldConverter<Object>) converter;
        prop.columnType = converter.getColumnType();
        properties.add(prop);
        if (BaseColumns._ID.equals(prop.name)) {
            mIdProperty = prop;
        }
        columns.add(new Column(prop.name, prop.columnType, getIndexes(field)));
    }
    columns.addAll(additionalColumns);
    this.mColumns = Collections.unmodifiableList(columns);
    this.mProperties = properties.toArray(new Property[properties.size()]);
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
@Override
public FieldConverter<?> create(Cupboard cupboard, Type type) {
    // we don't handle any generic types here
    if (!(type instanceof Class)) {
        return null;
    }
    return sTypeConverters.get(type);
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
private void addDefaultEntityConverterFactories() {
    mEntityConverterFactories.add(new EntityConverterFactory() {
        @Override
        public <T> EntityConverter<T> create(Cupboard cupboard, Class<T> type) {
            return new ReflectiveEntityConverter<T>(cupboard, type);
        }
    });
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public void testAnnotatedEntity() {
    Cupboard cupboard = new Cupboard();
    cupboard.register(TestAnnotatedEntity.class);

    Cupboard annotatedCupboard = new CupboardBuilder().useAnnotations().build();
    annotatedCupboard.register(TestAnnotatedEntity.class);

    ReflectiveEntityConverter<TestAnnotatedEntity> converter = new ReflectiveEntityConverter<TestAnnotatedEntity>(cupboard, TestAnnotatedEntity.class);
    ReflectiveEntityConverter<TestAnnotatedEntity> annotatedConverter = new ReflectiveEntityConverter<TestAnnotatedEntity>(annotatedCupboard, TestAnnotatedEntity.class);

    MatrixCursor cursor = new MatrixCursor(new String[]{"_id", "myStringValue", "data1"});
    cursor.addRow(new Object[]{1L, "test", "test2"});
    cursor.moveToPosition(0);
    TestAnnotatedEntity entity = converter.fromCursor(TestHelper.newPreferredColumnOrderCursorWrapper(cursor, converter.getColumns()));
    assertEquals(1L, entity._id.longValue());
    assertEquals("test", entity.myStringValue);
    assertNull(entity.renamedStringValue);
    entity = annotatedConverter.fromCursor(TestHelper.newPreferredColumnOrderCursorWrapper(cursor, annotatedConverter.getColumns()));
    assertEquals(1L, entity._id.longValue());
    assertEquals("test", entity.myStringValue);
    assertEquals("test2", entity.renamedStringValue);

    ContentValues values = new ContentValues();
    annotatedConverter.toValues(entity, values);
    assertTrue(values.containsKey("data1"));
    assertEquals("test2", values.getAsString("data1"));
    assertTrue(values.containsKey("_id"));
    assertTrue(values.containsKey("myStringValue"));
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public void testIgnoreAnnotation() {
    Cupboard cupboard = new Cupboard();
    cupboard.register(TestAnnotatedEntity.class);

    Cupboard annotatedCupboard = new CupboardBuilder().useAnnotations().build();
    annotatedCupboard.register(TestAnnotatedEntity.class);

    ReflectiveEntityConverter<TestAnnotatedEntity> converter = new ReflectiveEntityConverter<TestAnnotatedEntity>(cupboard, TestAnnotatedEntity.class);
    ReflectiveEntityConverter<TestAnnotatedEntity> annotatedConverter = new ReflectiveEntityConverter<TestAnnotatedEntity>(annotatedCupboard, TestAnnotatedEntity.class);

    assertEquals(4, converter.getColumns().size());
    assertEquals(3, annotatedConverter.getColumns().size());
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public void testCaseInsensitiveColumnMapping() {
    Cupboard cupboard = new Cupboard();
    cupboard.register(TestEntity.class);
    ReflectiveEntityConverter<TestEntity> translator = new ReflectiveEntityConverter<TestEntity>(cupboard, TestEntity.class);
    TestEntity te = new TestEntity();
    te.booleanObjectProperty = true;
    te.booleanProperty = false;
    te.doubleObjectProperty = 100d;
    te.doubleProperty = 200.2d;
    te.floatObjectProperty = 101f;
    te.floatProperty = 202f;
    te.intObjectProperty = 10;
    te.intObjectProperty = 11;
    te.longObjectProperty = 12L;
    te.longProperty = 13L;
    te.shortObjectProperty = 1;
    te.shortProperty = 2;
    te.stringProperty = "test";

    ContentValues values = new ContentValues(50);
    translator.toValues(te, values);
    Set<Entry<String, Object>> vs = values.valueSet();
    String[] cols = new String[vs.size() - 1];
    int index = 0;
    List<Object> vals = new ArrayList<Object>(vs.size());
    for (Entry<String, Object> entry : vs) {
        if (!"bytearrayproperty".equalsIgnoreCase(entry.getKey())) {
            cols[index++] = entry.getKey().toUpperCase();
            vals.add(entry.getValue());
        }
    }
    MatrixCursor cursor = new MatrixCursor(cols);
    cursor.addRow(vals);
    cursor.moveToFirst();
    TestEntity converted = translator.fromCursor(newPreferredColumnOrderCursorWrapper(cursor, translator.getColumns()));
    assertEquals(te, converted);
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
@Override
public FieldConverter<?> create(Cupboard cupboard, Type type) {
  if (type.equals(this.type)) {
    return new GsonFieldConverter(gson, type);
  }
  return null;
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
	Cupboard cupboard = new CupboardBuilder().build();
	cupboard.register(TestEntity.class);
	InstrumentationRegistry.getTargetContext().deleteDatabase(TEST_DATABASE);
	db = new TestDbHelper(InstrumentationRegistry.getTargetContext(), cupboard, TEST_DATABASE).getWritableDatabase();
	rxDatabase = RxCupboard.with(cupboard, db);
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
	Cupboard cupboard = new CupboardBuilder().build();
	cupboard.register(TestEntity.class);
	cupboard.register(TestEntity2.class);
	InstrumentationRegistry.getTargetContext().deleteDatabase(TEST_DATABASE);
	db = new TestDbHelper(InstrumentationRegistry.getTargetContext(), cupboard, TEST_DATABASE).getWritableDatabase();
	rxDatabase = RxCupboard.with(cupboard, db);
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public static Cupboard getInstance() {
    if (cupboard == null) {
        cupboard = new CupboardBuilder().build();
    }
    return cupboard;
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public static Cupboard getAnnotatedInstance() {
    return new CupboardBuilder(getInstance())
            .useAnnotations()
            .build();
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public synchronized static Cupboard cupboard() {
	return cupboardAll;
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public ConverterRegistry(Cupboard cupboard) {
    this.mCupboard = cupboard;
    addDefaultEntityConverterFactories();
    addDefaultFieldConverterFactories();
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public void testPrivateFields() {
    Cupboard cupboard = new Cupboard();
    cupboard.register(PrivateEntity.class);
    ReflectiveEntityConverter<PrivateEntity> converter = new ReflectiveEntityConverter<PrivateEntity>(cupboard, PrivateEntity.class);
    assertEquals(3, converter.getColumns().size());
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public void testInheritedPrivateFields() {
    Cupboard cupboard = new Cupboard();
    cupboard.register(PrivateInheritedEntity.class);
    ReflectiveEntityConverter<PrivateInheritedEntity> converter = new ReflectiveEntityConverter<PrivateInheritedEntity>(cupboard, PrivateInheritedEntity.class);
    assertEquals(4, converter.getColumns().size());
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
RxDatabase(Cupboard cupboard, DatabaseCompartment dc, SQLiteDatabase db) {
	this.cupboard = cupboard;
	this.dc = dc;
	this.db = db;
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
public static RxDatabase with(Cupboard cupboard, SQLiteDatabase db) {
	return new RxDatabase(cupboard, cupboard.withDatabase(db), db);
}
 

import nl.qbusict.cupboard.Cupboard; //导入依赖的package包/类
RxCursor(Cupboard cupboard, Cursor cursor) {
	this.cursor = cupboard.withCursor(cursor);
}