C++ create_object函数代码示例

void ThriftBuffer::read(char *data, int len) {
    int avail = m_pEnd - m_p;

    // still enough
    if (avail >= len) {
        if (data) memcpy(data, m_p, len);
        if ((m_p += len) > m_pSafe) m_safe = false;
        return;
    }

    if (data) memcpy(data, m_p, avail);
    len -= avail;
    data += avail;

    Array args(CREATE_VECTOR1(BUFFER_SIZE));
    while (true) {
        String ret = m_xin->o_invoke("read", args, -1).toString();
        if (ret.empty()) {
            Object e = create_object("TProtocolException",
                                     CREATE_VECTOR2("unable to read enough bytes",
                                                    INVALID_DATA));
            throw e;
        }

        const char *rdata = ret.data();
        int rsize = ret.size();

        if (rsize >= len) {
            if (data) memcpy(data, rdata, len);
            rsize -= len;
            if (rsize) {
                memcpy(m_buf, rdata + len, rsize);
                m_pEnd = m_buf + rsize;
            } else {
                m_pEnd = m_buf;
            }
            m_pSafe = m_pEnd - sizeof(int64) - 1;
            m_p = m_buf;
            if (m_p > m_pSafe) m_safe = false;
            return; // done
        }

        if (data) memcpy(data, rdata, rsize);
        len -= rsize;
        data += rsize;
    }
}

static void
test_send_objects_async (ETestServerFixture *fixture,
                        gconstpointer user_data)
{
	ECalClient *cal_client;
	icalcomponent *icalcomp;

	cal_client = E_TEST_SERVER_UTILS_SERVICE (fixture, ECalClient);

	icalcomp = create_object ();
	g_assert (icalcomp);

	e_cal_client_send_objects (cal_client, icalcomp, NULL, async_send_result_ready, fixture->loop);
	icalcomponent_free (icalcomp);

	g_main_loop_run (fixture->loop);
}

HRESULT create_activex_constr(script_ctx_t *ctx, jsdisp_t **ret)
{
    jsdisp_t *prototype;
    HRESULT hres;

    static const WCHAR ActiveXObjectW[] = {'A','c','t','i','v','e','X','O','b','j','e','c','t',0};

    hres = create_object(ctx, NULL, &prototype);
    if(FAILED(hres))
        return hres;

    hres = create_builtin_function(ctx, ActiveXObject_value, ActiveXObjectW, NULL,
            PROPF_CONSTR|1, prototype, ret);

    jsdisp_release(prototype);
    return hres;
}

std::array<processed_object, 4> mock_processed_object_factory::
make_generalization_inside_large_package(
    unsigned int n, const std::string& st)  {
    std::array<processed_object, 4> r = {{
            make_large_package(n),
            make_class(++n, st),
            make_class(++n, st),
            create_object(object_types::uml_generalization, ++n)
        }};

    r[3].connection(std::make_pair(r[1].id(), r[2].id()));

    r[1].child_node_id(r[0].id());
    r[2].child_node_id(r[0].id());
    r[3].child_node_id(r[0].id());
    return r;
}

    static Variant HHVM_METHOD(MongoCollection, insert, Variant a, Array options) {
        mongoc_collection_t *collection;
        bson_t doc;
        bson_error_t error;

        collection = get_collection(this_);

        Array& doc_array = a.toArrRef();
        if (!doc_array.exists(String("_id"))) {
            const StaticString s_MongoId("MongoId");
            char id[25];
            bson_oid_t oid;
            bson_oid_init(&oid, NULL);
            bson_oid_to_string(&oid, id);
            ObjectData * data = create_object(&s_MongoId, make_packed_array(String(id)));
            doc_array.add(String("_id"), data);
        }
        encodeToBSON(doc_array, &doc);




        int w_flag = MONGOC_WRITE_CONCERN_W_DEFAULT;
        //如果传递了参数
        
        mongoc_write_concern_t *write_concern;
        write_concern = mongoc_write_concern_new();
        mongoc_write_concern_set_w(write_concern, w_flag);
        
        bool ret = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &doc, write_concern, &error);
        if (!ret) {
            mongoThrow<MongoCursorException>((const char *) error.message);
        }
        mongoc_collection_destroy(collection);
        bson_destroy(&doc);
        return ret;
        /*
        bool mongoc_collection_insert (mongoc_collection_t           *collection,
                                      mongoc_insert_flags_t          flags,
                                      const bson_t                  *document,
                                      const mongoc_write_concern_t  *write_concern,
                                      bson_error_t                  *error);
         */

    }

//na przyklad jak cialko sie robi, to calkiem z listy wywala
//ownera ale zostaje na mudzie artef. count sie nie zmienia
void all_artefact_from_char( CHAR_DATA *ch )
{
	ARTEFACT_DATA * atmp = NULL;
	ARTEFACT_OWNER *otmp, *prev = NULL;
	OBJ_DATA *obj = NULL;

	for ( atmp = artefact_system;atmp;atmp = atmp->next )
	{
		otmp = atmp->first_owner;
		for ( ;otmp; )
		{
			if ( !strcmp( ch->name, otmp->owner ) )
			{
				if ( prev != NULL )
					prev->next = otmp->next;
				else
					atmp->first_owner = otmp->next;

				obj = create_object( get_obj_index( atmp->avnum ), FALSE );
				wiznet( "$N STRACIL(a) artefact : $p.", ch, obj, WIZ_ARTEFACT, 0, get_trust( ch ) );

				append_file_format_daily( ch, ARTEFACT_LOG_FILE, "-> STRACIL (zgon):%s vnum:%d count:%d max: %d (move)", obj->short_descr, atmp->avnum, atmp->count, atmp->max_count );

				extract_obj( obj );

				otmp->next = NULL;
				free_artefact_owner( otmp );

				//nastepny element
				if ( prev != NULL )
					otmp = prev->next;
				else
					otmp = atmp->first_owner;


			}
			else //to nie ten
			{
				prev = otmp;
				otmp = otmp->next;
			}
		}
	}

}

static void
test_send_objects_sync (ETestServerFixture *fixture,
                        gconstpointer user_data)
{
	ECalClient *cal_client;
	GError *error = NULL;
	icalcomponent *icalcomp, *modified_icalcomp = NULL;
	GSList *users = NULL;

	cal_client = E_TEST_SERVER_UTILS_SERVICE (fixture, ECalClient);

	icalcomp = create_object ();
	if (!e_cal_client_send_objects_sync (cal_client, icalcomp, &users, &modified_icalcomp, NULL, &error))
		g_error ("send objects sync: %s", error->message);

	icalcomponent_free (icalcomp);
	manage_result (users, modified_icalcomp);
}

static bool
cbson_loads_visit_dbpointer (const bson_iter_t *iter,
                             const char        *key,
                             size_t             v_collection_len,
                             const char        *v_collection,
                             const bson_oid_t  *v_oid,
                             void              *output)
{
  char id[25];
  bson_oid_to_string(v_oid, id);
  ObjectData * data = create_object(&s_MongoDBRef,
    make_packed_array(
      String(v_collection, v_collection_len, CopyString),
      String(id)));
  ((Array *)output)->add(String(key), data);
  return false;
  //TODO: Finish this
}

static void
test_remove_object_sync (ETestServerFixture *fixture,
                         gconstpointer user_data)
{
	ECalClient *cal_client;
	GError *error = NULL;
	gchar *uid;

	cal_client = E_TEST_SERVER_UTILS_SERVICE (fixture, ECalClient);

	uid = create_object (cal_client);
	g_assert (uid != NULL);

	if (!e_cal_client_remove_object_sync (cal_client, uid, NULL, E_CAL_OBJ_MOD_ALL, NULL, &error))
		g_error ("remove object sync: %s", error->message);

	g_free (uid);
}

HRESULT create_source_function(parser_ctx_t *ctx, parameter_t *parameters, source_elements_t *source,
        scope_chain_t *scope_chain, const WCHAR *src_str, DWORD src_len, DispatchEx **ret)
{
    FunctionInstance *function;
    DispatchEx *prototype;
    parameter_t *iter;
    DWORD length = 0;
    HRESULT hres;

    hres = create_object(ctx->script, NULL, &prototype);
    if(FAILED(hres))
        return hres;

    hres = create_function(ctx->script, NULL, PROPF_CONSTR, FALSE, NULL, &function);
    if(SUCCEEDED(hres)) {
        hres = set_prototype(ctx->script, &function->dispex, prototype);
        if(FAILED(hres))
            jsdisp_release(&function->dispex);
    }
    jsdisp_release(prototype);
    if(FAILED(hres))
        return hres;

    function->source = source;
    function->parameters = parameters;

    if(scope_chain) {
        scope_addref(scope_chain);
        function->scope_chain = scope_chain;
    }

    parser_addref(ctx);
    function->parser = ctx;

    for(iter = parameters; iter; iter = iter->next)
        length++;
    function->length = length;

    function->src_str = src_str;
    function->src_len = src_len;

    *ret = &function->dispex;
    return S_OK;
}

void init_player(void){


    ski_player.actor = create_object(OBJ_TYPE_PLAYER);
	ski_player.actor->x = SCREEN_CENTER_W;



	/*
	load texture  for ski player  (sprite sheets)
	*/
	object_set_texture(&ski_player.actor, player_assets[0]);


	/*
	debug mode render sa borders in the texture
	*/

#ifdef DEBUG_MODE
		texture_set_flags(ski_player.actor->sprite, TEXTURE_SHOW_BORDER);
#endif
	
	/*
	if (DEBUG_MODE) {
		ski_player.actor->sprite->debug_texture = TEXTURE_SHOW_BORDER;
	}
	else {
		ski_player.actor->sprite->debug_texture = TEXTURE_NO_DEBUG;
	}
	*/
	

    ski_player.lives = 3;
    ski_player.health= 100;
    ski_player.player_movement_state = STATE_PLAYER_STATE_STOPPED;
    ski_player.actor->delay = 0;
    ski_player.key_active = 1;

    if(ski_player.actor->sprite->spritesheet != NULL)   al_convert_mask_to_alpha(  ski_player.actor->sprite->spritesheet, al_map_rgb(255,0,255));



}

int git_repository_newobject(git_object **object_out, git_repository *repo, git_otype type)
{
	git_object *object = NULL;
	int error;

	assert(object_out && repo);

	if ((error = create_object(&object, type)) < GIT_SUCCESS)
		return error;

	object->repo = repo;
	object->in_memory = 1;
	object->modified = 1;

	object->source.raw.type = type;

	*object_out = object;
	return GIT_SUCCESS;
}

static gboolean
test_sync (ECalClient *cal_client)
{
	GError *error = NULL;
	icalcomponent *icalcomp, *modified_icalcomp = NULL;
	GSList *users = NULL;

	icalcomp = create_object ();

	if (!e_cal_client_send_objects_sync (cal_client, icalcomp, &users, &modified_icalcomp, NULL, &error)) {
		report_error ("send objects sync", &error);
		icalcomponent_free (icalcomp);
		return FALSE;
	}

	icalcomponent_free (icalcomp);

	return manage_result (users, modified_icalcomp);
}

int main()
{
 double c, d ;
  int errcode ;
  struct SomeObject *objptr ;

  c = calculate_something(42, 98.6) ;
  if ((errcode = error_code()) != 0) {
    /* fprintf(stderr, "error calculating something: %d\n", errcode); */
    return 1;
  }

  objptr = create_object("my object") ;
  d = calculate_something_else(c, objptr) ;
  free_object(objptr) ;

  /* fprintf(stdout, "calculated %f\n", d); */
  return 0;
}

void handle_waterwheel_destruction(OBJ_DATA & obj)
{
    // Verify a room
    ROOM_INDEX_DATA * room(get_room_for_obj(obj));
    if (room == NULL)
        return;

    // Load up the remains and transfer the contents
    OBJ_DATA * remains(create_object(get_obj_index(OBJ_VNUM_WATERWHEEL_REMAINS), 0));
    remains->level = obj.level;

    for (OBJ_DATA * item(obj.contains); item != NULL; item = obj.contains)
    {
        obj_from_obj(item);
        obj_to_obj(item, remains);
    }

    obj_to_room(remains, room);
}