home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 4 / AACD04.ISO / AACD / Programming / lsEstuff / dynamic_array.e < prev    next >
Encoding:
Text File  |  1999-10-17  |  3.8 KB  |  175 lines
  1. OPT MODULE
  2.  
  3. ->
  4. -> fast dynamic array of CHAR/INT/LONG
  5. -> not as flexible/much functions as collextionX.
  6. -> but much faster when using it not-so-randomly :)
  7. -> and its ofcource alot smaller and simler..
  8. ->
  9.  
  10. MODULE 'LeifOO/xli'
  11.  
  12. EXPORT CONST DAVS_CHAR=1, DAVS_INT=2, DAVS_LONG=4
  13.  
  14. OBJECT xnode OF xni
  15.    values[4]:ARRAY OF CHAR
  16. ENDOBJECT
  17.  
  18.  
  19. EXPORT OBJECT dynamic_array
  20.    PRIVATE
  21.    xlist:PTR TO xli
  22.    valuesize:CHAR ->1/2/4, (CHAR/INT/LONG)
  23.    valuespernode:INT 
  24.    storagesize:INT
  25. ENDOBJECT
  26.  
  27. PROC dynamic_array(valuesize=1, alloc=64) OF dynamic_array
  28.    IF (valuesize < 1) OR (valuesize > 4) THEN RETURN NIL
  29.    IF alloc > 8000 THEN RETURN NIL
  30.    self.valuesize := valuesize
  31.    self.valuespernode := alloc * 4
  32.    self.storagesize := valuesize * self.valuespernode
  33.    NEW self.xlist
  34. ENDPROC self.valuesize
  35.  
  36. PROC end() OF dynamic_array
  37.    self.clear()
  38.    END self.xlist
  39. ENDPROC
  40.  
  41. PROC set(x, value) OF dynamic_array
  42.    DEF nodenum,
  43.        nodevaluenum,
  44.        xnode:PTR TO xnode
  45.  
  46.    nodenum := x / self.valuespernode
  47.    nodevaluenum := x - (nodenum * self.valuespernode)
  48.  
  49.    xnode := self.xlist.find(nodenum)
  50.  
  51.    IF xnode = NIL
  52.       xnode := AllocMem( (SIZEOF xnode) - 4 + self.storagesize, NIL)
  53.       xnode.id := nodenum
  54.       self.xlist.addTail(xnode)
  55.    ENDIF
  56.  
  57.    setxnodeval(self, xnode, nodevaluenum, value)
  58. ENDPROC
  59.  
  60. PROC unset(x) OF dynamic_array
  61.    DEF nodenum,
  62.        nodevaluenum,
  63.        xnode:PTR TO xnode
  64.  
  65.    nodenum := x / self.valuespernode
  66.    nodevaluenum := x - (nodenum * self.valuespernode)
  67.  
  68.    xnode := self.xlist.find(nodenum)
  69.  
  70.    IF xnode = NIL THEN RETURN NIL
  71.  
  72.    setxnodeval(self, xnode, nodevaluenum, NIL)
  73.  
  74.    IF xnodeisNIL(self, xnode)
  75.       self.xlist.remove(xnode)
  76.       FreeMem(xnode, (SIZEOF xnode) - 4 + self.storagesize)
  77.    ENDIF
  78. ENDPROC
  79.  
  80. PROC get(x) OF dynamic_array
  81.    DEF nodenum,
  82.    nodevaluenum,
  83.    xnode:PTR TO xnode
  84.  
  85.    nodenum := x / self.valuespernode
  86.    nodevaluenum := x - (nodenum * self.valuespernode)
  87.  
  88.    xnode := self.xlist.find(nodenum)
  89.  
  90.    IF xnode <> NIL
  91.       RETURN getxnodeval(self, xnode, nodevaluenum)
  92.    ENDIF
  93. ENDPROC NIL
  94.  
  95. PROC count() OF dynamic_array
  96.    DEF xnode:PTR TO xnode, c=NIL, a, stop
  97.    xnode:=self.xlist.first()
  98.    stop:=self.valuespernode
  99.    stop--
  100.       WHILE xnode
  101.          FOR a:=0 TO stop
  102.             IF getxnodeval(self, xnode, a) THEN c++
  103.          ENDFOR
  104.          xnode:=xnode.next
  105.       ENDWHILE
  106. ENDPROC c
  107.  
  108. PROC clear() OF dynamic_array
  109.    freememall(self.xlist, (SIZEOF xnode) - 4 + self.storagesize)
  110. ENDPROC
  111.  
  112. PROC freememall(xli:PTR TO xli, nodesize)
  113.    DEF xni:PTR TO xni
  114.    xni:=xli.first()
  115.    WHILE xni
  116.       xli.remove(xni)
  117.       FreeMem(xni, nodesize)
  118.       xni:=xni.next
  119.    ENDWHILE
  120. ENDPROC
  121.  
  122.  
  123. PROC xnodeisNIL(da:PTR TO dynamic_array, xnode:PTR TO xnode)
  124.    DEF a:REG, ptr:REG PTR TO LONG, stop:REG
  125.    stop := (da.storagesize) / 4
  126.    stop--
  127.    ptr := xnode.values
  128.    FOR a := 0 TO stop
  129.       IF ptr[a] <> NIL THEN RETURN FALSE
  130.    ENDFOR
  131. ENDPROC TRUE
  132.  
  133. PROC getxnodeval(da:PTR TO dynamic_array, xnode:PTR TO xnode, valuenum)
  134.    DEF ptr:PTR TO CHAR, valuesize, value,
  135.        iptr:PTR TO INT, lptr:PTR TO LONG
  136.    valuesize := da.valuesize
  137.    ptr := (xnode.values) + (valuenum * valuesize)
  138.    SELECT valuesize
  139.    CASE DAVS_CHAR
  140.       value := ptr[]
  141.    CASE DAVS_INT
  142.       iptr := ptr
  143.       value := iptr[]
  144.    CASE DAVS_LONG
  145.       lptr := ptr
  146.       value := lptr[]
  147.    ENDSELECT
  148. ENDPROC value
  149.  
  150. PROC setxnodeval(da:PTR TO dynamic_array, xnode:PTR TO xnode, valuenum, value)
  151.    DEF ptr:PTR TO CHAR, valuesize, iptr:PTR TO INT, lptr:PTR TO LONG
  152.    valuesize := da.valuesize
  153.    ptr := (xnode.values) + (valuenum * valuesize)
  154.    SELECT valuesize
  155.    CASE DAVS_CHAR
  156.       ptr[] := value
  157.    CASE DAVS_INT
  158.       iptr := ptr
  159.       iptr[] := value
  160.    CASE DAVS_LONG
  161.       lptr := ptr
  162.       lptr[] := value
  163.    ENDSELECT
  164. ENDPROC
  165.  
  166. OBJECT parse_point
  167.    value
  168.    x
  169.    PRIVATE
  170.    c_xnode:PTR TO xnode
  171.    c_valuenum:LONG
  172. ENDOBJECT
  173.  
  174.  
  175.