anchor.diff:         #+abcl &allow-other-keys)
     (if enabled
         (make-instance 'validation-resource-operation-implementation-decoration
  -		     :schema schema
  -		     :format format
  -		     :decorates resource-operation-implementation)
  +                     :schema schema
  +                     :format format
  +                     :decorates resource-operation-implementation)
         resource-operation-implementation))
  -  
  +
   (defmethod rs::execute :around ((decoration validation-resource-operation-implementation-decoration)
  -			    &rest args)
  +                                &rest args)
     (let ((posted-content (first args))) ;; Asume the posted content is in the first argument
       (let ((valid-p (validate-with-schema (validation-schema decoration)
  -					 posted-content
  -					 :format (validation-format decoration))))
  +                                         posted-content
  +                                         :format (validation-format decoration))))
         (if (not valid-p)
  -	  (error "The posted content is invalid")
  -	  (call-next-method)))))
  +          (error "The posted content is invalid")
  +          (call-next-method)))))
   
   (cl-annot:defannotation validation (args resource-operation-implementation)
       (:arity 2)
  
positive.code: (defun attribute-writer (attribute)
    (or (attribute-option :writer attribute)
        (and (attribute-accessor attribute)
  	   (fdefinition
  	    `(setf
  	      ,(attribute-accessor attribute))))))
  
  (defun attribute-reader (attribute)
    (or
  
negative.code:   (parse-with-schema type data))
  
  (defun schema-type (schema)
    (if (listp schema)
  	  (first schema)
  	  schema))
  
  (defun parse-xml-with-schema (schema-or-name input)
    (let ((schema (if (symbolp schema-or-name)
                      (find-schema schema-or-name)
                      schema-or-name)))
  
      (ecase (schema-type schema)
        (:list
         (let ((items (third input)))
           (loop for item in items
              collect
                (parse-xml-with-schema
                 (second schema) ;; the list type
                 item))))
        (:element
         (assert (equalp (make-keyword (element-name schema))
                         (make-keyword (first input))) nil
                         "~A is not a ~A" input (element-name schema))
         (loop for attribute in (element-attributes schema)
            appending (let ((input-attribute
                             (find (symbol-name (attribute-name attribute))
                                   (cddr input)
                                   :key #'first
                                   :test #'equalp)))
                        (if input-attribute
                            ;; The attrbute is present
                            (list (cons (make-keyword (first input-attribute))
                                        (cond
                                          ((listp (attribute-type attribute))
                                           ;; It is a compound type (:list, :element, etc)
                                           (parse-xml-with-schema
                                            (second (attribute-type attribute)) ;; The compound element type
                                            (third input-attribute) ;; The attribute value
                                            ))
                                          ((keywordp (attribute-type attribute))
                                           ;; the attribute type is simple, parse the attribute value
                                           (unserialize-schema-attribute-value
                                            (attribute-type attribute)
                                            (third input-attribute)))
                                          ((symbolp (attribute-type attribute))
                                           ;; assume a schema reference
                                           (let ((attribute-schema (find-schema (attribute-type attribute))))
                                             (parse-xml-with-schema
                                              attribute-schema
                                              (third input-attribute) ;; The attribute value
                                              )))))))))))))
  
  (defun element-name (element)
    (second element))
  