ClassDescription.py :  » Database » Modeling-Framework » Modeling-0.9 » Modeling » interfaces » Python Open Source

Home
Python Open Source
1.3.1.2 Python
2.Ajax
3.Aspect Oriented
4.Blog
5.Build
6.Business Application
7.Chart Report
8.Content Management Systems
9.Cryptographic
10.Database
11.Development
12.Editor
13.Email
14.ERP
15.Game 2D 3D
16.GIS
17.GUI
18.IDE
19.Installer
20.IRC
21.Issue Tracker
22.Language Interface
23.Log
24.Math
25.Media Sound Audio
26.Mobile
27.Network
28.Parser
29.PDF
30.Project Management
31.RSS
32.Search
33.Security
34.Template Engines
35.Test
36.UML
37.USB Serial
38.Web Frameworks
39.Web Server
40.Web Services
41.Web Unit
42.Wiki
43.Windows
44.XML
Python Open Source » Database » Modeling Framework 
Modeling Framework » Modeling 0.9 » Modeling » interfaces » ClassDescription.py
# -*- 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"
    
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.