Ignore:
Timestamp:
Apr 14, 2012, 6:31:40 PM (7 years ago)
Author:
ksherdy
Message:

Added GIDFactory class member. Each symbol table maintains a set of GIDs.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/symbol_table/src/id_symbol_table.hpp

    r2024 r2027  
    11/*
    2  * id_symbol_table.hpp - Identity Symbol Table Pablo Template
     2 * id_symbol_table.hpp
    33 * Created on: 18-December-2011
    44 * Author: Ken Herdy
     
    9696                                 &buffer[blk_offset], 1,                                                  /* buffer, symbol length */
    9797                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(1), BLOCK_SIZE, /* h0, h1, hash lgth (bits), hash block size (bits) */
    98                                  symbols);
     98                                 symbols, this->gid_factory);
    9999            }
    100100
    101         if(bitblock::any(groups[blk].ends_2)) {
    102             do_block<SYMBOL, hash_table <identity_strategy_t<uint16_t,2>, hash_strategy_t<2>, ALLOCATOR> >
     101        if(bitblock::any(groups[blk].ends_2)) {
     102            do_block<SYMBOL, hash_table <identity_strategy_t<uint16_t,2>, hash_strategy_t<2>, ALLOCATOR> >
    103103                                (blk_offset,
    104104                                 hash_table_2,
     
    106106                                 &buffer[blk_offset], 2,
    107107                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(2), BLOCK_SIZE,
    108                                  symbols);
    109         }
    110 
    111         if(bitblock::any(groups[blk].ends_3)) {
    112             do_block<SYMBOL, hash_table <identity_strategy_t<uint16_t,3>, hash_strategy_t<3>, ALLOCATOR> >
     108                                 symbols, this->gid_factory);
     109        }
     110
     111        if(bitblock::any(groups[blk].ends_3)) {
     112            do_block<SYMBOL, hash_table <identity_strategy_t<uint16_t,3>, hash_strategy_t<3>, ALLOCATOR> >
    113113                                (blk_offset,
    114114                                 hash_table_3,
     
    116116                                 &buffer[blk_offset], 3,
    117117                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(3), BLOCK_SIZE,
    118                                  symbols);
    119         }
    120         if(bitblock::any(groups[blk].ends_4)) {
    121             do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,4>, hash_strategy_t<4>, ALLOCATOR> >
     118                                 symbols, this->gid_factory);
     119        }
     120        if(bitblock::any(groups[blk].ends_4)) {
     121            do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,4>, hash_strategy_t<4>, ALLOCATOR> >
    122122                                (blk_offset,
    123123                                 hash_table_4,
     
    125125                                 &buffer[blk_offset], 4,
    126126                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(4), BLOCK_SIZE,
    127                                  symbols);
    128         }
    129 
    130         if(bitblock::any(groups[blk].ends_5)) {
    131             do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,5>, hash_strategy_t<5>, ALLOCATOR> >
     127                                 symbols, this->gid_factory);
     128        }
     129
     130        if(bitblock::any(groups[blk].ends_5)) {
     131            do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,5>, hash_strategy_t<5>, ALLOCATOR> >
    132132                                (blk_offset,
    133133                                 hash_table_5,
     
    135135                                 &buffer[blk_offset], 5,
    136136                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(5), BLOCK_SIZE,
    137                                  symbols);
    138         }
    139         if(bitblock::any(groups[blk].ends_6)) {
    140             do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,6>, hash_strategy_t<6>, ALLOCATOR> >
     137                                 symbols, this->gid_factory);
     138        }
     139        if(bitblock::any(groups[blk].ends_6)) {
     140            do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,6>, hash_strategy_t<6>, ALLOCATOR> >
    141141                                (blk_offset,
    142142                                 hash_table_6,
     
    144144                                 &buffer[blk_offset], 6,
    145145                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(6), BLOCK_SIZE,
    146                                  symbols);
    147         }
    148         if(bitblock::any(groups[blk].ends_7)) {
    149             do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,7>, hash_strategy_t<7>, ALLOCATOR> >
     146                                 symbols, this->gid_factory);
     147        }
     148        if(bitblock::any(groups[blk].ends_7)) {
     149            do_block<SYMBOL, hash_table <identity_strategy_t<uint32_t,7>, hash_strategy_t<7>, ALLOCATOR> >
    150150                                (blk_offset,
    151151                                 hash_table_7,
     
    153153                                 &buffer[blk_offset], 7,
    154154                                 &buffer[blk_offset], &buffer[blk_offset], bytes2bits(7), BLOCK_SIZE,
    155                                  symbols);
    156         }
    157 
    158         ///////////////////////////////////////////////////////////////////////////////
    159         // Bit Space Hash
    160         ///////////////////////////////////////////////////////////////////////////////
    161         if(bitblock::any(groups[blk].ends_8)) {
    162             do_block<SYMBOL, hash_table <identity_strategy_t<uint64_t,8>, hash_strategy_d, ALLOCATOR> >
     155                                 symbols, this->gid_factory);
     156        }
     157
     158        ///////////////////////////////////////////////////////////////////////////////
     159        // Bit Space Hash
     160        ///////////////////////////////////////////////////////////////////////////////
     161        if(bitblock::any(groups[blk].ends_8)) {
     162            do_block<SYMBOL, hash_table <identity_strategy_t<uint64_t,8>, hash_strategy_d, ALLOCATOR> >
    163163                                (blk_offset,
    164164                                 hash_table_8,
    165165                                 groups[blk].ends_8, &buffer[blk_offset], 8,
    166166                                 (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 8, BLOCK_SIZE/8,
    167                                  symbols);
    168         }
     167                                 symbols, this->gid_factory);
     168        }
    169169                if(bitblock::any(groups[blk].ends_9)) {
    170170                        do_block<SYMBOL, hash_table<identity_strategy_t<uint64_t,9>, hash_strategy_d, ALLOCATOR> >
     
    173173                                groups[blk].ends_9, &buffer[blk_offset], 9,
    174174                                (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 9, BLOCK_SIZE/8,
    175                                 symbols);
     175                                symbols, this->gid_factory);
    176176                }
    177177
     
    182182                                groups[blk].ends_10, &buffer[blk_offset], 10,
    183183                                (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 10, BLOCK_SIZE/8,
    184                                 symbols);
     184                                symbols, this->gid_factory);
    185185                }
    186186                if(bitblock::any(groups[blk].ends_11)) {
     
    190190                                        groups[blk].ends_11, &buffer[blk_offset], 11,
    191191                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 11, BLOCK_SIZE/8,
    192                                         symbols);
     192                                        symbols, this->gid_factory);
    193193                }
    194194                if(bitblock::any(groups[blk].ends_12)) {
     
    198198                                        groups[blk].ends_12, &buffer[blk_offset], 12,
    199199                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 12, BLOCK_SIZE/8,
    200                                         symbols);
     200                                        symbols, this->gid_factory);
    201201                }
    202202                if(bitblock::any(groups[blk].ends_13)) {
     
    206206                                        groups[blk].ends_13, &buffer[blk_offset], 13,
    207207                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 13, BLOCK_SIZE/8,
    208                                         symbols);
     208                                        symbols, this->gid_factory);
    209209                }
    210210                if(bitblock::any(groups[blk].ends_14)) {
     
    214214                                        groups[blk].ends_14, &buffer[blk_offset], 14,
    215215                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 14, BLOCK_SIZE/8,
    216                                         symbols);
     216                                        symbols, this->gid_factory);
    217217                }
    218218                if(bitblock::any(groups[blk].ends_15)) {
     
    222222                                        groups[blk].ends_15, &buffer[blk_offset], 15,
    223223                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 15, BLOCK_SIZE/8,
    224                                         symbols);
     224                                        symbols, this->gid_factory);
    225225                }
    226226                if(bitblock::any(groups[blk].ends_16)) {
     
    230230                                        groups[blk].ends_16, &buffer[blk_offset], 16,
    231231                                        (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 16, BLOCK_SIZE/8,
    232                                         symbols);
     232                                        symbols, this->gid_factory);
    233233                }
    234234
     
    240240                                         &buffer[blk_offset],
    241241                                         (uint8_t *)&h0[blk], (uint8_t *)&h1[blk], 17, BLOCK_SIZE/8,
    242                                          symbols);
     242                                         symbols, this->gid_factory);
    243243                }
    244244
     
    281281              uint8_t buffer [], const uint32_t lgth,
    282282              uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
    283               SYMBOL & symbols) {
     283              SYMBOL & symbols, GIDFactory & gid_factory) {
    284284
    285285    gid_type gid;
     
    303303        uint8_t * lb_h1 = h1 - ((lgth / BLOCK_SIZE) + 1)*h_block_size;
    304304
    305         gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth);
     305        gid = h_table.lookup_or_insert(lb_buffer, lb_spos, lgth, lb_h0, lb_h1, h_lgth, gid_factory);
    306306
    307307        symbols.gids[blk_offset + spos] = gid;
     
    322322        while(!fscanner.is_done()) {
    323323
    324                 gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth);
     324                gid = h_table.lookup_or_insert(buffer, spos, lgth, h0, h1, h_lgth, gid_factory);
    325325                symbols.gids[blk_offset + spos] = gid;
    326326
     
    344344                          uint8_t buffer [],
    345345                          uint8_t h0 [], uint8_t h1 [], const uint32_t h_lgth, const uint32_t h_block_size,
    346                           SYMBOL & symbols) {
     346                          SYMBOL & symbols, GIDFactory & gid_factory) {
    347347
    348348        BitBlock * starts_base = starts;
     
    389389                }
    390390
    391                 gid = h_table.lookup_or_insert(buffer, spos, lgth, h0_base, h1_base, h_lgth);
     391                gid = h_table.lookup_or_insert(buffer, spos, lgth, h0_base, h1_base, h_lgth, gid_factory);
    392392                symbols.gids[blk_offset + spos] = gid;
    393393
Note: See TracChangeset for help on using the changeset viewer.