"

 COPYRIGHT (c) 2002 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic2' }"

ByteArray variableByteSubclass:#UUID

	instanceVariableNames:''

	classVariableNames:'CachedMACAddress Lock SequenceNumber LastTime Increment

		NameSpaceToUuidBytes'

	poolDictionaries:''

	category:'Net-Communication-Support'

!

!UUID class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2002 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    128-bit Universal Unique Ids (UUIDs) as defined by OpenGroup/DCE

        http://www.opengroup.org/onlinepubs/9629399/apdxa.htm.

    See also RFC4122.

    A UUID is unique in time and space (at least until about Year 3400).

    Several fields if the UUID are interpreted as integers, so host/network byte

    order is relevant. UUIDs are stored in a ByteArray in network byte order (MSB-first),

    so they may be exported/imported between different machines.

    You can import UUIDs in host byte order using #fromNativeBytes:

    [author:]

    [instance variables:]

    [class variables:]

    [see also:]

"

! !

!UUID class methodsFor:'initialization'!

initialize

    "I want to get informed about image restarts"

    Lock isNil ifTrue:[

        Lock := RecursionLock new name:#UUID.

        LastTime := 0.

        Increment := 0.

        ObjectMemory addDependent:self.

        NameSpaceToUuidBytes := Dictionary withKeysAndValues:#(

                DNS  #[16r6B 16rA7 16rB8 16r10 16r9D 16rAD 16r11 16rD1 16r80 16rB4 16r0 16rC0 16r4F 16rD4 16r30 16rC8]            

                URL  #[16r6B 16rA7 16rB8 16r11 16r9D 16rAD 16r11 16rD1 16r80 16rB4 16r0 16rC0 16r4F 16rD4 16r30 16rC8]

                "ASN.1 OID in DER or as Text"

                OID  #[16r6B 16rA7 16rB8 16r12 16r9D 16rAD 16r11 16rD1 16r80 16rB4 16r0 16rC0 16r4F 16rD4 16r30 16rC8]

                "X.500 DN as DER or as Text"

                X500 #[16r6B 16rA7 16rB8 16r14 16r9D 16rAD 16r11 16rD1 16r80 16rB4 16r0 16rC0 16r4F 16rD4 16r30 16rC8]            

            ).

    ]

!

update:something with:aParameter from:changedObject

    "flush cached MAC address (may have been restarted on another host)"

    (something == #restarted) ifTrue:[

        CachedMACAddress := nil.

        SequenceNumber := nil.

    ]

! !

!UUID class methodsFor:'instance creation'!

basicNew

    ^ super basicNew:16

!

basicNew:size

    "allow creating with exact size. We need this for XMLStandardDecoder"

    size ~~ 16 ifTrue:[

        ^ self shouldNotImplement.

    ].

    ^ super basicNew:size.

!

decodeFromLiteralArray:anArray

    anArray size == 2 ifTrue:[

        "/ UUID 'uuid-string'

        ^ self readFrom:(anArray at:2).

    ].

    "/ UUID bytes...

    ^ super decodeFromLiteralArray:anArray "/ self readFrom:(anArray at:2)

    "

     (UUID decodeFromLiteralArray:#(UUID '5b023ce0-41f1-11dd-b99f-001558137da0'))

       literalArrayEncoding   

    "

!

fromBytes:aByteArray

    "set uuid from aByteArray.

     aByteArray must be 16 bytes in network byte order (MSB-first)"

    |uuid|

    uuid := super basicNew:16.

    uuid replaceFrom:1 to:16 with:aByteArray.

    ^ uuid.

    "    

     UUID fromBytes:#[16r01 16r02 16r03 16r04

                      16r05 16r06 16r07 16r08

                      16r09 16r10 16r11 16r12

                      16r13 16r14 16r15 16r16]. 

    "

!

fromBytes:aByteArray MSB:msb

    "Set the UUID from aByteArray. UUIDS are stored internally as MSB-first. 

     So, alway set

        msb = true      if reading from network or persistent storage"

    |uuid|

    uuid := self fromBytes:aByteArray.

    msb ifFalse:[

        self adjustByteOrder:uuid.

    ].

    ^ uuid

    "

     UUID fromBytes:#[16r01 16r02 16r03 16r04

                      16r05 16r06 16r07 16r08

                      16r09 16r10 16r11 16r12

                      16r13 16r14 16r15 16r16] msb:false. 

    "

    "

     UUID fromBytes:#[16r01 16r02 16r03 16r04

                      16r05 16r06 16r07 16r08

                      16r09 16r10 16r11 16r12

                      16r13 16r14 16r15 16r16] msb:true.    

    "

!

fromBytes:aByteArray msb:msb

    <resource: #obsolete>

    "Set the UUID from aByteArray. UUIDS are stored internally as MSB-first. 

     So, alway set

        msb = true      if reading from network or persistent storage"

    self obsoleteMethodWarning:'use fromBytes:MSB:'.

    ^ self fromBytes:aByteArray MSB:msb

    "

     UUID fromBytes:#[16r01 16r02 16r03 16r04

                      16r05 16r06 16r07 16r08

                      16r09 16r10 16r11 16r12

                      16r13 16r14 16r15 16r16] msb:false. 

    "

    "

     UUID fromBytes:#[16r01 16r02 16r03 16r04

                      16r05 16r06 16r07 16r08

                      16r09 16r10 16r11 16r12

                      16r13 16r14 16r15 16r16] msb:true.    

    "

!

fromNativeBytes:aByteArray

    "convert bytes to uuid.

     aByteArray represents a UUID in host byte order 

     - e.g. an UUID fetched from the Windows OS"

    |uuid|

    uuid := self fromBytes:aByteArray.

        self adjustByteOrder:uuid.

    ].

    ^ uuid.

    "    

     UUID fromNativeBytes:#[16r01 16r02 16r03 16r04

                              16r05 16r06 16r07 16r08

                              16r09 16r10 16r11 16r12

                              16r13 16r14 16r15 16r16]. 

    "

!

genRandomUUID

    "generate a new random UUID"

    ^ (super basicNew:16) genRandomUUID

    "

      self genRandomUUID

    "

!

genTimestampUUID

    "generate a new timestamp UUID"

    ^ (super basicNew:16) genTimestampUUID

    "

      self genTimestampUUID

    "

!

genUUID

    "generate a uuid.

     If a physical mac address can be retrieved from the OS,

     a mac-address/timestamp uuid is generated,

     otherwise a random uuid will be generated."

    ^ (super basicNew:16) genUUID

    "

     self genUUID

    "

!

genUUID:nameStringOrBytes inNameSpace:namespaceString

    "generate a namespace UUID (Version 5, hashed by SHA-1).

     See RFC4122."

    ^ (super basicNew:16) genUUID:nameStringOrBytes inNameSpace:namespaceString

    "

        self genUUID:'www.example.org' inNameSpace:'DNS'.

        self genUUID:'http://www.exept.de' inNameSpace:'URL'.

        self genUUID:'1.2.3.4.5' inNameSpace:'OID'.

        self genUUID:(OSI::DERCoder encode:(OSI::ASN1_OID newID:#(1 2 3 4 5))) 

             inNameSpace:'OID'.

        self genUUID:'c=de, o=eXept Software AG, cn=Development' 

             inNameSpace:'X500'.

        self genUUID:(OSI::DERCoder encode:(OSI::DistinguishedName fromString:'c=de, o=eXept Software AG, cn=Development') asAsn1Value) 

             inNameSpace:'X500'.

    "

!

new

    ^ (super basicNew:16) genUUID

    "

     self new 

    "

!

new:size

    "allow creating with exact size. We need this for XMLStandardDecoder"

    size ~~ 16 ifTrue:[

        ^ self shouldNotImplement.

    ].

    ^ super new:size.

!

readFrom:aStringOrStream onError:errorBlock

    |d offs s uuid t byte hasBrackets|

    Error handle:[:ex |

        ^ errorBlock value.

    ] do:[

        s := aStringOrStream readStream.

        uuid := super basicNew:16.

        hasBrackets := false.

        s skipSeparators.

        s peek == ${ ifTrue:[

            s next; skipSeparators.

            hasBrackets := true.

        ].

        t := s next:8.

        d := Integer readFrom:t radix:16 onError:[^ errorBlock value].

        uuid unsignedLongAt:1 put:d bigEndian:true.

        offs := 5.

        s next.         "skip $-"

        1 to:2 do:[:i |

            t := s next:4.

            d := Integer readFrom:t radix:16 onError:[^ errorBlock value].

            uuid unsignedShortAt:offs put:d bigEndian:true.

            offs := offs + 2.

            s next.     "skip $-"

        ].

        1 to:2 do:[:i |

            t := s next:2.

            d := Integer readFrom:t radix:16 onError:[^ errorBlock value].

            uuid at:offs put:d.

            offs := offs + 1.

        ].

        s next.         "skip $-"

        1 to:6 do:[:i |

            t := s next:2.

            byte := Integer readFrom:t radix:16 onError:[^ errorBlock value].

            uuid at:offs put:byte.

            offs := offs + 1.

        ].

        hasBrackets ifTrue:[

            s peek == $} 

                ifTrue:[s next] 

                ifFalse:errorBlock

        ].

    ].

    ^ uuid

    "

     UUID readFrom:'5ab2e9b4-3d48-11d2-9ea4-80c5140aaa77' 

     UUID readFrom:'{5ab2e9b4-3d48-11d2-9ea4-80c5140aaa77}' 

     UUID readFrom:'{5ab2e9b4-3d48-11d2-9ea4-80c5140aaa77' 

     UUID fromString:'5ab2e9b4-3d48-11d2-9ea4-80c5140aaa77 bllll' 

     UUID fromString:'5ab2e9b4-3d48-11d2-9ea4-80c5140aaa77' 

     UUID fromString:'00000001-0000-0000-C000-000000000046'

     UUID fromString:'00000001-0000-0000-C000-000000004600'

     UUID fromString:'00000001-0000-0000-C000-000000460000'

     UUID fromString:'00000001-0000-0000-C000-000046000000'

     UUID fromString:'00000001-0000-0000-C000-004600000000'

     UUID fromString:'00000001-0000-0000-C000-460000000000'

     UUID fromString:'00000001-0000-0000-C046-000000000000'

     UUID fromString:'00000001-0000-0046-C000-000000000000'

     UUID fromString:'00000001-0000-4600-C000-000000000000'

     UUID fromString:'00000001-0046-0000-C000-000000000000'

     UUID fromString:'00000001-4600-0000-C000-000000000000'

     UUID fromString:'00000100-4600-0000-C000-000000000000'

     UUID fromString:'00010000-4600-0000-C000-000000000000'

     UUID fromString:'10000000-4600-0000-C000-000000000000'

    "

    "Modified: / 10-10-2007 / 23:03:47 / cg"

! !

!UUID class methodsFor:'helpers'!

adjustByteOrder:aByteArray

    "change the byte order of the uuid"

    |d|

    d := aByteArray unsignedLongAt:1 bigEndian:false.

    aByteArray unsignedLongAt:1 put:d bigEndian:true.

    d := aByteArray unsignedShortAt:1+4 bigEndian:false.

    aByteArray unsignedShortAt:1+4 put:d bigEndian:true.

    d := aByteArray unsignedShortAt:1+4+2 bigEndian:false.

    aByteArray unsignedShortAt:1+4+2 put:d bigEndian:true.

!

getDtssUtcTime

    "return the DTSS based time in 100 nsec intervals

     DTSS UTC base time is October 15, 1582 (the start of the Gregorian Calendar)."

     "Unix base time is January 1, 1970.

      The difference between both is: 122192928000000000"

"   

        (Timestamp epoch asDate subtractDate:(Date day:15 month:10 year:1582))

        *  (24 * 60 * 60)

"

    ^ (Timestamp now getMilliseconds + 12219292800000) * 10000.

!

getValidMACAddress

    "return the first valid MAC address (i.e. having at least 6 bytes with the first six bytes ~~ 0)"

    CachedMACAddress isNil ifTrue:[

        CachedMACAddress := false.      "negative caching: remember the fact, that there is no MAC address" 

        [

            CachedMACAddress := OperatingSystem getNetworkMACAddresses 

                                    detect:[:macAddress | macAddress size >= 6 

                                                            and:[(macAddress startsWith:#[0 0 0 0 0 0]) not]]

                                    ifNone:false.

        ] on:PrimitiveFailure do:[:ex| "ignore"].

    ].

    ^ CachedMACAddress

    "

       CachedMACAddress := nil.

       self getValidMACAddress

    "

    "Modified: / 17-11-2004 / 01:45:53 / cg"

! !

!UUID methodsFor:'accessing'!

clockSeqHiAndReserved

    ^ self at:9

!

clockSeqLow

    ^ self at:10

!

node

    "answer the node (ethernet) address of this uuid"

    self isTimestampUUID ifFalse:[

        ConversionError raiseWith:self errorString:' - trying to get node address from random UUID'.

    ].            

    ^ (ByteArray new:6) replaceFrom:1 to:6 with:self startingAt:11.

    "

       (self allInstances 

            select:[:e| e isTimestampUUID] 

            thenCollect:[:e| e node]) asBag

    "

!

timeHighAndVersion

    ^ self unsignedShortAt:7 bigEndian:true

!

timeLow

    ^ self unsignedLongAt:1 bigEndian:true

!

timeMid

    ^ self unsignedShortAt:5 bigEndian:true

!

timestamp

    "Get the UTC timestamp, when the UUID has been created.

     This is only valid for timestampUUIDs"

    |low med high dtssUtcTime|

    self isTimestampUUID ifFalse:[

        ConversionError raiseWith:self errorString:' - trying to get timestamp from random UUID'.

    ].            

    low := self unsignedLongAt:1 bigEndian:true.

    med := self unsignedShortAt:5 bigEndian:true.

    high := (self unsignedShortAt:7 bigEndian:true) bitAnd:16rFFF.

    dtssUtcTime := low + ((med + (high bitShift:16)) bitShift:32).

    ^ Timestamp utcMillisecondsSince1970:(dtssUtcTime//10000) - 12219292800000.

    "

        self genTimestampUUID timestamp

        self genRandomUUID timestamp

        (self allInstances asSet asArray select:[:e| e isTimestampUUID] 

                                            thenCollect:[:e| e timestamp]) sort

    "

!

version

    "the version number of the uuid"

    ^ ((self at:7) bitAnd:16rF0) bitShift:-4.

    "