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

HighlightWriter*HLWriter_new(Schema *schema, Snapshot *snapshot, Segment *segment,             PolyReader *polyreader) {    HighlightWriter *self        = (HighlightWriter*)Class_Make_Obj(HIGHLIGHTWRITER);    return HLWriter_init(self, schema, snapshot, segment, polyreader);}

static FieldType*S_load_type(Class *klass, Obj *type_dump) {    FieldType *dummy = (FieldType*)Class_Make_Obj(klass);    FieldType *loaded = (FieldType*)FType_Load(dummy, type_dump);    DECREF(dummy);    return loaded;}

InStream*InStream_Reopen_IMP(InStream *self, String *filename, int64_t offset,                    int64_t len) {    InStreamIVARS *const ivars = InStream_IVARS(self);    if (!ivars->file_handle) {        THROW(ERR, "Can't Reopen() closed InStream %o", ivars->filename);    }    if (offset + len > FH_Length(ivars->file_handle)) {        THROW(ERR, "Offset + length too large (%i64 + %i64 > %i64)",              offset, len, FH_Length(ivars->file_handle));    }    Class *klass = InStream_get_class(self);    InStream *other = (InStream*)Class_Make_Obj(klass);    InStreamIVARS *const ovars = InStream_IVARS(other);    InStream_do_open(other, (Obj*)ivars->file_handle);    if (filename != NULL) {        String *temp = ovars->filename;        ovars->filename = Str_Clone(filename);        DECREF(temp);    }    ovars->offset = offset;    ovars->len    = len;    InStream_Seek(other, 0);    return other;}

ProximityCompiler*ProximityCompiler_new(ProximityQuery *parent, Searcher *searcher, float boost,                      uint32_t within) {    ProximityCompiler *self =        (ProximityCompiler*)Class_Make_Obj(PROXIMITYCOMPILER);    return ProximityCompiler_init(self, parent, searcher, boost, within);}

voidBool_init_class() {    Boolean *true_obj = (Boolean*)Class_Make_Obj(BOOLEAN);    true_obj->value   = true;    true_obj->string  = Str_newf("true");    if (!Atomic_cas_ptr((void**)&Bool_true_singleton, NULL, true_obj)) {        Bool_Destroy(true_obj);    }    Boolean *false_obj = (Boolean*)Class_Make_Obj(BOOLEAN);    false_obj->value   = false;    false_obj->string  = Str_newf("false");    if (!Atomic_cas_ptr((void**)&Bool_false_singleton, NULL, false_obj)) {        Bool_Destroy(false_obj);    }}

RangeQuery*RangeQuery_new(String *field, Obj *lower_term, Obj *upper_term,               bool include_lower, bool include_upper) {    RangeQuery *self = (RangeQuery*)Class_Make_Obj(RANGEQUERY);    return RangeQuery_init(self, field, lower_term, upper_term,                           include_lower, include_upper);}

static Obj*S_load_via_load_method(Class *klass, Obj *dump) {    Obj *dummy = Class_Make_Obj(klass);    Obj *loaded = NULL;    if (Obj_is_a(dummy, ANALYZER)) {        loaded = Analyzer_Load((Analyzer*)dummy, dump);    }    else if (Obj_is_a(dummy, DOC)) {        loaded = (Obj*)Doc_Load((Doc*)dummy, dump);    }    else if (Obj_is_a(dummy, SIMILARITY)) {        loaded = (Obj*)Sim_Load((Similarity*)dummy, dump);    }    else if (Obj_is_a(dummy, FIELDTYPE)) {        loaded = FType_Load((FieldType*)dummy, dump);    }    else if (Obj_is_a(dummy, SCHEMA)) {        loaded = (Obj*)Schema_Load((Schema*)dummy, dump);    }    else if (Obj_is_a(dummy, QUERY)) {        loaded = Query_Load((Query*)dummy, dump);    }    else {        DECREF(dummy);        THROW(ERR, "Don't know how to load '%o'", Class_Get_Name(klass));    }    DECREF(dummy);    return loaded;}

DefaultDeletionsWriter*DefDelWriter_new(Schema *schema, Snapshot *snapshot, Segment *segment,                 PolyReader *polyreader) {    DefaultDeletionsWriter *self        = (DefaultDeletionsWriter*)Class_Make_Obj(DEFAULTDELETIONSWRITER);    return DefDelWriter_init(self, schema, snapshot, segment, polyreader);}

static FieldType*S_alt_field_type() {    StackString *name = SSTR_WRAP_UTF8("DummyFieldType2", 15);    Class *klass = Class_singleton((String*)name, DUMMYFIELDTYPE);    FieldType *self = (FieldType*)Class_Make_Obj(klass);    return FType_init(self);}

StringIterator*StrIter_new(String *string, size_t byte_offset) {    StringIterator *self = (StringIterator*)Class_Make_Obj(STRINGITERATOR);    self->string      = (String*)INCREF(string);    self->byte_offset = byte_offset;    return self;}

Obj*Freezer_thaw(InStream *instream) {    String *class_name = Freezer_read_string(instream);    Class *klass = Class_singleton(class_name, NULL);    Obj *blank = Class_Make_Obj(klass);    DECREF(class_name);    return Freezer_deserialize(blank, instream);}

DefaultDocReader*DefDocReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,                 Vector *segments, int32_t seg_tick) {    DefaultDocReader *self        = (DefaultDocReader*)Class_Make_Obj(DEFAULTDOCREADER);    return DefDocReader_init(self, schema, folder, snapshot, segments,                             seg_tick);}

static SFWriterElem*S_SFWriterElem_create(Obj *value, int32_t doc_id) {    SFWriterElem *self = (SFWriterElem*)Class_Make_Obj(SFWRITERELEM);    SFWriterElemIVARS *ivars = SFWriterElem_IVARS(self);    ivars->value  = value;    ivars->doc_id = doc_id;    return self;}

RequiredOptionalMatcher*ReqOptMatcher_new(Similarity *similarity, Matcher *required_matcher,                  Matcher *optional_matcher) {    RequiredOptionalMatcher *self        = (RequiredOptionalMatcher*)Class_Make_Obj(REQUIREDOPTIONALMATCHER);    return ReqOptMatcher_init(self, similarity, required_matcher,                              optional_matcher);}

String*Str_new_steal_utf8(char *utf8, size_t size) {    if (!StrHelp_utf8_valid(utf8, size)) {        DIE_INVALID_UTF8(utf8, size);    }    String *self = (String*)Class_Make_Obj(STRING);    return Str_init_steal_trusted_utf8(self, utf8, size);}

TextSortCache*TextSortCache_new(String *field, FieldType *type, int32_t cardinality,                  int32_t doc_max, int32_t null_ord, int32_t ord_width,                  InStream *ord_in, InStream *ix_in, InStream *dat_in) {    TextSortCache *self = (TextSortCache*)Class_Make_Obj(TEXTSORTCACHE);    return TextSortCache_init(self, field, type, cardinality, doc_max,                              null_ord, ord_width, ord_in, ix_in, dat_in);}

InStream*InStream_Clone_IMP(InStream *self) {    InStreamIVARS *const ivars = InStream_IVARS(self);    Class *klass = InStream_get_class(self);    InStream *twin = (InStream*)Class_Make_Obj(klass);    InStream_do_open(twin, (Obj*)ivars->file_handle);    InStream_Seek(twin, SI_tell(self));    return twin;}

String*Str_Cat_Trusted_Utf8_IMP(String *self, const char* ptr, size_t size) {    size_t  result_size = self->size + size;    char   *result_ptr  = (char*)MALLOCATE(result_size + 1);    memcpy(result_ptr, self->ptr, self->size);    memcpy(result_ptr + self->size, ptr, size);    result_ptr[result_size] = '/0';    String *result = (String*)Class_Make_Obj(STRING);    return Str_init_steal_trusted_utf8(result, result_ptr, result_size);}

ScorePostingMatcher*ScorePost_Make_Matcher_IMP(ScorePosting *self, Similarity *sim,                           PostingList *plist, Compiler *compiler,                           bool need_score) {    ScorePostingMatcher *matcher        = (ScorePostingMatcher*)Class_Make_Obj(SCOREPOSTINGMATCHER);    UNUSED_VAR(self);    UNUSED_VAR(need_score);    return ScorePostMatcher_init(matcher, sim, plist, compiler);}

static Obj*S_new_testobj() {    StackString *class_name = SSTR_WRAP_UTF8("TestObj", 7);    Obj *obj;    Class *klass = Class_fetch_class((String*)class_name);    if (!klass) {        klass = Class_singleton((String*)class_name, OBJ);    }    obj = Class_Make_Obj(klass);    return Obj_init(obj);}

PostingPool*PostPool_new(Schema *schema, Snapshot *snapshot, Segment *segment,             PolyReader *polyreader,  String *field,             LexiconWriter *lex_writer, MemoryPool *mem_pool,             OutStream *lex_temp_out, OutStream *post_temp_out,             OutStream *skip_out) {    PostingPool *self = (PostingPool*)Class_Make_Obj(POSTINGPOOL);    return PostPool_init(self, schema, snapshot, segment, polyreader, field,                         lex_writer, mem_pool, lex_temp_out, post_temp_out,                         skip_out);}

SortFieldWriter*SortFieldWriter_new(Schema *schema, Snapshot *snapshot, Segment *segment,                    PolyReader *polyreader, String *field,                    Counter *counter, size_t mem_thresh,                    OutStream *temp_ord_out, OutStream *temp_ix_out,                    OutStream *temp_dat_out) {    SortFieldWriter *self        = (SortFieldWriter*)Class_Make_Obj(SORTFIELDWRITER);    return SortFieldWriter_init(self, schema, snapshot, segment, polyreader,                                field, counter, mem_thresh, temp_ord_out,                                temp_ix_out, temp_dat_out);}

static FileHandle*S_new_filehandle() {    String *class_name = SSTR_WRAP_UTF8("TestFileHandle", 14);    FileHandle *fh;    Class *klass = Class_fetch_class(class_name);    if (!klass) {        klass = Class_singleton(class_name, FILEHANDLE);    }    Class_Override(klass, S_no_op_method, LUCY_FH_Close_OFFSET);    fh = (FileHandle*)Class_Make_Obj(klass);    return FH_do_open(fh, NULL, 0);}

voidTHROW(Class *klass, char *pattern, ...) {    va_list args;    va_start(args, pattern);    String *message = S_str_vnewf(pattern, args);    va_end(args);    Err *err = (Err*)Class_Make_Obj(klass);    err = Err_init(err, message);    Err_do_throw(err);}

voidErr_throw_at(Class *klass, const char *file, int line,             const char *func, const char *pattern, ...) {    va_list args;    va_start(args, pattern);    String *message = S_vmake_mess(file, line, func, pattern, args);    va_end(args);    Err *err = (Err*)Class_Make_Obj(klass);    err = Err_init(err, message);    Err_do_throw(err);}

static voidtest_abstract_routines(TestBatchRunner *runner) {    Obj *blank = Class_Make_Obj(OBJ);    S_verify_abstract_error(runner, S_attempt_init, blank, "init");    Obj *obj = S_new_testobj();    S_verify_abstract_error(runner, S_attempt_Clone,      obj, "Clone");    S_verify_abstract_error(runner, S_attempt_Compare_To, obj, "Compare_To");    S_verify_abstract_error(runner, S_attempt_To_I64,     obj, "To_I64");    S_verify_abstract_error(runner, S_attempt_To_F64,     obj, "To_F64");    S_verify_abstract_error(runner, S_attempt_Mimic,      obj, "Mimic");    DECREF(obj);}

String*Str_new_from_char(int32_t code_point) {    const size_t MAX_UTF8_BYTES = 4;    char   *ptr  = (char*)MALLOCATE(MAX_UTF8_BYTES + 1);    size_t  size = StrHelp_encode_utf8_char(code_point, (uint8_t*)ptr);    ptr[size] = '/0';    String *self = (String*)Class_Make_Obj(STRING);    self->ptr    = ptr;    self->size   = size;    self->origin = self;    return self;}

static String*S_new_substring(String *string, size_t byte_offset, size_t size) {    String *self = (String*)Class_Make_Obj(STRING);    if (string->origin == NULL) {        // Copy substring of wrapped strings.        Str_init_from_trusted_utf8(self, string->ptr + byte_offset, size);    }    else {        self->ptr    = string->ptr + byte_offset;        self->size   = size;        self->origin = (String*)INCREF(string->origin);    }    return self;}

NumericType*NumType_Load_IMP(NumericType *self, Obj *dump) {    UNUSED_VAR(self);    Hash *source = (Hash*)CERTIFY(dump, HASH);    // Get a Class    String *class_name = (String*)Hash_Fetch_Utf8(source, "_class", 6);    String *type_spec  = (String*)Hash_Fetch_Utf8(source, "type", 4);    Class *klass = NULL;    if (class_name != NULL && Obj_is_a((Obj*)class_name, STRING)) {        klass = Class_singleton(class_name, NULL);    }    else if (type_spec != NULL && Obj_is_a((Obj*)type_spec, STRING)) {        if (Str_Equals_Utf8(type_spec, "i32_t", 5)) {            klass = INT32TYPE;        }        else if (Str_Equals_Utf8(type_spec, "i64_t", 5)) {            klass = INT64TYPE;        }        else if (Str_Equals_Utf8(type_spec, "f32_t", 5)) {            klass = FLOAT32TYPE;        }        else if (Str_Equals_Utf8(type_spec, "f64_t", 5)) {            klass = FLOAT64TYPE;        }        else {            THROW(ERR, "Unrecognized type string: '%o'", type_spec);        }    }    CERTIFY(klass, CLASS);    NumericType *loaded = (NumericType*)Class_Make_Obj(klass);    // Extract boost.    Obj *boost_dump = Hash_Fetch_Utf8(source, "boost", 5);    float boost = boost_dump ? (float)Json_obj_to_f64(boost_dump) : 1.0f;    // Find boolean properties.    Obj *indexed_dump = Hash_Fetch_Utf8(source, "indexed", 7);    Obj *stored_dump  = Hash_Fetch_Utf8(source, "stored", 6);    Obj *sort_dump    = Hash_Fetch_Utf8(source, "sortable", 8);    bool indexed  = indexed_dump ? Json_obj_to_bool(indexed_dump) : true;    bool stored   = stored_dump  ? Json_obj_to_bool(stored_dump)  : true;    bool sortable = sort_dump    ? Json_obj_to_bool(sort_dump)    : false;    return NumType_init2(loaded, boost, indexed, stored, sortable);}

FullTextType*FullTextType_Load_IMP(FullTextType *self, Obj *dump) {    UNUSED_VAR(self);    Hash *source = (Hash*)CERTIFY(dump, HASH);    String *class_name = (String*)Hash_Fetch_Utf8(source, "_class", 6);    Class *klass        = (class_name != NULL && Obj_is_a((Obj*)class_name, STRING))          ? Class_singleton(class_name, NULL)          : FULLTEXTTYPE;    FullTextType *loaded = (FullTextType*)Class_Make_Obj(klass);    // Extract boost.    Obj *boost_dump = Hash_Fetch_Utf8(source, "boost", 5);    float boost = boost_dump ? (float)Json_obj_to_f64(boost_dump) : 1.0f;    // Find boolean properties.    Obj *indexed_dump = Hash_Fetch_Utf8(source, "indexed", 7);    Obj *stored_dump  = Hash_Fetch_Utf8(source, "stored", 6);    Obj *sort_dump    = Hash_Fetch_Utf8(source, "sortable", 8);    Obj *hl_dump      = Hash_Fetch_Utf8(source, "highlightable", 13);    bool indexed  = indexed_dump ? Json_obj_to_bool(indexed_dump) : true;    bool stored   = stored_dump  ? Json_obj_to_bool(stored_dump)  : true;    bool sortable = sort_dump    ? Json_obj_to_bool(sort_dump)    : false;    bool hl       = hl_dump      ? Json_obj_to_bool(hl_dump)      : false;    // Extract an Analyzer.    Obj *analyzer_dump = Hash_Fetch_Utf8(source, "analyzer", 8);    Analyzer *analyzer = NULL;    if (analyzer_dump) {        if (Obj_is_a(analyzer_dump, ANALYZER)) {            // Schema munged the dump and installed a shared analyzer.            analyzer = (Analyzer*)INCREF(analyzer_dump);        }        else if (Obj_is_a((Obj*)analyzer_dump, HASH)) {            analyzer = (Analyzer*)Freezer_load(analyzer_dump);        }    }    CERTIFY(analyzer, ANALYZER);    FullTextType_init2(loaded, analyzer, boost, indexed, stored,                       sortable, hl);    DECREF(analyzer);    return loaded;}