自学教程：C++ Hash_Fetch函数代码示例

TermVector*DocVec_Term_Vector_IMP(DocVector *self, String *field,                       String *term_text) {    DocVectorIVARS *const ivars = DocVec_IVARS(self);    Hash *field_vector = (Hash*)Hash_Fetch(ivars->field_vectors, (Obj*)field);    // If no cache hit, try to fill cache.    if (field_vector == NULL) {        ByteBuf *field_buf            = (ByteBuf*)Hash_Fetch(ivars->field_bufs, (Obj*)field);        // Bail if there's no content or the field isn't highlightable.        if (field_buf == NULL) { return NULL; }        field_vector = S_extract_tv_cache(field_buf);        Hash_Store(ivars->field_vectors, (Obj*)field, (Obj*)field_vector);    }    // Get a buf for the term text or bail.    ByteBuf *tv_buf = (ByteBuf*)Hash_Fetch(field_vector, (Obj*)term_text);    if (tv_buf == NULL) {        return NULL;    }    return S_extract_tv_from_tv_buf(field, term_text, tv_buf);}

TermVector*DocVec_term_vector(DocVector *self, const CharBuf *field,                   const CharBuf *term_text) {    Hash *field_vector = (Hash*)Hash_Fetch(self->field_vectors, (Obj*)field);    // If no cache hit, try to fill cache.    if (field_vector == NULL) {        ByteBuf *field_buf            = (ByteBuf*)Hash_Fetch(self->field_bufs, (Obj*)field);        // Bail if there's no content or the field isn't highlightable.        if (field_buf == NULL) { return NULL; }        field_vector = S_extract_tv_cache(field_buf);        Hash_Store(self->field_vectors, (Obj*)field, (Obj*)field_vector);    }    // Get a buf for the term text or bail.    ByteBuf *tv_buf = (ByteBuf*)Hash_Fetch(field_vector, (Obj*)term_text);    if (tv_buf == NULL) {        return NULL;    }    return S_extract_tv_from_tv_buf(field, term_text, tv_buf);}

static voidS_init_sub_readers(PolyReader *self, VArray *sub_readers) {    PolyReaderIVARS *const ivars = PolyReader_IVARS(self);    uint32_t  num_sub_readers = VA_Get_Size(sub_readers);    int32_t *starts = (int32_t*)MALLOCATE(num_sub_readers * sizeof(int32_t));    Hash  *data_readers = Hash_new(0);    DECREF(ivars->sub_readers);    DECREF(ivars->offsets);    ivars->sub_readers       = (VArray*)INCREF(sub_readers);    // Accumulate doc_max, subreader start offsets, and DataReaders.    ivars->doc_max = 0;    for (uint32_t i = 0; i < num_sub_readers; i++) {        SegReader *seg_reader = (SegReader*)VA_Fetch(sub_readers, i);        Hash *components = SegReader_Get_Components(seg_reader);        CharBuf *api;        DataReader *component;        starts[i] = ivars->doc_max;        ivars->doc_max += SegReader_Doc_Max(seg_reader);        Hash_Iterate(components);        while (Hash_Next(components, (Obj**)&api, (Obj**)&component)) {            VArray *readers = (VArray*)Hash_Fetch(data_readers, (Obj*)api);            if (!readers) {                readers = VA_new(num_sub_readers);                Hash_Store(data_readers, (Obj*)api, (Obj*)readers);            }            VA_Store(readers, i, INCREF(component));        }    }    ivars->offsets = I32Arr_new_steal(starts, num_sub_readers);    CharBuf *api;    VArray  *readers;    Hash_Iterate(data_readers);    while (Hash_Next(data_readers, (Obj**)&api, (Obj**)&readers)) {        DataReader *datareader            = (DataReader*)CERTIFY(S_first_non_null(readers), DATAREADER);        DataReader *aggregator            = DataReader_Aggregator(datareader, readers, ivars->offsets);        if (aggregator) {            CERTIFY(aggregator, DATAREADER);            Hash_Store(ivars->components, (Obj*)api, (Obj*)aggregator);        }    }    DECREF(data_readers);    DeletionsReader *del_reader        = (DeletionsReader*)Hash_Fetch(              ivars->components, (Obj*)VTable_Get_Name(DELETIONSREADER));    ivars->del_count = del_reader ? DelReader_Del_Count(del_reader) : 0;}

voidSeg_store_metadata(Segment *self, const CharBuf *key, Obj *value) {    if (Hash_Fetch(self->metadata, (Obj*)key)) {        THROW(ERR, "Metadata key '%o' already registered", key);    }    Hash_Store(self->metadata, (Obj*)key, value);}

SegReader*SegReader_init(SegReader *self, Schema *schema, Folder *folder,               Snapshot *snapshot, Vector *segments, int32_t seg_tick) {    Segment *segment;    IxReader_init((IndexReader*)self, schema, folder, snapshot, segments,                  seg_tick, NULL);    SegReaderIVARS *const ivars = SegReader_IVARS(self);    segment = SegReader_Get_Segment(self);    ivars->doc_max    = (int32_t)Seg_Get_Count(segment);    ivars->seg_name   = (String*)INCREF(Seg_Get_Name(segment));    ivars->seg_num    = Seg_Get_Number(segment);    Err *error = Err_trap(S_try_init_components, self);    if (error) {        // An error occurred, so clean up self and rethrow the exception.        DECREF(self);        RETHROW(error);    }    DeletionsReader *del_reader        = (DeletionsReader*)Hash_Fetch(              ivars->components, Class_Get_Name(DELETIONSREADER));    ivars->del_count = del_reader ? DelReader_Del_Count(del_reader) : 0;    return self;}

bool_tRAMFolder_local_is_directory(RAMFolder *self, const CharBuf *name){    Obj *entry = Hash_Fetch(self->entries, (Obj*)name);    if (entry && Obj_Is_A(entry, FOLDER)) { return true; }    return false;}

FileDes*RAMFolder_open_filedes(RAMFolder *self, const CharBuf *filepath){    RAMFileDes *file_des         = (RAMFileDes*)Hash_Fetch(self->elems, filepath);    return file_des ? (FileDes*)INCREF(file_des) : NULL;}

Folder*CFReader_Local_Find_Folder_IMP(CompoundFileReader *self,                               String *name) {    CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);    if (Hash_Fetch(ivars->records, name)) { return false; }    return Folder_Local_Find_Folder(ivars->real_folder, name);}

boolCFReader_Local_Exists_IMP(CompoundFileReader *self, String *name) {    CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);    if (Hash_Fetch(ivars->records, name))              { return true; }    if (Folder_Local_Exists(ivars->real_folder, name)) { return true; }    return false;}

InStream*CFReader_Local_Open_In_IMP(CompoundFileReader *self, String *name) {    CompoundFileReaderIVARS *const ivars = CFReader_IVARS(self);    Hash *entry = (Hash*)Hash_Fetch(ivars->records, name);    if (!entry) {        InStream *instream = Folder_Local_Open_In(ivars->real_folder, name);        if (!instream) {            ERR_ADD_FRAME(Err_get_error());        }        return instream;    }    else {        Obj *len    = Hash_Fetch_Utf8(entry, "length", 6);        Obj *offset = Hash_Fetch_Utf8(entry, "offset", 6);        if (!len || !offset) {            Err_set_error(Err_new(Str_newf("Malformed entry for '%o' in '%o'",                                           name, Folder_Get_Path(ivars->real_folder))));            return NULL;        }        else if (Str_Get_Size(ivars->path)) {            String *fullpath = Str_newf("%o/%o", ivars->path, name);            InStream *instream = InStream_Reopen(ivars->instream, fullpath,                                                 Obj_To_I64(offset), Obj_To_I64(len));            DECREF(fullpath);            return instream;        }        else {            return InStream_Reopen(ivars->instream, name, Obj_To_I64(offset),                                   Obj_To_I64(len));        }    }}

bool_tRAMFolder_local_delete(RAMFolder *self, const CharBuf *name){    Obj *entry = Hash_Fetch(self->entries, (Obj*)name);    if (entry) {        if (Obj_Is_A(entry, RAMFILE)) {            ;        }        else if (Obj_Is_A(entry, FOLDER)) {            RAMFolder *inner_folder;            if (Obj_Is_A(entry, COMPOUNDFILEREADER)) {                inner_folder = (RAMFolder*)CERTIFY(                    CFReader_Get_Real_Folder((CompoundFileReader*)entry),                     RAMFOLDER);            }            else {                inner_folder = (RAMFolder*)CERTIFY(entry, RAMFOLDER);            }            if (Hash_Get_Size(inner_folder->entries)) {                // Can't delete non-empty dir.                 return false;            }        }        else {            return false;        }        DECREF(Hash_Delete(self->entries, (Obj*)name));        return true;    }    else {        return false;    }}

bool_tHash_equals(Hash *self, Obj *other) {    Hash    *twin = (Hash*)other;    Obj     *key;    Obj     *val;    if (twin == self)             {        return true;    }    if (!Obj_Is_A(other, HASH))   {        return false;    }    if (self->size != twin->size) {        return false;    }    Hash_Iterate(self);    while (Hash_Next(self, &key, &val)) {        Obj *other_val = Hash_Fetch(twin, key);        if (!other_val || !Obj_Equals(other_val, val)) {            return false;        }    }    return true;}

InStream*CFReader_local_open_in(CompoundFileReader *self, const CharBuf *name) {    Hash *entry = (Hash*)Hash_Fetch(self->records, (Obj*)name);    if (!entry) {        InStream *instream = Folder_Local_Open_In(self->real_folder, name);        if (!instream) {            ERR_ADD_FRAME(Err_get_error());        }        return instream;    }    else {        Obj *len    = Hash_Fetch_Str(entry, "length", 6);        Obj *offset = Hash_Fetch_Str(entry, "offset", 6);        if (!len || !offset) {            Err_set_error(Err_new(CB_newf("Malformed entry for '%o' in '%o'",                                          name, Folder_Get_Path(self->real_folder))));            return NULL;        }        else if (CB_Get_Size(self->path)) {            CharBuf *fullpath = CB_newf("%o/%o", self->path, name);            InStream *instream = InStream_Reopen(self->instream, fullpath,                                                 Obj_To_I64(offset), Obj_To_I64(len));            DECREF(fullpath);            return instream;        }        else {            return InStream_Reopen(self->instream, name, Obj_To_I64(offset),                                   Obj_To_I64(len));        }    }}

Analyzer*Schema_Fetch_Analyzer_IMP(Schema *self, String *field) {    SchemaIVARS *const ivars = Schema_IVARS(self);    return field           ? (Analyzer*)Hash_Fetch(ivars->analyzers, field)           : NULL;}

Matcher*DefDelWriter_Seg_Deletions_IMP(DefaultDeletionsWriter *self,                               SegReader *seg_reader) {    DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);    Matcher *deletions    = NULL;    Segment *segment      = SegReader_Get_Segment(seg_reader);    String  *seg_name     = Seg_Get_Name(segment);    Integer32 *tick_obj   = (Integer32*)Hash_Fetch(ivars->name_to_tick,                                                   (Obj*)seg_name);    int32_t tick          = tick_obj ? Int32_Get_Value(tick_obj) : 0;    SegReader *candidate  = tick_obj                            ? (SegReader*)VA_Fetch(ivars->seg_readers, tick)                            : NULL;    if (tick_obj) {        DeletionsReader *del_reader            = (DeletionsReader*)SegReader_Obtain(                  candidate, Class_Get_Name(DELETIONSREADER));        if (ivars->updated[tick] || DelReader_Del_Count(del_reader)) {            BitVector *deldocs = (BitVector*)VA_Fetch(ivars->bit_vecs, tick);            deletions = (Matcher*)BitVecMatcher_new(deldocs);        }    }    else { // Sanity check.        THROW(ERR, "Couldn't find SegReader %o", seg_reader);    }    return deletions;}

RAMFileDes*RAMFolder_ram_file(RAMFolder *self, const CharBuf *filepath){    RAMFileDes *ram_file = (RAMFileDes*)Hash_Fetch(self->elems, filepath);    if (ram_file == NULL)        THROW( "File '%o' not loaded into RAM", filepath);    return ram_file;}

voidSeg_Store_Metadata_IMP(Segment *self, String *key, Obj *value) {    SegmentIVARS *const ivars = Seg_IVARS(self);    if (Hash_Fetch(ivars->metadata, key)) {        THROW(ERR, "Metadata key '%o' already registered", key);    }    Hash_Store(ivars->metadata, key, value);}

Folder*RAMFolder_local_find_folder(RAMFolder *self, const CharBuf *path){    Folder *local_folder = (Folder*)Hash_Fetch(self->entries, (Obj*)path);    if (local_folder && Folder_Is_A(local_folder, FOLDER)) {        return local_folder;    }    return NULL;}

Similarity*Schema_Fetch_Sim_IMP(Schema *self, String *field) {    SchemaIVARS *const ivars = Schema_IVARS(self);    Similarity *sim = NULL;    if (field != NULL) {        sim = (Similarity*)Hash_Fetch(ivars->sims, field);    }    return sim;}

voidSegReader_register(SegReader *self, const CharBuf *api, DataReader *component){    if (Hash_Fetch(self->components, api)) {        THROW("Interface '%o' already registered");    }    ASSERT_IS_A(component, DATAREADER);    Hash_Store(self->components, api, (Obj*)component);}

int32_tDefDelWriter_Seg_Del_Count_IMP(DefaultDeletionsWriter *self,                               String *seg_name) {    DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);    Integer *tick = (Integer*)Hash_Fetch(ivars->name_to_tick, seg_name);    BitVector *deldocs = tick                         ? (BitVector*)Vec_Fetch(ivars->bit_vecs, (size_t)Int_Get_Value(tick))                         : NULL;    return deldocs ? (int32_t)BitVec_Count(deldocs) : 0;}

bool_tRAMFolder_exists(RAMFolder *self, const CharBuf *filepath){    if (Hash_Fetch(self->elems, filepath) != NULL) {        return true;    }    else {        return false;    }}

voidSegReader_Register_IMP(SegReader *self, String *api,                       DataReader *component) {    SegReaderIVARS *const ivars = SegReader_IVARS(self);    if (Hash_Fetch(ivars->components, api)) {        THROW(ERR, "Interface '%o' already registered");    }    CERTIFY(component, DATAREADER);    Hash_Store(ivars->components, api, (Obj*)component);}

voidSegWriter_Register_IMP(SegWriter *self, String *api,                       DataWriter *component) {    SegWriterIVARS *const ivars = SegWriter_IVARS(self);    CERTIFY(component, DATAWRITER);    if (Hash_Fetch(ivars->by_api, api)) {        THROW(ERR, "API %o already registered", api);    }    Hash_Store(ivars->by_api, api, (Obj*)component);}

int32_tSeg_field_num(Segment *self, const CharBuf *field) {    if (field == NULL) {        return 0;    }    else {        Integer32 *num = (Integer32*)Hash_Fetch(self->by_name, (Obj*)field);        return num ? Int32_Get_Value(num) : 0;    }}

int32_tDefDelWriter_seg_del_count(DefaultDeletionsWriter *self,                           const CharBuf *seg_name) {    DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);    Integer32 *tick        = (Integer32*)Hash_Fetch(ivars->name_to_tick, (Obj*)seg_name);    BitVector *deldocs = tick                         ? (BitVector*)VA_Fetch(ivars->bit_vecs, Int32_Get_Value(tick))                         : NULL;    return deldocs ? BitVec_Count(deldocs) : 0;}

int32_tSeg_Field_Num_IMP(Segment *self, String *field) {    if (field == NULL) {        return 0;    }    else {        SegmentIVARS *const ivars = Seg_IVARS(self);        Integer *num = (Integer*)Hash_Fetch(ivars->by_name, field);        return num ? (int32_t)Int_Get_Value(num) : 0;    }}

bool_tCFReader_local_mkdir(CompoundFileReader *self, const CharBuf *name) {    if (Hash_Fetch(self->records, (Obj*)name)) {        Err_set_error(Err_new(CB_newf("Can't MkDir: '%o' exists", name)));        return false;    }    else {        bool_t result = Folder_Local_MkDir(self->real_folder, name);        if (!result) { ERR_ADD_FRAME(Err_get_error()); }        return result;    }}

OutStream*RAMFolder_open_out(RAMFolder *self, const CharBuf *filepath){    if (Hash_Fetch(self->elems, filepath)) {        return NULL;    }    else {        RAMFileDes *file_des = RAMFileDes_new(filepath);        Hash_Store(self->elems, filepath, (Obj*)file_des);        return OutStream_new((FileDes*)file_des);    }}

int32_tSeg_add_field(Segment *self, const CharBuf *field) {    Integer32 *num = (Integer32*)Hash_Fetch(self->by_name, (Obj*)field);    if (num) {        return Int32_Get_Value(num);    }    else {        int32_t field_num = VA_Get_Size(self->by_num);        Hash_Store(self->by_name, (Obj*)field, (Obj*)Int32_new(field_num));        VA_Push(self->by_num, (Obj*)CB_Clone(field));        return field_num;    }}