Changeset 86

Show
Ignore:
Timestamp:
05/23/08 11:28:17
Author:
mhadji
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • spatialindex/trunk/regressiontest/rtree/RTreeLoad.cc

    r5 r86  
    7979                string baseName = argv[2]; 
    8080                IStorageManager* diskfile = StorageManager::createNewDiskStorageManager(baseName, 4096); 
     81 
    8182                StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*diskfile, 10, false); 
    8283                        // applies a main memory random buffer on top of the persistent storage manager 
    …… 
    8889                ISpatialIndex* tree = RTree::createNewRTree(*file, 0.7, atoi(argv[3]), atoi(argv[3]), 2, SpatialIndex::RTree::RV_RSTAR, indexIdentifier); 
    8990 
     91                std::cout << "a" << std::endl; 
    9092                size_t count = 0; 
    9193                id_type id; 

  • spatialindex/trunk/src/storagemanager/DiskStorageManager.cc

    r67 r86  
    2020//    mhadji@gmail.com 
    2121 
    22 #ifndef _MSC_VER 
    23 #include <unistd.h> 
    24 #endif 
    25  
    26 #include <fcntl.h> 
    27 #include <sys/types.h> 
    28 #include <sys/stat.h> 
    29 #include <stdio.h> 
     22#include <fstream> 
    3023 
    3124#include "../spatialindex/SpatialIndexImpl.h" 
    …… 
    8982        if (var.m_varType != Tools::VT_EMPTY) 
    9083        { 
    91                 if (var.m_varType != Tools::VT_BOOL) throw Tools::IllegalArgumentException("Property Overwrite must be Tools::VT_BOOL"); 
     84                if (var.m_varType != Tools::VT_BOOL) 
     85                        throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: Property Overwrite must be Tools::VT_BOOL"); 
    9286                bOverwrite = var.m_val.blVal; 
    9387        } 
    …… 
    9892        if (var.m_varType != Tools::VT_EMPTY) 
    9993        { 
    100                 if (var.m_varType != Tools::VT_PCHAR) throw Tools::IllegalArgumentException("Property FileName must be Tools::VT_PCHAR"); 
     94                if (var.m_varType != Tools::VT_PCHAR) 
     95                        throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: Property FileName must be Tools::VT_PCHAR"); 
    10196 
    10297                size_t cLen = strlen(var.m_val.pcVal); 
    10398 
    104                 char* pIndexFile = new char[cLen + 10]; 
    105                 char* pDataFile = new char[cLen + 10]; 
    106  
    107                 sprintf(pIndexFile, "%s.idx", var.m_val.pcVal); 
    108                 sprintf(pDataFile, "%s.dat", var.m_val.pcVal); 
     99                std::string sIndexFile = std::string(var.m_val.pcVal) + ".idx"; 
     100                std::string sDataFile = std::string(var.m_val.pcVal) + ".dat"; 
    109101 
    110102                // check if file exists. 
    111103                bool bFileExists = true; 
    112                 int e1 = access(pIndexFile, F_OK); 
    113                 int e2 = access(pDataFile, F_OK); 
    114                 if (e1 != 0 || e2 != 0) bFileExists = false; 
    115  
    116                 if (! bFileExists) bOverwrite = true; 
     104                std::ifstream fin1(sIndexFile.c_str(), std::ios::in | std::ios::binary); 
     105                std::ifstream fin2(sDataFile.c_str(), std::ios::in | std::ios::binary); 
     106                if (fin1.fail() || fin2.fail()) bFileExists = false; 
     107                fin1.close(); fin2.close(); 
    117108 
    118109                // check if file can be read/written. 
    119                 if (bOverwrite == false) 
    120                 { 
    121                         int e1 = access(pIndexFile, R_OK | W_OK); 
    122                         int e2 = access(pDataFile, R_OK | W_OK); 
    123  
    124                         if ((e1 != 0 || e2 != 0) && bFileExists) 
    125                         { 
    126                                 delete[] pIndexFile; 
    127                                 delete[] pDataFile; 
    128                                 throw Tools::IllegalArgumentException("Index file cannot be read/writen."); 
    129                         } 
    130                 } 
    131  
    132                 int cMode = (bOverwrite) ? O_CREAT | O_RDWR | O_TRUNC : O_RDWR; 
    133  
    134                 m_indexFile = open(pIndexFile, cMode, 0644); 
    135                 if (m_indexFile < 0) 
    136                 { 
    137                         delete[] pIndexFile; 
    138                         delete[] pDataFile; 
    139                         throw Tools::IllegalArgumentException("Index file cannot be opened."); 
    140                 } 
    141  
    142                 m_dataFile = open(pDataFile, cMode, 0644); 
    143                 if (m_dataFile < 0) 
    144                 { 
    145                         delete[] pIndexFile; 
    146                         delete[] pDataFile; 
    147                         throw Tools::IllegalArgumentException("Data file cannot be opened."); 
    148                 } 
    149  
    150                 delete[] pIndexFile; 
    151                 delete[] pDataFile; 
     110                if (bFileExists == true && bOverwrite == false) 
     111                { 
     112                        m_indexFile.open(sIndexFile.c_str(), std::ios::in | std::ios::out | std::ios::binary); 
     113                        m_dataFile.open(sDataFile.c_str(), std::ios::in | std::ios::out | std::ios::binary); 
     114 
     115                        if (m_indexFile.fail() || m_dataFile.fail()) 
     116                                throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: Index/Data file cannot be read/writen."); 
     117                } 
     118                else 
     119                { 
     120                        m_indexFile.open(sIndexFile.c_str(), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc); 
     121                        m_dataFile.open(sDataFile.c_str(), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc); 
     122 
     123                        if (m_indexFile.fail() || m_dataFile.fail()) 
     124                                throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: Index/Data file cannot be created."); 
     125 
     126                } 
    152127        } 
    153128        else 
    154129        { 
    155                 throw Tools::IllegalArgumentException("Property FileName was not specified."); 
     130                throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: Property FileName was not specified."); 
    156131        } 
    157132 
    …… 
    163138                if (var.m_varType != Tools::VT_EMPTY) 
    164139                { 
    165                         if (var.m_varType != Tools::VT_ULONG) throw Tools::IllegalArgumentException("Property PageSize must be Tools::VT_ULONG"); 
     140                        if (var.m_varType != Tools::VT_ULONG) 
     141                                throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: Property PageSize must be Tools::VT_ULONG"); 
    166142                        m_pageSize = var.m_val.ulVal; 
    167143                        m_nextPage = 0; 
    …… 
    169145                else 
    170146                { 
    171                         throw Tools::IllegalArgumentException("A new storage manager is created and property PageSize was not specified."); 
     147                        throw Tools::IllegalArgumentException("SpatialIndex::DiskStorageManager: A new storage manager is created and property PageSize was not specified."); 
    172148                } 
    173149        } 
    174150        else 
    175151        { 
    176                 ssize_t bytesread = read(m_indexFile, &m_pageSize, sizeof(size_t)); 
    177                 if (bytesread != sizeof(size_t)) throw Tools::IllegalStateException("Failed reading pageSize."); 
    178  
    179                 bytesread = read(m_indexFile, &m_nextPage, sizeof(id_type)); 
    180                 if (bytesread != sizeof(id_type)) 
    181                         throw Tools::IllegalStateException("Failed reading nextPage."); 
     152                m_indexFile.read(reinterpret_cast<char*>(&m_pageSize), sizeof(size_t)); 
     153                if (m_indexFile.fail()) 
     154                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Failed reading pageSize."); 
     155 
     156                m_indexFile.read(reinterpret_cast<char*>(&m_nextPage), sizeof(id_type)); 
     157                if (m_indexFile.fail()) 
     158                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Failed reading nextPage."); 
    182159        } 
    183160 
    …… 
    190167                size_t count; 
    191168                id_type id, page; 
    192                 ssize_t bytesread; 
    193169 
    194170                // load empty pages in memory. 
    195                 bytesread = read(m_indexFile, &count, sizeof(size_t)); 
    196                 if (bytesread != sizeof(size_t)) 
    197                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    198  
    199                 for (size_t cCount = 0; cCount < count; cCount++) 
    200                 { 
    201                         bytesread = read(m_indexFile, &page, sizeof(id_type)); 
    202                         if (bytesread != sizeof(id_type)) 
    203                                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     171                m_indexFile.read(reinterpret_cast<char*>(&count), sizeof(size_t)); 
     172                if (m_indexFile.fail()) 
     173                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     174 
     175                for (size_t cCount = 0; cCount < count; ++cCount) 
     176                { 
     177                        m_indexFile.read(reinterpret_cast<char*>(&page), sizeof(id_type)); 
     178                        if (m_indexFile.fail()) 
     179                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    204180                        m_emptyPages.push(page); 
    205181                } 
    206182 
    207183                // load index table in memory. 
    208                 bytesread = read(m_indexFile, &count, sizeof(size_t)); 
    209                 if (bytesread != sizeof(size_t)) 
    210                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    211  
    212                 for (size_t cCount = 0; cCount < count; cCount++) 
     184                m_indexFile.read(reinterpret_cast<char*>(&count), sizeof(size_t)); 
     185                if (m_indexFile.fail()) 
     186                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     187 
     188                for (size_t cCount = 0; cCount < count; ++cCount) 
    213189                { 
    214190                        Entry* e = new Entry(); 
    215191 
    216                         bytesread = read(m_indexFile, &id, sizeof(id_type)); 
    217                         if (bytesread != sizeof(id_type)) 
    218                                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    219  
    220                         bytesread = read(m_indexFile, &(e->m_length), sizeof(size_t)); 
    221                         if (bytesread != sizeof(size_t)) 
    222                                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     192                        m_indexFile.read(reinterpret_cast<char*>(&id), sizeof(id_type)); 
     193                        if (m_indexFile.fail()) 
     194                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     195 
     196                        m_indexFile.read(reinterpret_cast<char*>(&(e->m_length)), sizeof(size_t)); 
     197                        if (m_indexFile.fail()) 
     198                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    223199 
    224200                        size_t count2; 
    225                         bytesread = read(m_indexFile, &count2, sizeof(size_t)); 
    226                         if (bytesread != sizeof(size_t)) 
    227                                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    228  
    229                         for (size_t cCount2 = 0; cCount2 < count2; cCount2++) 
    230                         { 
    231                                 bytesread = read(m_indexFile, &page, sizeof(id_type)); 
    232                                 if (bytesread != sizeof(id_type)) 
    233                                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     201                        m_indexFile.read(reinterpret_cast<char*>(&count2), sizeof(size_t)); 
     202                        if (m_indexFile.fail()) 
     203                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     204 
     205                        for (size_t cCount2 = 0; cCount2 < count2; ++cCount2) 
     206                        { 
     207                                m_indexFile.read(reinterpret_cast<char*>(&page), sizeof(id_type)); 
     208                                if (m_indexFile.fail()) 
     209                                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    234210                                e->m_pages.push_back(page); 
    235211                        } 
    …… 
    242218{ 
    243219        flush(); 
    244         close(m_indexFile); 
    245         close(m_dataFile); 
     220        m_indexFile.close(); 
     221        m_dataFile.close(); 
    246222        if (m_buffer != 0) delete[] m_buffer; 
    247223 
    248         std::map<id_type, Entry*>::iterator it = m_pageIndex.begin(); 
    249  
    250         while (it != m_pageIndex.end()) 
    251         { 
    252                 delete (*it).second; 
    253                 it++; 
    254         } 
     224        std::map<id_type, Entry*>::iterator it; 
     225        for (it = m_pageIndex.begin(); it != m_pageIndex.end(); ++it) delete (*it).second; 
    255226} 
    256227 
    257228void DiskStorageManager::flush() 
    258229{ 
    259         ssize_t byteswritten; 
    260  
    261         off_t seek = lseek(m_indexFile, 0, SEEK_SET); 
    262         if (seek < 0) throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    263  
    264         byteswritten = write(m_indexFile, &m_pageSize, sizeof(size_t)); 
    265         if (byteswritten != sizeof(size_t)) throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    266         byteswritten = write(m_indexFile, &m_nextPage, sizeof(id_type)); 
    267         if (byteswritten != sizeof(id_type)) 
    268                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     230        m_indexFile.seekp(0, std::ios_base::beg); 
     231        if (m_indexFile.fail()) 
     232                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     233 
     234        m_indexFile.write(reinterpret_cast<const char*>(&m_pageSize), sizeof(size_t)); 
     235        if (m_indexFile.fail()) 
     236                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     237 
     238        m_indexFile.write(reinterpret_cast<const char*>(&m_nextPage), sizeof(id_type)); 
     239        if (m_indexFile.fail()) 
     240                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    269241 
    270242        size_t count = m_emptyPages.size(); 
    271243        id_type id, page; 
    272244 
    273         byteswritten = write(m_indexFile, &count, sizeof(size_t)); 
    274         if (byteswritten != sizeof(size_t)) 
    275                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     245        m_indexFile.write(reinterpret_cast<const char*>(&count), sizeof(size_t)); 
     246        if (m_indexFile.fail()) 
     247                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    276248 
    277249        while (! m_emptyPages.empty()) 
    278250        { 
    279251                page = m_emptyPages.top(); m_emptyPages.pop(); 
    280                 byteswritten = write(m_indexFile, &page, sizeof(id_type)); 
    281                 if (byteswritten != sizeof(id_type)) 
    282                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     252                m_indexFile.write(reinterpret_cast<const char*>(&page), sizeof(id_type)); 
     253                if (m_indexFile.fail()) 
     254                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    283255        } 
    284256 
    285257        count = m_pageIndex.size(); 
    286258 
    287         byteswritten = write(m_indexFile, &count, sizeof(size_t)); 
    288         if (byteswritten != sizeof(size_t)) 
    289                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    290  
    291         std::map<id_type, Entry*>::iterator it = m_pageIndex.begin(); 
    292  
    293         while (it != m_pageIndex.end()) 
     259        m_indexFile.write(reinterpret_cast<const char*>(&count), sizeof(size_t)); 
     260        if (m_indexFile.fail()) 
     261                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     262 
     263        std::map<id_type, Entry*>::iterator it; 
     264 
     265        for (it = m_pageIndex.begin(); it != m_pageIndex.end(); ++it) 
    294266        { 
    295267                id = (*it).first; 
    296                 byteswritten = write(m_indexFile, &id, sizeof(id_type)); 
    297                 if (byteswritten != sizeof(id_type)) 
    298                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     268                m_indexFile.write(reinterpret_cast<const char*>(&id), sizeof(id_type)); 
     269                if (m_indexFile.fail()) 
     270                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    299271 
    300272                size_t length = (*it).second->m_length; 
    301                 byteswritten = write(m_indexFile, &length, sizeof(size_t)); 
    302                 if (byteswritten != sizeof(size_t)) 
    303                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
     273                m_indexFile.write(reinterpret_cast<const char*>(&length), sizeof(size_t)); 
     274                if (m_indexFile.fail()) 
     275                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
    304276 
    305277                count = (*it).second->m_pages.size(); 
    306                 byteswritten = write(m_indexFile, &count, sizeof(size_t)); 
    307                 if (byteswritten != sizeof(size_t)) 
    308                         throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    309  
    310                 for (size_t cIndex = 0; cIndex < count; cIndex++) 
     278                m_indexFile.write(reinterpret_cast<const char*>(&count), sizeof(size_t)); 
     279                if (m_indexFile.fail()) 
     280                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     281 
     282                for (size_t cIndex = 0; cIndex < count; ++cIndex) 
    311283                { 
    312284                        page = (*it).second->m_pages[cIndex]; 
    313                         byteswritten = write(m_indexFile, &page, sizeof(id_type)); 
    314                         if (byteswritten != sizeof(id_type)) 
    315                                 throw Tools::IllegalStateException("Corrupted storage manager index file."); 
    316                 } 
    317                 it++; 
    318         } 
    319  
    320         fsync(m_indexFile); 
    321         fsync(m_dataFile); 
     285                        m_indexFile.write(reinterpret_cast<const char*>(&page), sizeof(id_type)); 
     286                        if (m_indexFile.fail()) 
     287                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted storage manager index file."); 
     288                } 
     289        } 
     290 
     291        m_indexFile.flush(); 
     292        m_dataFile.flush(); 
    322293} 
    323294 
    …… 
    326297        std::map<id_type, Entry*>::iterator it = m_pageIndex.find(id); 
    327298 
    328         if (it == m_pageIndex.end()) throw Tools::InvalidPageException(id); 
     299        if (it == m_pageIndex.end()) 
     300                throw Tools::InvalidPageException(id); 
    329301 
    330302        std::vector<id_type>& pages = (*it).second->m_pages; 
    …… 
    341313        do 
    342314        { 
    343                 off_t seek = lseek(m_dataFile, pages[cNext] * m_pageSize, SEEK_SET); 
    344                 if (seek < 0) throw Tools::IllegalStateException("Corrupted data file."); 
    345  
    346                 ssize_t bytesread = read(m_dataFile, m_buffer, m_pageSize); 
    347                 if (bytesread <= 0) throw Tools::IllegalStateException("Corrupted data file."); 
     315                m_dataFile.seekg(pages[cNext] * m_pageSize, std::ios_base::beg); 
     316                if (m_dataFile.fail()) 
     317                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted data file."); 
     318 
     319                m_dataFile.read(reinterpret_cast<char*>(m_buffer), m_pageSize); 
     320                if (m_dataFile.fail()) 
     321                        throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted data file."); 
    348322 
    349323                cLen = (cRem > m_pageSize) ? m_pageSize : cRem; 
    …… 
    352326                ptr += cLen; 
    353327                cRem -= cLen; 
    354                 cNext++; 
     328                ++cNext; 
    355329        } 
    356330        while (cNext < cTotal); 
    …… 
    378352                        { 
    379353                                cPage = m_nextPage; 
    380                                 m_nextPage++; 
     354                                ++m_nextPage; 
    381355                        } 
    382356 
    …… 
    384358                        memcpy(m_buffer, ptr, cLen); 
    385359 
    386                         off_t seek = lseek(m_dataFile, cPage * m_pageSize, SEEK_SET); 
    387                         if (seek < 0) throw Tools::IllegalStateException("Corrupted data file."); 
    388                         ssize_t byteswritten = write(m_dataFile, m_buffer, m_pageSize); 
    389                         if (byteswritten <= 0) throw Tools::IllegalStateException("Corrupted data file."); 
     360                        m_dataFile.seekp(cPage * m_pageSize, std::ios_base::beg); 
     361                        if (m_dataFile.fail()) 
     362                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted data file."); 
     363                         
     364                        m_dataFile.write(reinterpret_cast<const char*>(m_buffer), m_pageSize); 
     365                        if (m_dataFile.fail()) 
     366                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted data file."); 
    390367 
    391368                        ptr += cLen; 
    …… 
    403380 
    404381                // check if it exists. 
    405                 if (it == m_pageIndex.end()) throw Tools::IndexOutOfBoundsException(id); 
     382                if (it == m_pageIndex.end()) 
     383                        throw Tools::IndexOutOfBoundsException(id); 
    406384 
    407385                Entry* oldEntry = (*it).second; 
    …… 
    437415                        memcpy(m_buffer, ptr, cLen); 
    438416 
    439                         off_t seek = lseek(m_dataFile, cPage * m_pageSize, SEEK_SET); 
    440                         if (seek < 0) throw Tools::IllegalStateException("Corrupted data file."); 
    441                         ssize_t byteswritten = write(m_dataFile, m_buffer, m_pageSize); 
    442                         if (byteswritten <= 0) throw Tools::IllegalStateException("Corrupted data file."); 
     417                        m_dataFile.seekp(cPage * m_pageSize, std::ios_base::beg); 
     418                        if (m_dataFile.fail()) 
     419                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted data file."); 
     420                         
     421                        m_dataFile.write(reinterpret_cast<const char*>(m_buffer), m_pageSize); 
     422                        if (m_dataFile.fail()) 
     423                                throw Tools::IllegalStateException("SpatialIndex::DiskStorageManager: Corrupted data file."); 
    443424 
    444425                        ptr += cLen; 
    …… 
    450431                { 
    451432                        m_emptyPages.push(oldEntry->m_pages[cNext]); 
    452                         cNext++; 
     433                        ++cNext; 
    453434                } 
    454435 
    …… 
    462443        std::map<id_type, Entry*>::iterator it = m_pageIndex.find(id); 
    463444 
    464         if (it == m_pageIndex.end()) throw Tools::InvalidPageException(id); 
    465  
    466         for (size_t cIndex = 0; cIndex < (*it).second->m_pages.size(); cIndex++) 
     445        if (it == m_pageIndex.end()) 
     446                throw Tools::InvalidPageException(id); 
     447 
     448        for (size_t cIndex = 0; cIndex < (*it).second->m_pages.size(); ++cIndex) 
    467449        { 
    468450                m_emptyPages.push((*it).second->m_pages[cIndex]); 
    …… 
    472454        m_pageIndex.erase(it); 
    473455} 
    474  

  • spatialindex/trunk/src/storagemanager/DiskStorageManager.h

    r2 r86  
    4747                        }; 
    4848 
    49                         int m_dataFile; 
    50                         int m_indexFile; 
     49                        std::fstream m_dataFile; 
     50                        std::fstream m_indexFile; 
    5151                        size_t m_pageSize; 
    5252                        id_type m_nextPage;