FUNCTOR: specialized-array ( T -- ) [[

USING: accessors alien alien.c-types alien.data byte-arrays
classes kernel math math.vectors parser prettyprint.custom
sequences sequences.private specialized-arrays
specialized-arrays.private ;

TUPLE: ${T}-array
{ underlying c-ptr read-only }
{ length array-capacity read-only } ; final

: <direct-${T}-array> ( alien len -- specialized-array ) ${T}-array boa ; inline

M: ${T}-array direct-like drop <direct-${T}-array> ; inline

: <${T}-array> ( n -- specialized-array )
    [ \ ${T} <underlying> ] keep <direct-${T}-array> ; inline

: (${T}-array) ( n -- specialized-array )
    [ \ ${T} (underlying) ] keep <direct-${T}-array> ; inline

M: ${T}-array clone [ underlying>> clone ] [ length>> ] bi <direct-${T}-array> ; inline

M: ${T}-array length length>> ; inline

M: ${T}-array nth-unsafe underlying>> \ ${T} alien-element ; inline

M: ${T}-array nth-c-ptr underlying>> \ ${T} array-accessor drop swap <displaced-alien> ; inline

M: ${T}-array set-nth-unsafe underlying>> \ ${T} set-alien-element ; inline

M: ${T}-array like drop dup ${T}-array instance? [ \ ${T} >c-array ] unless ; inline

M: ${T}-array new-sequence drop (${T}-array) ; inline

M: ${T}-array equal? over ${T}-array instance? [ sequence= ] [ 2drop f ] if ;

M: ${T}-array resize
    [
        [ \ ${T} heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] [ drop ] 2bi
    <direct-${T}-array> ; inline

M: ${T}-array element-size drop \ ${T} heap-size ; inline

M: ${T}-array underlying-type drop \ ${T} ;
<<
SYNTAX: ${T}-array{ \ } [ \ ${T} >c-array ] parse-literal ;
>>
M: ${T}-array pprint-delims drop \ ${T}-array{ \ } ;

M: ${T}-array >pprint-sequence ;

INSTANCE: ${T}-array specialized-array

M: ${T}-array vs+ [ + \ ${T} c-type-clamp ] 2map ; inline
M: ${T}-array vs- [ - \ ${T} c-type-clamp ] 2map ; inline
M: ${T}-array vs* [ * \ ${T} c-type-clamp ] 2map ; inline

M: ${T}-array v*high [ * \ ${T} heap-size neg shift ] 2map ; inline
]]