anchor.diff:  
   ;; * Trasform-Class
   
  -(defclass transform-class (transformation-model-component standard-class)
  -  ((transform-type
  -    :initarg :transform-type
  -    :type qname)))
  -
  -#+NIL ;; FIXME: register TRANSFORM-TYPE in the appropriate namespace in MODEL
  -(defmethod shared-initialize :around ((instance transform-class) slots
  -				      &rest initargs
  -				      &key (transform-type nil tp)
  -				      &allow-other-keys)
  -  (cond
  -    (tp
  -     )
  -    (t (call-next-method))))
  -
  -
  +(defclass transform-class (bootstrap-model-component standard-class)
  +  ((model-metaclass
  +    :initarg :model-metaclass
  +    :types simple-string
  +    :accessor class-model-metaclass
  +    )
  +   (composite-name
  +    ;; ??? specific to UML, but needs to be handled during class
  +    ;; init. However, in order for it to be appropriately handleed,
  +    ;; the system must have NAMESPACE and NAMED-ELEMENT defined.
  +    ;;
  +    ;; so, FIXME: during CHANGE-CLASS or somesuch, be sure to resolve
  +    ;; COMPOSITE-NAME to its NAME and CONTAINING-PACKAGE(s) components
  +    :initarg :comopsite-name
  +    :type simple-string
  +    :accessor class-composite-name
  +    )))
  +
  +
  +(defmethod shared-initialize ((instance transform-class)
  +			      slots &rest initargs
  +			      &key &allow-other-keys)
  +  (macrolet ((uncadr (name)
  +	       (with-gensyms (it)
  +		 (let ((,it (getf initargs ,name)))
  +		   (when ,it
  +		     (setf (getf initargs ,name)
  +			   (cadr ,it)))))))
  +    ;; FIXME: resolve MODEL-METACLASS (as a QName) onto model
  +    ;; namespace registry (prefix/ns bindings) in MODEL
  +    (uncadr :model-metaclass)
  +    (uncadr :model)
  +    (uncadr :composite-name)
  +    ;; FIXME: resolve COMPOSITE-NAME ...
  +    (apply #'call-next-method instance slots initargs)
  +    ))
  +
  +
  +(defmethod direct-slot-definition-class ((class transform-class)
  +					 &rest initargs)
  +  (destructuring-bind (&key source-local-name &allow-other-keys)
  +      initargs
  +    (cond
  +      (source-local-name
  +       (find-class 'direct-property-transform-slot-definition))
  +      (t (call-next-method)))))
  +
  +(defmethod effective-slot-definition-class ((class transform-class)
  +					    &rest initargs)
  +  (destructuring-bind (&key name &allow-other-keys)
  +      initargs
  +    (let ((dslots (compute-direct-slot-definitions name class)))
  +      (delare (type cons dslots))
  +      (cond
  +	((some #'(lambda (sl)
  +		   (typep sl 'direct-property-transform-slot-definition))
  +	       dslots)
  +	 (find-class 'effective-property-transform-slot-definition))
  +	(t (call-next-method))))))
  +
  +
  +#+nil
   (defclass uml-transform-class (transform-class)
  +  ;; moreso representstive of a named element and a relation to its
  +  ;; containing package
     ((uml-source-package
       )
      (uml-element-name
  
positive.code: ;;; * Post Hoc
  
  
  ;; FIXME: Can't use UML-CLASS as a :METACLASS util it's finalized,
  ;; and it won't be finalized until after DEFCLASS CLASSIFIER
  
  (defclass element ()
    ((owned-comments
      :source-element-p t
      :source-local-name "ownedComment"
      :initarg :owned-comments
      :type property-table
      :accessor class-direct-owned-comments-table))
    (:metaclass uml-transform-class)
    (:model *uml-stub-model*)
    (:uml-name "UML::Element")
    (:transform-type  "uml:Class")
    (:is-abstract t))
  
  
  (defclass named-element (element)
    ((name
      :source-attribute-p t
      :source-local-name "name"
      :initarg :name
      :type simple-string
      :accessor named-element-name))
    (:metaclass uml-transform-class)
    (:model *uml-stub-model*)
    (:uml-name "UML::NamedElement")
    (:transform-type  "uml:Class")
    (:is-abstract t))
  
  
  (defclass namespace (named-element)
    ((owned-rules
      :source-element-p t
      :source-local-name "ownedRule"
      :initarg :owned-rules
      :type property-table
      :accessor class-direct-owned-rules-table
      ))
    (:metaclass uml-transform-class)
    (:model *uml-stub-model*)
    (:uml-name "UML::Namespace")
    (:transform-type  "uml:Class")
    (:is-abstract t))
  
  
  (defclass classifier (namespace type)
    ((generalizations
      :source-element-p t
      :source-local-name "generalization"
      :initarg :generalizations
      :type property-table
      :accessor class-direct-generalizations-table
      ))
    (:metaclass uml-transform-class)
    (:model *uml-stub-model*)
    (:transform-type "uml:Class")
    (:uml-name "UML::Classifier")
    (:is-abstract t))
  
negative.code:   ;;
    ;; This class option would effectively denote a packagedElement
    ;; definition for the defining class.
    (::composite-name "UML::Class")
  
    ;; "uml" in the following item denotes the namespace URI assigned
    ;; to the prefix "uml"
    (:model-metaclass  "uml:Class")  ;; cf. @xmi:type="uml:Class"
    )
  
  #+Nil ;; FIXME: do this CHANGE-CLASS for all elements in the *boostrap-model* after loading
  (let ((c (find-class 'uml-class)))
    (change-class c c))
  
  