Esempio n. 1
0
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);
}
Esempio n. 3
0
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);
         */

    }
Esempio n. 6
0
//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);
}
Esempio n. 8
0
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);
}
Esempio n. 10
0
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;
}
Esempio n. 11
0
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));



}
Esempio n. 12
0
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);
}
Esempio n. 14
0
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;
}
Esempio n. 15
0
static HRESULT invoke_constructor(FunctionInstance *function, LCID lcid, DISPPARAMS *dp,
        VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
{
    DispatchEx *this_obj;
    HRESULT hres;

    hres = create_object(function->dispex.ctx, &function->dispex, &this_obj);
    if(FAILED(hres))
        return hres;

    hres = invoke_source(function, (IDispatch*)_IDispatchEx_(this_obj), lcid, dp, retv, ei, caller);
    jsdisp_release(this_obj);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_DISPATCH;
    V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(this_obj);
    return S_OK;
}
Esempio n. 16
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);
}
Esempio n. 17
0
bool spec_auth( CHAR_DATA * ch )
{
   CHAR_DATA *victim;
   CHAR_DATA *v_next;
   char buf[MAX_STRING_LENGTH];
   OBJ_INDEX_DATA *pObjIndex;
   OBJ_DATA *obj;
   bool hasdiploma;

   for( victim = ch->in_room->first_person; victim; victim = v_next )
   {
      v_next = victim->next_in_room;

      if( !IS_NPC( victim ) && ( pObjIndex = get_obj_index( OBJ_VNUM_SCHOOL_DIPLOMA ) ) != NULL )
      {
         hasdiploma = FALSE;

         for( obj = victim->last_carrying; obj; obj = obj->prev_content )
            if( obj->pIndexData == get_obj_index( OBJ_VNUM_SCHOOL_DIPLOMA ) )
               hasdiploma = TRUE;

         if( !hasdiploma )
         {
            obj = create_object( pObjIndex, 1 );
            obj = obj_to_char( obj, victim );
            send_to_char( "&cThe schoolmaster gives you a diploma, and shakes your hand.\r\n&w", victim );
         }
      }

      if( IS_NPC( victim ) || !IS_SET( victim->pcdata->flags, PCFLAG_UNAUTHED ) )
         continue;

      victim->pcdata->auth_state = 3;
      REMOVE_BIT( victim->pcdata->flags, PCFLAG_UNAUTHED );
      if( victim->pcdata->authed_by )
         STRFREE( victim->pcdata->authed_by );
      victim->pcdata->authed_by = QUICKLINK( ch->name );
      sprintf( buf, "%s authorized %s", ch->name, victim->name );
      to_channel( buf, CHANNEL_MONITOR, "Monitor", ch->top_level );
   }
   return FALSE;
}
Esempio n. 18
0
void do_bank_open(Character *ch, char *argument)
{
    OBJ_DATA *obj;
    if ( ( obj = get_obj_carry( ch, (char*)"bank note", ch ) ) != NULL )
    {
	send_to_char( "You already own a bank note.\n\r", ch );
	return;
    }

    if (ch->gold < 10)
    {
	send_to_char("It costs 10 gold to open an account.\n\r", ch);
	return;
    }

    ch->gold -= 10;
    obj_to_char(create_object(get_obj_index(OBJ_VNUM_BANK_NOTE),0),ch);
    send_to_char("Enjoy your bank note.\n\r", ch);
    return;
}
Esempio n. 19
0
 * load_quest_object : This takes a pointer to OBJ_INDEX_DATA and places the
 * object onto the target.
 */

OBJ_DATA *load_quest_object( CHAR_DATA *target )
{
   OBJ_INDEX_DATA *pObj;
   OBJ_DATA *object;
   int foo;
   
   foo = number_range( OBJ_VNUM_QUEST_MIN, OBJ_VNUM_QUEST_MAX );
   
   pObj = get_obj_index( foo );
   
   if ( pObj == NULL )
   {
      bug( "load_quest_object : Invalid object vnum %d.", foo );
      return NULL;
   }
      
   object = create_object( pObj, 1 );
   obj_to_char( object, target );
   
   return object;
}
Esempio n. 20
0
static void test_indent()
{
    json_t *object;
    json_t *array;
    char *result;

    object = create_object();
    array = create_array();

    result = json_dumps(object, JSON_INDENT(4));
    if(strcmp(result, INDENTED_OBJECT) != 0)
        fail("unexpected encoded object");
    free(result);

    result = json_dumps(array, JSON_INDENT(4));
    if(strcmp(result, INDENTED_ARRAY) != 0)
        fail("unexpected encoded array");
    free(result);

    json_decref(object);
    json_decref(array);
}
Esempio n. 21
0
/* retrieve the clipboard info for the current process, allocating it if needed */
static struct clipboard *get_process_clipboard(void)
{
	NTSTATUS status;
	struct clipboard *clipboard;
	struct winstation *winstation = get_process_winstation(get_current_w32process(), WINSTA_ACCESSCLIPBOARD);

	if (!winstation) {
		ktrace("get_process_winstation return NULL!\n");
		return NULL;
	}

	if (!(clipboard = winstation->clipboard)) {
		status = create_object(KernelMode,
				clipboard_object_type,
				NULL /* obj_attr*/,
				KernelMode,
				NULL,
				sizeof(struct clipboard),
				0,
				0,
				(PVOID *)&clipboard);

		if (NT_SUCCESS(status) && clipboard) {
			INIT_DISP_HEADER(&clipboard->obj.header, CLIPBOARD,
					sizeof(struct clipboard) / sizeof(ULONG), 0);
			BODY_TO_HEADER(&(clipboard->obj))->ops = &clipboard_ops;
			clipboard->open_thread = NULL;
			clipboard->open_win = 0;
			clipboard->owner_thread = NULL;
			clipboard->owner_win = 0;
			clipboard->viewer = 0;
			clipboard->seqno = 0;
			clipboard->seqno_timestamp = 0;
			winstation->clipboard = clipboard;
		}
	}
	release_object(winstation);
	return clipboard;
}
Esempio n. 22
0
int StringHash::Find(const String & string,  void *(*create_object)())
{
    unsigned int key = getKey(string);
    unsigned int h   = Iterate(key, string);

    if (strings[h] == NULL && create_object == NULL)
        return -1;

    if (strings[h] == NULL && create_object != NULL)
    {
        Insert(h, key, string);
        objects[h] = create_object();

        if (count * 2 > size)
        {
            Grow();
            return Iterate(key, string);
        }
    }

    return h;
}
Esempio n. 23
0
struct Thing *create_thing(struct Coord3d *pos, unsigned short tngclass, unsigned short model, unsigned short owner, long parent_idx)
{
    struct Thing *thing;
    //return _DK_create_thing(pos, tngclass, model, owner, a4);
    thing = INVALID_THING;
    switch (tngclass)
    {
    case TCls_Object:
        thing = create_object(pos, model, owner, parent_idx);
        break;
    case TCls_Shot:
        thing = create_shot(pos, model, owner);
        break;
    case TCls_EffectElem:
        thing = create_effect_element(pos, model, owner);
        break;
    case TCls_DeadCreature:
        thing = create_dead_creature(pos, model, 1, owner, 0);
        break;
    case TCls_Creature:
        thing = create_creature(pos, model, owner);
        break;
    case TCls_Effect:
        thing = create_effect(pos, model, owner);
        break;
    case TCls_Trap:
        thing = create_trap(pos, model, owner);
        break;
    case TCls_AmbientSnd:
        thing = create_ambient_sound(pos, model, owner);
        break;
    case TCls_CaveIn:
        thing = create_cave_in(pos, model, owner);
        break;
    default:
        break;
    }
    return thing;
}
Esempio n. 24
0
static void test_compact()
{
    json_t *object;
    json_t *array;
    char *result;

    object = create_object();
    array = create_array();

    result = json_dumps(object, JSON_COMPACT);
    if(strcmp(result, COMPACT_OBJECT) != 0)
        fail("unexpected encoded object");
    free(result);

    result = json_dumps(array, JSON_COMPACT);
    if(strcmp(result, COMPACT_ARRAY) != 0)
        fail("unexpected encoded array");
    free(result);

    json_decref(object);
    json_decref(array);
}
Esempio n. 25
0
static void test_normal()
{
    json_t *object;
    json_t *array;
    char *result;

    object = create_object();
    array = create_array();

    result = json_dumps(object, 0);
    if(strcmp(result, NORMAL_OBJECT) != 0)
        fail("unexpected encoded object");
    free(result);

    result = json_dumps(array, 0);
    if(strcmp(result, NORMAL_ARRAY) != 0)
        fail("unexpected encoded array");
    free(result);

    json_decref(object);
    json_decref(array);
}
Esempio n. 26
0
static struct ioctl_call *create_ioctl(struct device *device, ioctl_code_t code,
							const void *in_data, data_size_t in_size,
							data_size_t out_size)
{
	struct ioctl_call *ioctl;
	NTSTATUS status;

	status = create_object(KernelMode,
			ioctl_call_object_type,
			NULL /* obj_attr*/,
			KernelMode,
			NULL,
			sizeof(struct ioctl_call),
			0,
			0,
			(PVOID *)&ioctl);

	if (NT_SUCCESS(status) && ioctl) {
		INIT_DISP_HEADER(&ioctl->obj.header, IOCTL_CALL,
				sizeof(struct ioctl_call) / sizeof(ULONG), 0);
		BODY_TO_HEADER(&ioctl->obj)->ops = &ioctl_call_ops;
		ioctl->device   = (struct device *)grab_object(device);
		ioctl->code     = code;
		ioctl->async    = NULL;
		ioctl->status   = STATUS_PENDING;
		ioctl->in_size  = in_size;
		ioctl->in_data  = NULL;
		ioctl->out_size = out_size;
		ioctl->out_data = NULL;

		if (ioctl->in_size && !(ioctl->in_data = memdup(in_data, in_size))) {
			release_object(ioctl);
			ioctl = NULL;
		}
	}
	return ioctl;
}
Esempio n. 27
0
HRESULT create_source_function(script_ctx_t *ctx, bytecode_t *code, function_code_t *func_code,
        scope_chain_t *scope_chain, jsdisp_t **ret)
{
    FunctionInstance *function;
    jsdisp_t *prototype;
    HRESULT hres;

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

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

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

    bytecode_addref(code);
    function->code = code;
    function->func_code = func_code;
    function->length = function->func_code->param_cnt;

    *ret = &function->dispex;
    return S_OK;
}
Esempio n. 28
0
void newshape(){
	if(objectarray.size == 500)
		printf("Buffer full\n");
	printf("%i\n", objectarray.size);
	GLfloat scale = randglfloat(0.5, 6.0);
	GLfloat tempvert[] = {0.0f,0.0f,
				    0.0f,scale,
				    scale,scale,
				    scale,0.0f};
					
	int i;
	GLfloat tempcolor[16];
	for(i=0;i<4;i++){
		tempcolor[i]=tempcolor[i+4]=tempcolor[i+8]=tempcolor[i+12]=randglfloat(0.0, 1.0);
	}
					   
	GLubyte tempelems[]={0,1,2,3};
	
	create_object(sizeof(tempvert), sizeof(tempcolor), sizeof(tempelems), tempvert, tempcolor, tempelems, objectarray.array[objectarray.size], 1);
	objectarray.array[objectarray.size].speed = 1.0/scale;
	objectarray.array[objectarray.size].scale = scale;
	printf("%f\n", 1.0/scale);
	objectarray.size++;
}
Esempio n. 29
0
static struct device_manager *create_device_manager(void)
{
	struct device_manager *manager;
	NTSTATUS status;

	status = create_object(KernelMode,
			device_manager_object_type,
			NULL /* obj_attr*/,
			KernelMode,
			NULL,
			sizeof(struct device_manager),
			0,
			0,
			(PVOID *)&manager);

	if (NT_SUCCESS(status) && manager) {
		INIT_DISP_HEADER(&manager->obj.header, DEVICE_MANAGER,
				sizeof(struct ioctl_call) / sizeof(ULONG), 0);
		BODY_TO_HEADER(&manager->obj)->ops = &device_manager_ops;
		INIT_LIST_HEAD(&manager->devices);
		INIT_LIST_HEAD(&manager->requests);
	}
	return manager;
}
Esempio n. 30
0
static Variant f_hphp_get_iterator(VRefParam iterable, bool isMutable) {
  if (iterable.isArray()) {
    if (isMutable) {
      return create_object(s_MutableArrayIterator,
                           CREATE_VECTOR1(ref(iterable)));
    }
    return create_object(s_ArrayIterator,
                         CREATE_VECTOR1(iterable));
  }
  if (iterable.isObject()) {
    ObjectData *obj = iterable.getObjectData();
    Variant iterator;
    while (obj->instanceof(SystemLib::s_IteratorAggregateClass)) {
      iterator = obj->o_invoke(s_getIterator, Array());
      if (!iterator.isObject()) break;
      obj = iterator.getObjectData();
    }
    VM::Class*ctx = g_vmContext->getContextClass();
    CStrRef context = ctx ? ctx->nameRef() : empty_string;
    if (isMutable) {
      if (obj->instanceof(SystemLib::s_IteratorClass)) {
        throw FatalErrorException("An iterator cannot be used for "
                                  "iteration by reference");
      }
      Array properties = obj->o_toIterArray(context, true);
      return create_object(s_MutableArrayIterator,
                           CREATE_VECTOR1(ref(properties)));
    } else {
      if (obj->instanceof(SystemLib::s_IteratorClass)) {
        return obj;
      }
      return create_object(s_ArrayIterator,
                           CREATE_VECTOR1(obj->o_toIterArray(context)));
    }
  }
  raise_warning("Invalid argument supplied for iteration");
  if (isMutable) {
    return create_object(s_MutableArrayIterator,
                         CREATE_VECTOR1(Array::Create()));
  }
  return create_object(s_ArrayIterator,
                       CREATE_VECTOR1(Array::Create()));
}