Return to pa_array.C CVS log

Up to [parser3project] / parser3 / src / main

Annotation of parser3/src/main/pa_array.C, revision 1.4

1.1       paf         1: /*
1.4     ! paf         2:   $Id: pa_array.C,v 1.3 2001/01/27 15:45:24 paf Exp $
1.1       paf         3: */
                      4: 
                      5: #include <string.h>
                      6: 
                      7: #include "pa_pool.h"
                      8: 
                      9: void *Array::operator new(size_t size, Pool *apool) {
                     10:        return apool->malloc(size);
                     11: }
                     12: 
                     13: void Array::construct(Pool *apool, int initial_rows) {
                     14:        pool=apool;
                     15:        curr_chunk_rows=initial_rows;
                     16:        head=static_cast<Chunk *>(
                     17:                pool->malloc(sizeof(int)+sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *)));
1.3       paf        18:        head->count=curr_chunk_rows;
1.1       paf        19:        append_here=head->rows;
                     20:        link_row=&head->rows[curr_chunk_rows];
                     21:        link_row->link=0;
                     22:        fused_rows=0;
1.2       paf        23: 
1.3       paf        24:        cache_chunk_base=0;
                     25:        cache_chunk=head;
1.1       paf        26: }
                     27: 
                     28: void Array::expand() {
                     29:        curr_chunk_rows+=curr_chunk_rows*CR_GROW_PERCENT/100;
                     30:        Chunk *chunk=static_cast<Chunk *>(
                     31:                pool->malloc(sizeof(int)+sizeof(Chunk::Row)*curr_chunk_rows+sizeof(Chunk *)));
                     32:        chunk->count=curr_chunk_rows;
                     33:        link_row->link=chunk;
                     34:        append_here=chunk->rows;
                     35:        link_row=&chunk->rows[curr_chunk_rows];
                     36:        link_row->link=0;
                     37: }
                     38: 
                     39: 
                     40: Array& Array::operator += (Item src) {
                     41:        if(chunk_is_full())
                     42:                expand();
                     43: 
                     44:        append_here->item=src;
                     45:        append_here++; fused_rows++;
                     46: 
                     47:        return *this;
                     48: }
                     49: 
1.2       paf        50: Array::Item& Array::operator [] (int index) {
1.3       paf        51:        if(!(index>=0 && index<size())) {
                     52:                // FIX: some sort of thread-global error
                     53:                Item *result=0;
                     54:                return *result;
1.2       paf        55:        }
                     56: 
1.3       paf        57:        // if they ask index to the left of cached position, forget cache
                     58:        if(index<cache_chunk_base) {
                     59:                cache_chunk_base=0;
                     60:                cache_chunk=head;
                     61:        }
                     62: 
                     63:        // navigate to chunk with "index" row
                     64:        while(!(index>=cache_chunk_base && index<cache_chunk_base+cache_chunk->count)) {
                     65:                int count=cache_chunk->count;
                     66:                cache_chunk_base+=count;
                     67:                cache_chunk=cache_chunk->rows[count].link;
                     68:        }
                     69: 
                     70:        return cache_chunk->rows[index-cache_chunk_base].item;
1.4     ! paf        71: }
        !            72: 
        !            73: Array& Array::operator += (Array& src) {
        !            74:        int src_size=src.size();
        !            75:        int last_chunk_rows_left=link_row-append_here;
        !            76:        
        !            77:        // src fits into our lask chunk?
        !            78:        if(src_size<=last_chunk_rows_left) {
        !            79:                Chunk *src_chunk=src.head; 
        !            80:                Chunk::Row *dest_rows=append_here;
        !            81:                int rows_left_to_copy=src_size;
        !            82:                while(true) {
        !            83:                        int src_count=src_chunk->count;
        !            84:                        Chunk *next_chunk=src_chunk->rows[src_count].link;
        !            85:                        if(next_chunk) {
        !            86:                                // not last source chunk
        !            87:                                // taking it all
        !            88:                                memcpy(dest_rows, src_chunk->rows, sizeof(Chunk::Row)*src_count);
        !            89:                                dest_rows+=src_count;
        !            90:                                rows_left_to_copy-=src_count;
        !            91: 
        !            92:                                src_chunk=next_chunk;
        !            93:                        } else {
        !            94:                                // the last source chunk
        !            95:                                // taking only those rows of chunk that _left_to_copy
        !            96:                                memcpy(dest_rows, src_chunk->rows, sizeof(Chunk::Row)*rows_left_to_copy);
        !            97:                                break;
        !            98:                        }
        !            99:                }
        !           100:        } else {
        !           101:        }
        !           102: 
        !           103:        return *this;
        !           104: }
        !           105: 
        !           106: void Array::remove(int index, int count=1) {
        !           107: }