Cupboard (library 2.2.0 API)

java.lang.Object
- nl.qbusict.cupboard.Cupboard

```
public class Cupboard
extends java.lang.Object
```
The entry point of Cupboard is this class. The typical way to get an instance of this class is to use CupboardFactory using a static import:
```
 import static nl.qbusict.cupboard.CupboardFactory.cupboard;

 public class Example {
  static {
   cupboard().register(MyEntity.class);
  }

  public void storeMyEntity(SQLiteDatabase db, MyEntity entity) {
   cupboard().withDataBase(db).put(entity);
  }
 }
 
```
Registering entities before use

Entities that are used with Cupboard should be registered using the register(Class) function. If an entity class isn't registered an IllegalArgumentException is thrown at runtime, for example when attempting to call DatabaseCompartment.createTables()

Compartments
Storing an entity directly in a database is different from storing an entity through a ContentResolver. That's why there are different entry points:
- withDatabase(SQLiteDatabase) for interacting with a database
- withContext(Context) for interacting with a ContentProvider
- withCursor(Cursor) for getting results from Cursor objects
- withEntity(Class) for converting entities to ContentValues
- withOperations(ArrayList) for working on a list of ContentProviderOperations
Using annotations for column mapping
When working with existing data, it might be convenient to use a different field name for a certain column. For supporting that use case, the Column annotation can be used on an entity field. By default, these annotations are not processed, processing needs to be enabled explicitly by creating a Cupboard instance using CupboardBuilder
```
 Cupboard cupboard = new CupboardBuilder().useAnnotations().build();
 cupboard.setUseAnnotations(true);
 
```
Above would configure a local instance of Cupboard to use the Column annotation for mapping fields to columns. If you would like to make this the global default, use CupboardBuilder as well.
```
static {
      new CupboardBuilder().useAnnotations().asGlobalInstance().build();
      cupboard().register(MyEntity.class);
}
```
See Also:

DatabaseCompartment, ProviderCompartment, CursorCompartment, EntityCompartment, ProviderOperationsCompartment

Constructor Summary

Constructors
Constructor and Description

Cupboard()

Constructors
Constructor and Description
`Cupboard()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T> EntityConverter<T>`	`getDelegateEntityConverter(EntityConverterFactory skipPast, java.lang.Class<T> entityClass)` Get an entity converter to be used as a delegate.
`FieldConverter<?>`	`getDelegateFieldConverter(FieldConverterFactory skipPast, java.lang.reflect.Type type)` Get a field converter to be used as a delegate.
`<T> EntityConverter<T>`	`getEntityConverter(java.lang.Class<T> entityClass)` Get an entity converter for an entity class.
`FieldConverter<?>`	`getFieldConverter(java.lang.reflect.Type type)` Get a field converter for the specified `Type`
`java.util.Collection<java.lang.Class<?>>`	`getRegisteredEntities()` Get the classes that are registered with this instance
`<T> java.lang.String`	`getTable(java.lang.Class<T> clz)` Get the database table for an entity
`boolean`	`isRegisteredEntity(java.lang.Class<?> entityClass)` Check if an entity class is registered.
`boolean`	`isUseAnnotations()` Return if annotations are enabled
`<T> void`	`register(java.lang.Class<T> clz)` Register an entity class.
`ProviderCompartment`	`withContext(android.content.Context context)` Operate on a `ContentResolver`
`CursorCompartment`	`withCursor(android.database.Cursor cursor)` Operate on a `Cursor`
`DatabaseCompartment`	`withDatabase(CupboardDatabase db)` Operate on a `CupboardDatabase`
`DatabaseCompartment`	`withDatabase(android.database.sqlite.SQLiteDatabase db)` Operate on a `SQLiteDatabase`
`<T> EntityCompartment<T>`	`withEntity(java.lang.Class<T> entityClass)` Operate on an entity
`ProviderOperationsCompartment`	`withOperations(java.util.ArrayList<android.content.ContentProviderOperation> operations)` Operate on a list of `ContentProviderOperation`s

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Cupboard
```
public Cupboard()
```
- Method Detail
  - register
```
public <T> void register(java.lang.Class<T> clz)
```
    Register an entity class. Every entity class has to be registered before use.
    
    Parameters:
    
    clz - the entity class to register.
  - withDatabase
```
public DatabaseCompartment withDatabase(android.database.sqlite.SQLiteDatabase db)
```
    Operate on a SQLiteDatabase
    
    Parameters:
    
    db - the database to wrap
    
    Returns:
    
    a DatabaseCompartment wrapping the database for chaining.
  - withDatabase
```
public DatabaseCompartment withDatabase(CupboardDatabase db)
```
    Operate on a CupboardDatabase
    
    Parameters:
    
    db - the database to wrap
    
    Returns:
    
    a DatabaseCompartment wrapping the database for chaining.
  - withCursor
```
public CursorCompartment withCursor(android.database.Cursor cursor)
```
    Operate on a Cursor
    
    Parameters:
    
    cursor - the cursor to wrap
    
    Returns:
    
    a CursorCompartment wrapping the cursor for chaining.
  - withContext
```
public ProviderCompartment withContext(android.content.Context context)
```
    Operate on a ContentResolver
    
    Parameters:
    
    context - the Context to retrieve the ContentResolver from
    
    Returns:
    
    a ProviderCompartment to interact with the ContentResolver
  - withOperations
```
public ProviderOperationsCompartment withOperations(java.util.ArrayList<android.content.ContentProviderOperation> operations)
```
    Operate on a list of ContentProviderOperations
    
    Parameters:
    
    operations - the (empty) list of operations to append to
    
    Returns:
    
    a ProviderOperationsCompartment for chaining
  - withEntity
```
public <T> EntityCompartment<T> withEntity(java.lang.Class<T> entityClass)
```
    Operate on an entity
    
    Parameters:
    
    entityClass - the entity class
    
    Returns:
    
    an EntityCompartment to interact with the entity.
  - getTable
```
public <T> java.lang.String getTable(java.lang.Class<T> clz)
```
    Get the database table for an entity
    
    Parameters:
    
    clz - the entity class
    
    Returns:
    
    the database table name
  - getRegisteredEntities
```
public java.util.Collection<java.lang.Class<?>> getRegisteredEntities()
```
    Get the classes that are registered with this instance
    
    Returns:
    
    an unmodifiable collection of registered classes
  - isUseAnnotations
```
public boolean isUseAnnotations()
```
    Return if annotations are enabled
    
    Returns:
    
    true if annotations are enabled, false otherwise
  - getFieldConverter
```
public FieldConverter<?> getFieldConverter(java.lang.reflect.Type type)
                                    throws java.lang.IllegalArgumentException
```
    Get a field converter for the specified Type
    
    Parameters:
    
    type - the type
    
    Returns:
    
    the field converter
    
    Throws:
    
    java.lang.IllegalArgumentException - if a field of this type cannot be converted by this instance
  - getEntityConverter
```
public <T> EntityConverter<T> getEntityConverter(java.lang.Class<T> entityClass)
                                          throws java.lang.IllegalArgumentException
```
    Get an entity converter for an entity class. When using the returned converter directly, you should take note that EntityConverter.fromCursor(Cursor) expects the cursor passed in to have the columns in the expected order. When not using this as part of delegation from an EntityConverter, the recommended way is to use withCursor(Cursor) and use CursorCompartment.get(Class) to convert from a cursor to an entity.
    
    Type Parameters:
    
    T - the entity type
    
    Parameters:
    
    entityClass - the entity class, must have been previous registered using register(Class)
    
    Returns:
    
    a converter for the given type
    
    Throws:
    
    java.lang.IllegalArgumentException - if an entity of this type cannot be converted by this instance
  - getDelegateFieldConverter
```
public FieldConverter<?> getDelegateFieldConverter(FieldConverterFactory skipPast,
                                                   java.lang.reflect.Type type)
                                            throws java.lang.IllegalArgumentException
```
    Get a field converter to be used as a delegate. The converter can be used in a FieldConverter to delegate to the default converter for example.
    
    Parameters:
    
    skipPast - the FieldConverterFactory to skip when searching for the delegate converter
    
    type - the type for the field
    
    Returns:
    
    the field converter
    
    Throws:
    
    java.lang.IllegalArgumentException - if a field of this type cannot be converted by this instance
  - getDelegateEntityConverter
```
public <T> EntityConverter<T> getDelegateEntityConverter(EntityConverterFactory skipPast,
                                                         java.lang.Class<T> entityClass)
                                                  throws java.lang.IllegalArgumentException
```
    Get an entity converter to be used as a delegate. The converter can be used in a EntityConverter to delegate to the default converter for example.
    
    Type Parameters:
    
    T - the entity type
    
    Parameters:
    
    skipPast - The EntityConverterFactory to skip when searching for the delegate converter
    
    entityClass - the entity class
    
    Returns:
    
    the converter
    
    Throws:
    
    java.lang.IllegalArgumentException - if an entity of this type cannot be converted by this instance
  - isRegisteredEntity
```
public boolean isRegisteredEntity(java.lang.Class<?> entityClass)
```
    Check if an entity class is registered. This is primarily for use in an entity converter
    
    Parameters:
    
    entityClass - the entity class
    
    Returns:
    
    true if the entityClass or one of it's super classes is registered with this instance, false otherwise

Class Cupboard

Registering entities before use

Compartments

Using annotations for column mapping

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Cupboard

Method Detail

register

withDatabase

withDatabase

withCursor

withContext

withOperations

withEntity

getTable

getRegisteredEntities

isUseAnnotations

getFieldConverter

getEntityConverter

getDelegateFieldConverter

getDelegateEntityConverter

isRegisteredEntity