;;;; in Text, HTML, and XML formats. This includes hyperlinking
;;;; capability and sub-objects.
;;;;
-;;;; $Id: hyperobject.lisp,v 1.4 2002/11/04 19:19:04 kevin Exp $
+;;;; $Id: hyperobject.lisp,v 1.6 2002/11/22 15:43:22 kevin Exp $
;;;;
;;;; This file is Copyright (c) 2000-2002 by Kevin M. Rosenberg
;;;;
;;;; *************************************************************************
-(in-package :hyperobject)
+(in-package :hyperobject-mop)
(eval-when (:compile-toplevel :execute)
#+sbcl (sb-pcl:class-name obj)
#+cmu (pcl:class-name obj))
+(defun portable-class-slots (obj)
+ #+allegro (mop:class-slots obj)
+ #+lispworks (clos:class-slots obj)
+ #+sbcl (sb-pcl:class-slots obj)
+ #+(or cmu scl) (pcl:class-slots obj))
+
+(defun portable-slot-name (obj)
+ #+allegro (mop::slot-definition-name obj)
+ #+lispworks (clos::slot-definition-name obj)
+ #+sbcl (sb-pcl::slot-definition-name obj)
+ #+(or cmu scl) (pcl::slot-definition-name obj))
+
+
+;; Slot definitions
+
+
+
+(defclass hyperobject-dsd (#+allegro mop::standard-direct-slot-definition
+ #+lispworks clos:standard-direct-slot-definition
+ #+sbcl sb-pcl::standard-direct-slot-definition
+ #+(or scl cmucl) pcl::standard-direct-slot-definition
+ )
+ ((ho-type :initarg :ho-type :initform nil :accessor dsd-ho-type)
+ (format-func :initarg :format-func :initform nil :accessor dsd-format-func)
+ (subobject :initarg :subobject :initform nil :accessor dsd-subobject)
+ (reference :initarg :reference :initform nil :accessor dsd-reference)
+ ))
+
+(defclass hyperobject-esd (#+allegro mop::standard-effective-slot-definition
+ #+lispworks clos:standard-effective-slot-definition
+ #+sbcl sb-pcl::standard-effective-slot-definition
+ #+(or scl cmucl) pcl::standard-effective-slot-definition
+ )
+ ((ho-type :initarg :ho-type :initform nil :accessor esd-ho-type)
+ (format-func :initarg :format-func :initform nil :accessor esd-format-func)
+ (subobject :initarg :subobject :initform nil :accessor esd-subobject)
+ (reference :initarg :reference :initform nil :accessor esd-reference)
+ ))
+
;; Main class
(defclass hyperobject-class (#-(or cmu sbcl) standard-class
((title :initarg :title :type string :reader ml-std-title
:documentation
"Print Title for class")
- (fields :initarg :fields :reader ml-std-fields
- :documentation
-"List of field lists for printing. Format is
- ((fieldname type optional-formatter) ... )")
- (subobjects-lists
- :initarg :subobjects-lists :reader ml-std-subobjects-lists
+ (subobjects
+ :initarg :subobjects
:documentation
"List of fields that contain a list of subobjects objects.")
- (ref-fields
- :initarg :ref-fields :type list :reader ml-std-ref-field
+ (references
+ :initarg :references :type list :reader ml-std-references
:documentation
"List of fields that can be referred to by browsers.
Format is ((field-name field-lookup-func other-link-params) ...)")
(fmtstr-html-ref-labels :initform nil :type string :reader ml-std-fmtstr-html-ref-labels)
(fmtstr-xml-ref-labels :initform nil :type string :reader ml-std-fmtstr-xml-ref-labels)
)
- (:default-initargs :title nil :fields nil :subobjects-lists nil :ref-fields nil)
+ (:default-initargs :title nil :subobjects nil :references nil)
(:documentation "Metaclass for Markup Language classes."))
+(defclass subobject ()
+ ((name :type symbol :initform nil :initarg :name :reader name)
+ (reader :type function :initform nil :initarg :reader :reader reader)))
+
+(defmethod print-object ((obj subobject) (s stream))
+ (print-unreadable-object (obj s :type t :identity t)
+ (format s "~S" (name obj))))
+
+(defclass reference ()
+ ((name :type symbol :initform nil :initarg :name :reader name)
+ (lookup :type function :initform nil :initarg :lookup :reader lookup)
+ (link-parameters :type list :initform nil :initarg :link-parameters
+ :reader link-parameters)))
+
+(defmethod print-object ((obj reference) (s stream))
+ (print-unreadable-object (obj s :type t :identity t)
+ (format s "~S" (name obj))))
#+cmu
(defmethod pcl:finalize-inheritance :after ((cl hyperobject-class))
(defmethod clos:finalize-inheritance :after ((cl hyperobject-class))
(init-hyperobject-class cl))
+;; Slot definitions
+#+allegro
+(defmethod mop:direct-slot-definition-class ((cl hyperobject-class)
+ &rest iargs)
+ (find-class 'hyperobject-dsd))
+
+#+lispworks
+(defmethod clos:direct-slot-definition-class ((cl hyperobject-class) iargs)
+ (find-class 'hyperobject-dsd))
+
+#+sbcl
+(defmethod sb-pcl:direct-slot-definition-class ((cl hyperobject-class) iargs)
+ (find-class 'hyperobject-dsd))
+
+#+(or cmucl scl)
+(defmethod pcl:direct-slot-definition-class ((cl hyperobject-class) iargs)
+ (find-class 'hyperobject-dsd))
+
+
+
+
#+lispworks
(defmethod clos:process-a-class-option ((class hyperobject-class)
(name (eql :title))
(list name (car value))
(list name `',value)))
-#+lispworks
-(defmethod clos:process-a-class-option ((class hyperobject-class)
- (name (eql :fields))
- value)
- (unless value
- (error "hyperobject-class fields must have a value"))
- (list name `',value))
-
-#+lispworks
-(defmethod clos:process-a-class-option ((class hyperobject-class)
- (name (eql :ref-fields))
- value)
- (unless value
- (error "hyperobject-class ref-fields must have a value"))
- (list name `',value))
+(defmethod
+ #+allegro clos:compute-effective-slot-definition
+ #+lispworks clos:compute-effective-slot-definition
+ #+sbcl sb-pcl::compute-effective-slot-definition
+ #+(or cmucl scl) pcl::compute-effective-slot-definition
+ :around ((cl hyperobject-class) #+(or allegro lispworks) slot dsds)
+ (declare (ignorable slot))
+ (let* ((dsd (car dsds))
+ (ho-type (slot-value dsd 'type)))
+ (setf (slot-value dsd 'ho-type) ho-type)
+ (setf (slot-value dsd 'type) (convert-ho-type ho-type))
+ (let ((ia
+ #+allegro (excl::compute-effective-slot-definition-initargs cl dsds)
+ #+lispworks (clos::compute-effective-slot-definition-initargs cl slot dsds)
+ #+sbcl (sb-pcl::compute-effective-slot-definition-initargs cl dsds)
+ #+(or cmucl scl) (pcl::compute-effective-slot-definition-initargs cl dsds)
+ ))
+ (apply
+ #'make-instance 'hyperobject-esd
+ :ho-type ho-type
+ :format-func (slot-value dsd 'format-func)
+ :subobject (slot-value dsd 'subobject)
+ :reference (slot-value dsd 'reference)
+ ia)))
+ )
-#+lispworks
-(defmethod clos:process-a-class-option ((class hyperobject-class)
- (name (eql :subobjects-lists))
- value)
- (unless value
- (error "hyperobject-class subobjects-lists must have a value"))
- (list name `',value))
+(defun convert-ho-type (ho-type)
+ (check-type ho-type symbol)
+ (case (intern (symbol-name ho-type) (symbol-name :keyword))
+ (:string
+ 'string)
+ (:fixnum
+ 'fixnum)
+ (:boolean
+ 'boolean)
+ (:integer
+ 'integer)
+ (:cdata
+ 'string)
+ (:float
+ 'float)
+ (otherwise
+ ho-type)))
;;;; Class initialization function
(first-field t)
(value-func '())
(xmlvalue-func '())
- (classname (class-name cl))
+ (classname (portable-class-name cl))
(package (symbol-package (portable-class-name cl)))
- (ref-fields (slot-value cl 'ref-fields)))
+ (references nil)
+ (subobjects nil))
(declare (ignore classname))
- (dolist (f (slot-value cl 'fields))
- (let ((name (car f))
- (namestr (symbol-name (car f)))
- (namestr-lower (string-downcase (symbol-name (car f))))
- (type (cadr f))
- (formatter (caddr f))
- (value-fmt "~a")
- (plain-value-func nil)
- html-str xml-str html-label-str xml-label-str)
-
- (when (or (eql type :integer) (eql type :fixnum))
- (setq value-fmt "~d"))
-
- (when (eql type :commainteger)
- (setq value-fmt "~:d"))
-
- (when (eql type :boolean)
- (setq value-fmt "~a"))
-
- (if first-field
- (setq first-field nil)
- (progn
- (string-append fmtstr-text " ")
- (string-append fmtstr-html " ")
- (string-append fmtstr-xml " ")
- (string-append fmtstr-text-labels " ")
- (string-append fmtstr-html-labels " ")
- (string-append fmtstr-xml-labels " ")
- (string-append fmtstr-html-ref " ")
- (string-append fmtstr-xml-ref " ")
- (string-append fmtstr-html-ref-labels " ")
- (string-append fmtstr-xml-ref-labels " ")))
-
- (setq html-str (concatenate 'string "<span class=\"" namestr-lower "\">" value-fmt "</span>"))
- (setq xml-str (concatenate 'string "<" namestr-lower ">" value-fmt "</" namestr-lower ">"))
- (setq html-label-str (concatenate 'string "<span class=\"label\">" namestr-lower "</span> <span class=\"" namestr-lower "\">" value-fmt "</span>"))
- (setq xml-label-str (concatenate 'string "<label>" namestr-lower "</label> <" namestr-lower ">" value-fmt "</" namestr-lower ">"))
-
+ (dolist (f (portable-class-slots cl))
+ (if (slot-value f 'subobject)
+ (push (make-instance 'subobject :name (portable-slot-name f)
+ :reader (if (eq t (esd-subobject f))
+ (portable-slot-name f)
+ (esd-subobject f)))
+ subobjects)
+ (let ((name (portable-slot-name f))
+ (namestr (symbol-name (portable-slot-name f)))
+ (namestr-lower (string-downcase (symbol-name (portable-slot-name f))))
+ (type (slot-value f 'ho-type))
+ (formatter (slot-value f 'format-func))
+ (value-fmt "~a")
+ (plain-value-func nil)
+ html-str xml-str html-label-str xml-label-str)
+
+ (when (or (eql type :integer) (eql type :fixnum))
+ (setq value-fmt "~d"))
+
+ (when (eql type :commainteger)
+ (setq value-fmt "~:d"))
+
+ (when (eql type :boolean)
+ (setq value-fmt "~a"))
+
+ (if first-field
+ (setq first-field nil)
+ (progn
+ (string-append fmtstr-text " ")
+ (string-append fmtstr-html " ")
+ (string-append fmtstr-xml " ")
+ (string-append fmtstr-text-labels " ")
+ (string-append fmtstr-html-labels " ")
+ (string-append fmtstr-xml-labels " ")
+ (string-append fmtstr-html-ref " ")
+ (string-append fmtstr-xml-ref " ")
+ (string-append fmtstr-html-ref-labels " ")
+ (string-append fmtstr-xml-ref-labels " ")))
+
+ (setq html-str (concatenate 'string "<span class=\"" namestr-lower "\">" value-fmt "</span>"))
+ (setq xml-str (concatenate 'string "<" namestr-lower ">" value-fmt "</" namestr-lower ">"))
+ (setq html-label-str (concatenate 'string "<span class=\"label\">" namestr-lower "</span> <span class=\"" namestr-lower "\">" value-fmt "</span>"))
+ (setq xml-label-str (concatenate 'string "<label>" namestr-lower "</label> <" namestr-lower ">" value-fmt "</" namestr-lower ">"))
+
(string-append fmtstr-text value-fmt)
(string-append fmtstr-html html-str)
(string-append fmtstr-xml xml-str)
(string-append fmtstr-html-labels html-label-str)
(string-append fmtstr-xml-labels xml-label-str)
- (if (find name ref-fields :key #'car)
- (progn
- (string-append fmtstr-html-ref "<~~a>" value-fmt "</~~a>")
- (string-append fmtstr-xml-ref "<~~a>" value-fmt "</~~a>")
- (string-append fmtstr-html-ref-labels "<span class=\"label\">" namestr-lower "</span> <~~a>" value-fmt "</~~a>")
- (string-append fmtstr-xml-ref-labels "<label>" namestr-lower "</label> <~~a>" value-fmt "</~~a>"))
- (progn
- (string-append fmtstr-html-ref html-str)
- (string-append fmtstr-xml-ref xml-str)
- (string-append fmtstr-html-ref-labels html-label-str)
- (string-append fmtstr-xml-ref-labels xml-label-str)))
+ (if (esd-reference f)
+ (progn
+ (string-append fmtstr-html-ref "<~~a>" value-fmt "</~~a>")
+ (string-append fmtstr-xml-ref "<~~a>" value-fmt "</~~a>")
+ (string-append fmtstr-html-ref-labels "<span class=\"label\">" namestr-lower "</span> <~~a>" value-fmt "</~~a>")
+ (string-append fmtstr-xml-ref-labels "<label>" namestr-lower "</label> <~~a>" value-fmt "</~~a>")
+ (push (make-instance 'reference :name name :lookup (esd-reference f))
+ references))
+ (progn
+ (string-append fmtstr-html-ref html-str)
+ (string-append fmtstr-xml-ref xml-str)
+ (string-append fmtstr-html-ref-labels html-label-str)
+ (string-append fmtstr-xml-ref-labels xml-label-str)))
(if formatter
(setq plain-value-func
- (list `(,formatter (,(intern namestr package) x))))
- (setq plain-value-func
- (list `(,(intern namestr package) x))))
+ (list `(,formatter (,(intern namestr package) x))))
+ (setq plain-value-func
+ (list `(,(intern namestr package) x))))
(setq value-func (append value-func plain-value-func))
(if (eql type :cdata)
(setq xmlvalue-func (append xmlvalue-func (list `(xml-cdata ,@plain-value-func))))
- (setq xmlvalue-func (append xmlvalue-func plain-value-func)))
- ))
+ (setq xmlvalue-func (append xmlvalue-func plain-value-func)))
+ )))
+
+ (setf (slot-value cl 'references) references)
+ (setf (slot-value cl 'subobjects) subobjects)
(if value-func
(setq value-func `(lambda (x) (values ,@value-func)))
(car it)
it))))
-(defun hyperobject-class-subobjects-lists (obj)
- (slot-value (portable-class-of obj) 'subobjects-lists))
+(defun hyperobject-class-subobjects (obj)
+ (slot-value (portable-class-of obj) 'subobjects))
-(defun hyperobject-class-ref-fields (obj)
- (slot-value (portable-class-of obj) 'ref-fields))
+(defun hyperobject-class-references (obj)
+ (slot-value (portable-class-of obj) 'references))
(defun hyperobject-class-fields (obj)
- (slot-value (portable-class-of obj) 'fields))
+ (portable-class-slots (portable-class-of obj)))
(defun hyperobject-class-fmtstr-html-ref (obj)
(slot-value (portable-class-of obj) 'fmtstr-html-ref))
(funcall (funcall (obj-data-value-func fmt) x) x))))
;; make list of reference link fields for printing to refstr template
- (dolist (field (hyperobject-class-ref-fields x))
+ (dolist (ref (hyperobject-class-references x))
(let ((link-start
- (make-link-start x (link-ref fmt) (car field) (cadr field)
- (nth (position (car field) (hyperobject-class-fields x) :key #'car) field-values)
- (append (caddr field) refvars)))
- (link-end (make-link-end x (link-ref fmt) (car field))))
+ (make-link-start x (link-ref fmt) (name ref) (lookup ref)
+ (nth (position (name ref)
+ (hyperobject-class-fields x)
+ :key #'(lambda (x)
+ (portable-slot-name x)))
+ field-values)
+ (append (link-parameters ref) refvars)))
+ (link-end (make-link-end x (link-ref fmt) (name ref))))
(push link-start refvalues)
(push link-end refvalues)))
(setq refvalues (nreverse refvalues))
(when objs
(let ((objlist (mklist objs)))
(dolist (obj objlist)
- (awhen (hyperobject-class-subobjects-lists obj) ;; access list of functions
+ (awhen (hyperobject-class-subobjects obj) ;; access list of functions
(dolist (child-obj it) ;; for each child function
- (awhen (funcall (car child-obj) obj)
+ (awhen (funcall (reader child-obj) obj)
(load-all-subobjects it))))))
objs))
(fmt-obj-start obj fmt strm indent)
(fmt-obj-data obj fmt strm (1+ indent) label refvars)
(if subobjects
- (awhen (hyperobject-class-subobjects-lists obj) ;; access list of functions
+ (awhen (hyperobject-class-subobjects obj) ;; access list of functions
(dolist (child-obj it) ;; for each child function
- (awhen (funcall (car child-obj) obj) ;; access set of child objects
+ (awhen (funcall (reader child-obj) obj) ;; access set of child objects
(print-hyperobject-class it fmt strm label
(1+ indent) english-only-function
subobjects refvars)))))
(print-unreadable-object (obj s :type t :identity t)
(let ((fmt (make-instance 'hyperobject::textformat)))
(apply #'format
- s (funcall (hyperobject::obj-data-fmtstr fmt) obj)
+ s (funcall (hyperobject-mop::obj-data-fmtstr fmt) obj)
(multiple-value-list
- (funcall (funcall (hyperobject::obj-data-value-func fmt) obj) obj))))))
+ (funcall (funcall (hyperobject-mop::obj-data-value-func fmt) obj) obj))))))