EOAdaptor
Inherits from: NSObject
Package: com.apple.yellow.eoaccess
Class Description
EOAdaptor is an abstract class that provides concrete subclasses with a structure for connecting to a database. A concrete subclass of EOAdaptor provides database-specific method implementations and represents a single database server. You never interact with instances of the EOAdaptor class, but you use its static methods, adaptorWithName and adaptorWithModel, to create instances of a concrete subclass. The EOAdaptor class defines the methods that find and load the concrete adaptors from bundles. However, you rarely interact with a concrete adaptor either. Generally, adaptors are automatically created and used by other classes in the Enterprise Objects Framework.
EOAdaptor isn't declared to be abstract, but conceptually it is abstract. Never create instances of the EOAdaptor class. |
Method | Description |
assertConnectionDictionaryIsValid | Verifies that the adaptor can connect with its connection information. |
runLoginPanel | Runs the login panel without affecting the connection dictionary. |
runLoginPanelAndValidateConnectionDictionary | Runs the login panel until the user enters valid connection information or cancels the panel. |
setConnectionDictionary | Sets the connection dictionary. |
For information on subclassing an EOAdaptor, see "Creating an EOAdaptor Subclass" .
Constants
EOAdaptor defines one constant, a String, as described below:
Constant | Description |
GeneralAdaptorException | The name of exceptions raised by adaptors when errors occur during interactions with their database servers. |
Method Types
- Creating an EOAdaptor
- adaptorWithName
- adaptorWithModel
- Accessing an adaptor's name
- name
- Accessing the names of all available adaptors
- availableAdaptorNames
- Connecting to a database server
- assertConnectionDictionaryIsValid
- connectionDictionary
- setConnectionDictionary
- runLoginPanelAndValidateConnectionDictionary
- runLoginPanel
- isDroppedConnectionException
- handleDroppedConnection
- Encoding database strings
- databaseEncoding
- Performing database-specific transformations on values
- fetchedValueForValue
- fetchedValueForDataValue
- fetchedValueForDateValue
- fetchedValueForNumberValue
- fetchedValueForStringValue
- Servicing models
- canServiceModel
- internalTypeForExternalType
- externalTypesWithModel:
- assignExternalInfoForEntireModel:
- assignExternalInfoForEntity
- assignExternalInfoForAttribute
- isValidQualifierType
- Creating adaptor contexts
- createAdaptorContext
- contexts
- Checking connection status
- hasOpenChannels
- Accessing a default expression class
- setExpressionClassName
- expressionClass
- defaultExpressionClass
- Accessing an adaptor's login panel
- sharedLoginPanelInstance
- runLoginPanelAndValidateConnectionDictionary
- runLoginPanel
- Accessing the delegate
- delegate
- setDelegate
- setDefaultDelegate
- defaultDelegate
- Creating and dropping databases
- createDatabaseWithAdministrativeConnectionDictionary
- dropDatabaseWithAdministrativeConnectionDictionary
- Providing prototype attributes
- prototypeAttributes
- Synchronizing the database with a model
- objectStoreChangesFromAttributeToAttribute
Constructors
EOAdaptor
public EOAdaptor(String name)
Never use this constructor directly. It is invoked automatically from adaptorWithName and adaptorWithModel-EOAdaptor static methods you use to create a new adaptor.
Static Methods
adaptorWithModel
public static Object adaptorWithModel(EOModel model)
A subclass of EOAdaptor doesn't need to implement this method. A subclass that does implement this method must incorporate the superclass's version.
See Also: adaptorName ( EOModel), setConnectionDictionary
adaptorWithName
public static Object adaptorWithName(String name)
EOAdaptor myAdaptor = (EOAdaptor)EOAdaptor.adaptorWithName("Acme");
This method searches the application's main bundle, ~/Library/Frameworks, Network/Library/Frameworks, and System/Library/Frameworks for the first framework whose base filename (that is, the filename without the ".framework" extension) corresponds to name. Throws an exception if name is null or if an adaptor class corresponding with name can't be found.
Usually you'd use adaptorWithModel to create a new adaptor, but you can use this method when you don't have a model. In fact, this method is typically used when you're creating an adaptor for the purpose of creating a model from an existing database.
assignExternalInfoForAttribute
public static void assignExternalInfoForAttribute(EOAttribute attribute)
Implemented by adaptor subclasses to assign database-specific characteristics to attribute. EOAdaptor's implementation invokes assignExternalTypeForAttribute to assign an external type, and then it assigns a column name based on the attribute name. For example, assignExternalInfoForAttribute assigns the column name "FIRST_NAME" to an attribute named "firstName". The method makes no changes to attribute's column name if attribute is derived.
A subclass of EOAdaptor doesn't need to implement this method. A subclass that does implement this method must incorporate the superclass's version.
See Also: assignExternalInfoForEntireModel:
assignExternalInfoForEntireModel:
public static void assignExternalInfoForEntireModel(EOModel model)
A subclass of EOAdaptor doesn't need to implement this method.
assignExternalInfoForEntity
public static void assignExternalInfoForEntity(EOEntity entity)
An adaptor subclass should implement this method to assign additional database-specific characteristics, if any. A subclass that does implement this method must incorporate the superclass's version.
See Also: assignExternalInfoForEntireModel:
assignExternalTypeForAttribute
public static void assignExternalTypeForAttribute(EOAttribute attribute)
An adaptor subclass should implement this method to assign an external type using attribute's internal type, precision, and length information. A subclass that does implement this method should incorporate the superclass's version.
See Also: assignExternalInfoForEntireModel:
availableAdaptorNames
public static NSArray availableAdaptorNames()
defaultDelegate
public static Object defaultDelegate()
externalTypesWithModel:
public static NSArray externalTypesWithModel(EOModel model)
An adaptor subclass should implement this method.
internalTypeForExternalType
public static String internalTypeForExternalType(
String extType,
EOModel model)
An adaptor subclass should implement this method without invoking EOAdaptor's implementation.
setDefaultDelegate
public static void setDefaultDelegate(Object anObject)
setExpressionClassName
public static void setExpressionClassName(
String sqlExpressionClassName,
String adaptorClassName)
Use this method to substitute a subclass of EOSQLExpression for the expression class provided by the adaptor.
A subclass of EOAdaptor doesn't need to implement this method. A subclass that does implement this method must incorporate the superclass's version.
See Also: defaultExpressionClass
sharedLoginPanelInstance
public static EOLoginPanel sharedLoginPanelInstance()
A subclass of EOAdaptor doesn't need to override this method. A subclass that does override this method must incorporate the superclass's version through a message to super.
Instance Methods
assertConnectionDictionaryIsValid
public void assertConnectionDictionaryIsValid()
An adaptor subclass must override this method without invoking EOAdaptor's implementation.
See Also: setConnectionDictionary
canServiceModel
public boolean canServiceModel(EOModel model)
A subclass of EOAdaptor doesn't need to override this method.
connectionDictionary
public NSDictionary connectionDictionary()
A subclass of EOAdaptor doesn't need to override this method.
contexts
public NSArray contexts()
See Also: createAdaptorContext
createAdaptorContext
public EOAdaptorContext createAdaptorContext()
An adaptor subclass must override this method without invoking EOAdaptor's implementation.
See Also: contexts
createDatabaseWithAdministrativeConnectionDictionary
public void createDatabaseWithAdministrativeConnectionDictionary(
NSDictionary connectionDictionary)
See Also: dropDatabaseWithAdministrativeConnectionDictionary
databaseEncoding
public int databaseEncoding()
An adaptor's database encoding is stored in the connection dictionary with the key "databaseEncoding". If the connection dictionary doesn't have an entry for the database encoding, the default C string encoding is used. This method throws an exception if the receiver's database encoding isn't valid.
A subclass of EOAdaptor doesn't need to override this method.
defaultExpressionClass
public Class defaultExpressionClass()
An adaptor subclass must override this method without invoking EOAdaptor's implementation.
See Also: setExpressionClassName
delegate
public Object delegate()
dropDatabaseWithAdministrativeConnectionDictionary
public void dropDatabaseWithAdministrativeConnectionDictionary(
NSDictionary connectionDictionary)
See Also: createDatabaseWithAdministrativeConnectionDictionary, EOLoginPanel class
expressionClass
public Class expressionClass()
A subclass of EOAdaptor doesn't need to override this method. A subclass that does override this method must incorporate the superclass's version through a message to super.
fetchedValueForDataValue
public NSData fetchedValueForDataValue(
NSData value,
EOAttribute attribute)
EOAdaptor's implementation returns value unchanged. An adaptor subclass should override this method if the adaptor's database performs transformations on binary types, such as BLOBs.
fetchedValueForDateValue
public NSGregorianDate fetchedValueForDateValue(
NSGregorianDate value,
EOAttribute attribute)
EOAdaptor's implementation returns value unchanged. An adaptor subclass should override this method to convert or format date values. For example, a concrete adaptor subclass could set value's millisecond value to 0.
fetchedValueForNumberValue
public Number fetchedValueForNumberValue(
Number value,
EOAttribute attribute)
EOAdaptor's implementation returns value unchanged. An adaptor subclass should override this method to convert or format numeric values. For example, a concrete adaptor subclass should probably round value according to the precision and scale attribute.
fetchedValueForStringValue
public String fetchedValueForStringValue(
String value,
EOAttribute attribute)
EOAdaptor's implementation trims trailing spaces and returns null for zero-length strings. An adaptor subclass should override this method to perform any additional conversion or formatting on string values.
fetchedValueForValue
public Object fetchedValueForValue(
Object value,
EOAttribute attribute)
An adaptor subclass can override this method or one of the data type-specific fetchedValue... methods. EOAdaptor's implementation of fetchedValueForValue invokes one of the data type-specific methods depending on value's class. If value is not a string, number, date, or data object (that is, an instance of String, Number, NSGregorianDate, NSData, or any of their subclasses), fetchedValueForValue returns value unchanged.
This method invokes the EOAdaptor.Delegate method adaptorFetchedValueForValue which can override the adaptor's default behavior.
See Also: fetchedValueForDataValue, fetchedValueForDateValue, fetchedValueForNumberValue, fetchedValueForStringValue, valueFactoryMethod (EOAttribute)
handleDroppedConnection
public void handleDroppedConnection()
You should never invoke this method; it is invoked automatically by the Framework. Subclasses don't normally need to override the superclass implementation.
hasOpenChannels
public boolean hasOpenChannels()
See Also: hasOpenChannels ( EOAdaptorContext)
isDroppedConnectionException
public boolean isDroppedConnectionException(Throwable aThrowable)
true
if
the exception is one that the adaptor can attempt to recover from
by reconnecting to the database, false
otherwise.Invoked
if an exception is raised during fetching or saving. If the adaptor
returns true
, then the
adaptor attempts to reconnect to the database and retries the operation.
If the reconnection attempt fails, the exception from the failure
is raised as usual. If the adaptor returns false
,
reconnection isn't attempted and the exception is raised.
The
default implementation of isDroppedConnectionException: returns false
.
Subclasses that support database reconnection should implement this
method to allow for automatic database reconnection.
See Also: handleDroppedConnection, reconnectionDictionaryForAdaptor ( EOAdaptor.Delegate)
isValidQualifierType
public boolean isValidQualifierType(
String typeName,
EOModel model)
An adaptor subclass must override this method without invoking EOAdaptor's implementation.
name
public String name()
A subclass of EOAdaptor doesn't need to override this method.
See Also: adaptorWithName
objectStoreChangesFromAttributeToAttribute
public NSDictionary objectStoreChangesFromAttributeToAttribute(
EOAttribute schemaAttribute,
EOAttribute modelAttribute)
prototypeAttributes
public NSArray prototypeAttributes()
runLoginPanel
public NSDictionary runLoginPanel()
A subclass of EOAdaptor doesn't need to override this method. A subclass that does override this method must incorporate the superclass's version through a message to super.
See Also: setConnectionDictionary, assertConnectionDictionaryIsValid, sharedLoginPanelInstance
runLoginPanelAndValidateConnectionDictionary
public boolean runLoginPanelAndValidateConnectionDictionary()
A subclass of EOAdaptor doesn't need to override this method. A subclass that does override this method must incorporate the superclass's version through a message to super.
See Also: runLoginPanel, setConnectionDictionary, assertConnectionDictionaryIsValid, sharedLoginPanelInstance
setConnectionDictionary
public void setConnectionDictionary(NSDictionary dictionary)
A subclass of EOAdaptor doesn't need to override this method. A subclass that does override this method must incorporate the superclass's version through a message to super.
See Also: connectionDictionary, hasOpenChannels, assertConnectionDictionaryIsValid, runLoginPanelAndValidateConnectionDictionary, runPanelForAdaptor (EOLoginPanel)
setDelegate
public void setDelegate(Object delegate)