To CHANGE-CLASS or not to CHANGE-CLASS

(This article isn't about clipping paths or graphics or Vecto, it's about CLOS, protocols, and change-class.)

Clipping paths in in Vecto have these semantics:

  • the initial clipping path covers the whole canvas, so it has no effect on drawing
  • the clipping path can never get bigger (updates always intersect with the current clipping path), but
  • the clipping path is saved and restored by WITH-GRAPHICS-STATE, so you can localize changes

Vecto implements clipping with a grayscale mask channel. But I wanted a couple optimizations:

  • no clipping path creation or drawing overhead for the initial, empty clipping path
  • no data copying overhead in WITH-GRAPHICS-STATE unless the clipping path is actually modified (i.e. copy-on-write)

The protocol to support this has the generic functions EMPTYP, COPY, CLIPPING-DATA, and WRITABLE-CLIPPING-DATA. A more efficient drawing function is used if the canvas's clipping path object is EMPTYP, otherwise a slower function that references CLIPPING-DATA is used. WITH-GRAPHICS-STATE copies the clipping path with COPY. Clipping path updates are written to the channel returned by WRITABLE-CLIPPING-DATA.

I initially implemented this with three classes: CLIPPING-PATH, EMPTY-CLIPPING-PATH, and PROXY-CLIPPING-PATH. Here's how each class handles each generic function:

EMPTY-CLIPPING-PATH CLIPPING-PATH PROXY-CLIPPING-PATH
EMPTYP returns true returns false
COPY returns new EMPTY-CLIPPING-PATH returns new PROXY-CLIPPING-PATH,
data slot is EQ to original
CLIPPING-DATA no method returns data slot value
WRITABLE-CLIPPING-DATA change-class to CLIPPING-PATH,
initializes and returns data
returns data slot change-class to CLIPPING-PATH,
set data slot to copy-seq of data slot

Then I read Joe Marshall's take on CHANGE-CLASS, which he calls — with some caveats — horrendous. I don't want to use horrendous things! So I implemented a different approach using only one CLIPPING-PATH class:

  • add a COPY-ON-WRITE-P slot, initially false
  • a CLIPPING-PATH is EMPTYP if its data slot is unbound
  • COPY creates a new CLIPPING-PATH instance
    • if the original is EMPTYP, the new instance is also empty
    • otherwise it has the same (EQ) data as the original and a copy-on-write flag of t.
  • CLIPPING-DATA returns the data slot
  • WRITABLE-CLIPPING-DATA checks if the clipping path is empty:
    • if so, initializes and returns the data slot
    • otherwise, checks the copy-on-write flag:
      • if set, COPY-SEQs the data slot to itself, returns the new data
      • otherwise it returns the data directly

The second approach seems ok to me (and I don't need a table to explain it), but the first approach doesn't seem that horrendous either. I didn't choose either technique for any special reasons; they're just the first things that occurred to me.

What do you think? Are they about the same, or does one seem better to you? Is there some other approach that would be even nicer? Let me know.

Tags:

Comments

(Anonymous)

It isn't <em>*that*</em> horrendous.

The situation you describe in this post is one where change-class can be put to good use. You've got an abstract class (a clipping-path) and three concrete representation classes. You are using change-class to transparently switch representations as needed.

Horrendous is more along the lines of this:

(let ((my-fish (get-fish *aquarium*)))
  (change-class my-fish 'bicycle)
  (shift-gears my-fish 3))

You can really screw up the semantics of object identity if you use change-class in an undisciplined way, but you can also use it to preserve object identity in the face of representation changes, schema upgrades, and incremental debugging.

(Anonymous)

Oops.

I accidentally hit submit. Pretend the html directives aren't in the subject and that I signed the message.

~Joe Marshall

August 2014

S M T W T F S
     12
3456789
10111213141516
17181920212223
24252627282930
31      
Powered by LiveJournal.com