# -*- coding: iso-8859-1 -*-
#-----------------------------------------------------------------------------
# Modeling Framework: an Object-Relational Bridge for python
#
# Copyright (c) 2001-2004 Sbastien Bigaret <sbigaret@users.sourceforge.net>
# All rights reserved.
#
# This file is part of the Modeling Framework.
#
# This code is distributed under a "3-clause BSD"-style license;
# see the LICENSE file for details.
#-----------------------------------------------------------------------------
"""
ClassDescription API
Class description fills the gap between a model and informations needed at
run-time, such as ...
Automatically registered when a model is loaded/instanciated.
ClassDescriptionManagerInterface API
Until a EventManager (or equivalent) is available, we need a central booth
to deliver class descriptions when needed. A ClassDescriptionManager is such
a booth, fulfilling the following needs:
- 'class description providers', such as manager of models, register
themselves as providers.
- when an object needs at runtime its classDescription, it asks the
CVS information
$Id: ClassDescription.py 932 2004-07-20 06:21:57Z sbigaret $
"""
__version__='$Revision: 932 $'[11:-2]
try:
from Interface import Base
except:
class Base:
pass
class ClassDescriptionManagerInterface(Base):
"""
Responsible for class descriptions
"""
# Initialization of objects
def awakeObjectFromFetch(self, anObject):
"""
pass
"""
def awakeObjectFromInsertion(self, anObject):
"""
pass
"""
# Class description management
def classDescriptionForEntityName(self, entityName):
"Returns the ClassDescription corresponding to entityName"
def registerClassDescription(self, aClassDescription, entityName):
"Assigns the supplied classDescription to 'entityName'"
def invalidateClassDescriptionCache(self):
"Simply empties the set of held class description"
def registeredNames(self):
"Returns all known names"
# Providers of class descriptions management
def registerProvider(self, aProvider):
"Registers 'aProvider'"
def providers(self):
"Returns the set of registered providers"
def unregisterProvider(self, aProvider):
"""
Unregister the supplied provider, and calls
'self.invalidateClassDescriptionCache()'
Silently return if 'aProvider' is not registered.
"""
class ClassDescriptionInterface(Base):
"""
*Documentation forthcoming*
Implemented by:
- EntityClassDescription
- CMFClassDescription (still TBD)
"""
def adaptorName(self):
"""
Returns the name of the adaptor used to make persistent the corresponding
instances
"""
def attributesKeys(self):
""
#def awakeObjectFromInsertion(self, object, editingContext):
# "later"
#def awakeObjectFromFetch(self, object, editingContext):
# "later"
def classDescriptionForDestinationKey(self, destinationKey):
"""
Returns the class description registered for the destination entity of
relationship named 'aKey'
"""
def createInstanceWithEditingContext(self, editingContext):
"""
Implemented by subclasses to return a new object of the appropriate
class. For example, 'EntityClassDescription' subclass uses an Entity
to determine the class from which the instance should be instanciated.
"""
def delegate(self):
"""
Returns the object's delegate
See also: interfaces.ClassDescriptionDelegate
"""
def deleteRuleForRelationshipKey(self, aKey):
""
def displayNameForKey(self, aKey):
""
def entityName(self):
""
def foreignKeys(self):
"""
Returns the names of foreign keys for the object, i.e. the source
attributes' names of to-one relationships.
See also: toOneRelationshipKeys(), allToOneRelationshipKeys()
"""
def inverseForRelationshipKey(self, aKey):
""
def primaryKeys(self):
"Returns the names of primary keys for the object"
def propagateDeleteForObject(self, anObject, editingContext):
""
def propagateInsertionForObject(self, anObject, editingContext):
"""
Examines the object's relationships and searches for related objects not
inserted in 'editingContext', then inserts these objects into
editingContextif they are not already registered.
This is normally called when an EditingContext gets the
processRecentChanges() message.
See also: EditingContext.propagatesInsertionForRelatedObjects()
"""
def registeredBy(self, aClassDescriptionProvider):
"""
Sets the class_description_provider in which the receiver is registered.
Note that this is needed by implementation, not by design: since we still
do not have any EventManager, the only way method
classDescriptionForDestinationKey() can make it is to ask its provider,
so we need it. Hence is it very important that the provider notifies
the class description that it holds it.
"""
def setDelegate(self, aDelegate):
"""
Sets the object's delegate
See also: interfaces.ClassDescriptionDelegate
"""
def toManyRelationshipKeys(self):
"Returns the to-many relationships keys, as tuple"
def toOneRelationshipKeys(self):
"Returns the to-one relationships keys, as tuple"
def userPresentableDescriptionForObject(self, anObject):
"Returns a "
def validateObjectForDelete(self, anObject):
""
def validateObjectForSave(self, anObject):
""
def validateValueForKey(self, object, aValue, aKey):
"""
attribute/relationship validateValue
+ attribute: search and exec. validate<AttributeName> method
"""
def XMLDescriptionForObject(self, anObject):
"Returns an DOM representing the object"
|