bitcoin core load mapBlcokIndex

load_map_block_index.cpp

// txdb.cpp
static const char DB_BLOCK_INDEX = 'b';

bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex)
{
  std::unique_ptr<CDBIterator> pcursor(NewIterator());

  // Start from key b000...
  pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));

  // Load mapBlockIndex
  while (pcursor->Valid()) {
    boost::this_thread::interruption_point();
    std::pair<char, uint256> key;

    if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
      // CDiskBlockIndex inherits CBlockIndex and implements serialization method.
      CDiskBlockIndex diskindex;
      if (pcursor->GetValue(diskindex)) {
        // Construct block index object
        CBlockIndex* pindexNew = insertBlockIndex(diskindex.GetBlockHash());
        pindexNew->pprev          = insertBlockIndex(diskindex.hashPrev);
        pindexNew->nHeight        = diskindex.nHeight;
        pindexNew->nFile          = diskindex.nFile;
        pindexNew->nDataPos       = diskindex.nDataPos;
        pindexNew->nUndoPos       = diskindex.nUndoPos;
        pindexNew->nVersion       = diskindex.nVersion;
        pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
        pindexNew->nTime          = diskindex.nTime;
        pindexNew->nBits          = diskindex.nBits;
        pindexNew->nNonce         = diskindex.nNonce;
        pindexNew->nStatus        = diskindex.nStatus;
        pindexNew->nTx            = diskindex.nTx;

        if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams))
          return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString());

        pcursor->Next();
      } else {
        return error("%s: failed to read value", __func__);
      }
    } else {
      break;
    }
  }

  return true;
}

// validation.cpp. The only function as an argument of LoadBlockIndexGuts.
CBlockIndex * InsertBlockIndex(uint256 hash)
{
    if (hash.IsNull())
        return nullptr;

    // Return existing
    BlockMap::iterator mi = mapBlockIndex.find(hash);
    if (mi != mapBlockIndex.end())
        return (*mi).second;

    // Create new
    CBlockIndex* pindexNew = new CBlockIndex();
    mi = mapBlockIndex.insert(std::make_pair(hash, pindexNew)).first;
    pindexNew->phashBlock = &((*mi).first);

    return pindexNew;
}