"{ Package: 'stx:libbasic' }"

Object subclass:#AbstractObjectCoder
	instanceVariableNames:'aspect'
	classVariableNames:''
	poolDictionaries:''
	category:'System-Storage'
!

!AbstractObjectCoder class methodsFor:'documentation'!

documentation
"
    This class is defines #encodeXXX:with: messages for various kinds of objects.
    Any of these messsages is mapped to #encodeObject:with:.

    When a class redefines #encodeOn:with:, an method has to be defined here, too.

    Subclasses have to define at least #encodeObject:with:

    [author:]
        Stefan Vogel (stefan@zwerg)

    [see also:]
        Object>>encodeOn:with:
"
! !

!AbstractObjectCoder methodsFor:'accessing'!

aspect
    "return the value of the instance variable 'aspect' (automatically generated)"

    ^ aspect
!

aspect:something
    "set the value of the instance variable 'aspect' (automatically generated)"

    aspect := something.
! !

!AbstractObjectCoder methodsFor:'encoding-smalltalk types'!

encodeAbsoluteTime:anAbsoluteTime with:aParameter
    "encode an absolute time value"

    self encodeObject:anAbsoluteTime with:aParameter


!

encodeBehavior:aSymbol with:aParameter
    "encode a class"

    self encodeObject:aSymbol with:aParameter
!

encodeBitArray:aBitArray with:aParameter
    "encode a BitArray"

    self encodeSequenceableCollection:aBitArray with:aParameter
!

encodeBlock:aBlock with:aParameter
    "encoding of blocks is rather difficult and an error by default.
     If your encoder supports this, redefine it there"

    self error:'encoding of blocks is not supported'
!

encodeBoolean:aBoolean with:aParameter
    "encode a Boolean"

    self encodeObject:aBoolean with:aParameter


!

encodeByteArray:aByteArray with:aParameter
    "encode an absolute time value"

    self encodeSequenceableCollection:aByteArray with:aParameter
!

encodeCharacter:aCharacter with:aParameter
    "encode a Character"

    self encodeObject:aCharacter with:aParameter


!

encodeCollection:aCollection with:aParameter
    "encode a Collection"

    self encodeObject:aCollection with:aParameter
!

encodeDictionary:aDictionary with:aParameter
    "encode a Dictionary"

    self encodeCollection:aDictionary with:aParameter
!

encodeFloat:aFloat with:aParameter
    "encode a Float"

    self encodeNumber:aFloat with:aParameter
!

encodeFraction:aFraction with:aParameter
    "encode a Fraction"

    self encodeNumber:aFraction with:aParameter
!

encodeInteger:anInteger with:aParameter
    "encode an Integer"

    self encodeNumber:anInteger with:aParameter
!

encodeInterval:anInterval with:aParameter
    "intervals are a special flavor of sequenceable collection (saving memory)
     We treat it as SequenceableCollection by default.
     Encoders that do a dense representation, redefine this to #encodeObject"

    ^ self encodeSequenceableCollection:anInterval with:aParameter
!

encodeNilWith:aParameter
    "encode a nil"

    self encodeObject:nil with:aParameter


!

encodeNumber:aNumber with:aParameter
    "encode an Integer"

    self encodeObject:aNumber with:aParameter
!

encodeSequencableCollection:aCollection with:aParameter
    "encode a SequenceableCollection.
     This is the wrong spelling but kept foe backward compatibility"

    self encodeCollection:aCollection with:aParameter
!

encodeSequenceableCollection:aCollection with:aParameter
    "encode a SequenceableCollection"

    "send the historic (wrong) selector, for backward compatibility with old subclasses"
    self encodeSequencableCollection:aCollection with:aParameter
!

encodeSet:aCollection with:aParameter
    "encode a Set"

    self encodeCollection:aCollection with:aParameter
!

encodeString:aString with:aParameter
    "encode a String"

    self encodeObject:aString with:aParameter


!

encodeSymbol:aSymbol with:aParameter
    "encode a Symbol"

    self encodeObject:aSymbol with:aParameter


! !

!AbstractObjectCoder methodsFor:'helpers'!

encodeAllInstanceVariablesOf:anObject
    "recursively enumerate anObjects refs, encoding each of the child objects.
     nil childs are not encoded"

    |instVarNames theClass 
     sz "{ Class: SmallInteger }"|

    theClass := anObject class.
    sz := theClass instSize.
    sz ~~ 0 ifTrue:[
        instVarNames := theClass allInstVarNames.
        1 to:sz do:[:i |  |ref|
            ref := anObject instVarAt:i.
            ref notNil ifTrue:[
                ref encodeOn:self with:(instVarNames at:i).
                self nextObject.
            ].
        ].
    ].

    theClass isVariable ifTrue:[
        sz := anObject basicSize.
        sz ~~ 0 ifTrue:[
            1 to:sz do:[:i |
                (anObject basicAt:i) encodeOn:self with:i.   
                self nextObject.
            ]
        ].
    ].
!

encodeChildrenOf:anObject
    "encode all child objects of anObject.
     If aspect is defined, perform aspect to fetch the child objects.
     Otherwise encode all the instance variables"

    |childObjectDescriptors|

    aspect isNil ifTrue:[
        "shortcut -- basic mechanism: encode instance variables by name"
        self encodeAllInstanceVariablesOf:anObject.
        ^ self.
    ].

    childObjectDescriptors := anObject encodingVectorFor:aspect.
    childObjectDescriptors do:[:association|
        association notNil ifTrue:[
            association value encodeOn:self with:association key.
            self nextObject.
        ].
    ].

    "
        XMLStandardCoder new aspect:#encodingVectorForInstanceVariables;
                 encodingOf:('blaKey' -> 'blaValue')

        XMLStandardCoder new aspect:#encodingVectorForInstanceVariables;
                 encodingOf:('blaKey' -> nil)

        XMLStandardCoder new aspect:#encodingVectorForNonNilInstanceVariables;
                 encodingOf:('blaKey' -> nil)

        XMLStandardCoder new aspect:#blaFaselQuall;
                 encodingOf:('blaKey' -> nil)
    "
! !

!AbstractObjectCoder methodsFor:'subclass responsibility'!

encodeObject:anObject with:aParameter
    "encode an object. Subclasses must implement this method"

    self subclassResponsibility


!

nextObject
    "this is sent, when a new Object is going to be encoded.
     Subclasses may redefine this e.g.to output a CR"

    ^ self 
! !

!AbstractObjectCoder class methodsFor:'documentation'!

version
    ^ '$Header: /cvs/stx/stx/libbasic/Attic/AbstractObjectCoder.st,v 1.8 2003-05-07 15:14:30 cg Exp $'
! !