コード例 #1
0
ファイル: multiplayer.c プロジェクト: BackupTheBerlios/bmc
static void process_data_from_server()
{
	/* enough data present for the length field ? */
	if (3 <= in_data_used) {
		Uint8   *pData  = in_data;
		Uint16   size;

		do { /* while (3 <= in_data_used) (enough data present for the length field) */
			static const int foo = 1; /* used for run-time byteorder check */

			/* make a copy of the length field...watch alignment/byteorder */
			if (*(char *)&foo) { /* little-endian ? */
				((Uint8 *)&size)[0] = pData[1];
				((Uint8 *)&size)[1] = pData[2];
			}
			else { /* big-endian */
				((Uint8 *)&size)[0] = pData[2];
				((Uint8 *)&size)[1] = pData[1];
			}

			if (sizeof (in_data) - 3 >= size) { /* buffer big enough ? */
				size += 2; /* add length field size */

				if (size <= in_data_used) { /* do we have a complete message ? */
					process_message_from_server(pData, size);

					if (log_conn_data)
						log_conn(pData, size);

					/* advance to next message */
					pData         += size;
					in_data_used  -= size;
				}
				else
					break;
			}
			else { /* sizeof (in_data) - 3 < size */
				log_to_console(c_red2, packet_overrun);

				log_to_console(c_red2, disconnected_from_server);
				log_to_console(c_red2, alt_x_quit);
				in_data_used = 0;
				disconnected = 1;
				// clear buddy list
				clear_buddy();
			}
		} while (3 <= in_data_used);

		/* move the remaining data to the start of the buffer...(not tested...never happened to me) */
		if (in_data_used && pData != in_data)
			memmove(in_data, pData, in_data_used);
	}
}
コード例 #2
0
ファイル: elconfig.c プロジェクト: BackupTheBerlios/bmc
void change_vertex_array(int value)
{
	use_vertex_array=(value>0);
	if(use_vertex_array)
		{
			log_to_console(c_green2,enabled_vertex_arrays);
		}
}
コード例 #3
0
ファイル: elconfig.c プロジェクト: BackupTheBerlios/bmc
void change_point_particles(int value)
{
	use_point_particles=(value>0);
	if(!use_point_particles)
		{
			log_to_console(c_green2,disabled_point_particles);
		}
}
コード例 #4
0
ファイル: elconfig.c プロジェクト: BackupTheBerlios/bmc
void change_particles_percentage(int value)
{
	if(value>0 && value <=100) particles_percentage=value;
	else
		{
			particles_percentage=0;
			log_to_console(c_green2,disabled_particles_str);
		}
}
コード例 #5
0
ファイル: elconfig.c プロジェクト: BackupTheBerlios/bmc
void switch_vidmode(int mode)
{
	if(mode>10 || mode<=0)
		{
			//warn about this error
			log_to_console(c_red2,invalid_video_mode);
			return;
		}
	else video_mode=mode;
	if(!video_mode_set) return;
	set_new_video_mode(full_screen,video_mode);
}
コード例 #6
0
ファイル: multiplayer.c プロジェクト: BackupTheBerlios/bmc
void get_message_from_server()
{
	/* data available for reading ? */
	if (!disconnected && SDLNet_CheckSockets(set, 0) && SDLNet_SocketReady(my_socket)) {
		int received;

		if (0 < (received = SDLNet_TCP_Recv(my_socket, &in_data[in_data_used], sizeof (in_data) - in_data_used))) {
			in_data_used += received;

			process_data_from_server();
		}
		else { /* 0 >= received (EOF or some error) */
			if (received)
				log_to_console(c_red2, SDLNet_GetError()); //XXX: SDL[Net]_GetError used by timer thread ? i bet its not reentrant...

			log_to_console(c_red2, disconnected_from_server);
			log_to_console(c_red2, alt_x_quit);
			in_data_used = 0;
			disconnected = 1;
			// clear buddy list
			clear_buddy();
		}
	}
}
コード例 #7
0
ファイル: actor_scripts.c プロジェクト: BackupTheBerlios/bmc
void update_all_actors()
{
	Uint8 str[40];

#ifdef EXTRA_DEBUG
	ERR();
#endif

	//we got a nasty error, log it
	log_to_console(c_red2,resync_server);

	destroy_all_actors();
	str[0]=SEND_ME_MY_ACTORS;
	my_tcp_send(my_socket,str,1);
}
コード例 #8
0
ファイル: audio.cpp プロジェクト: Sir-Irk/game_of_life
internal bool32
al_log(bool32 error, const char *message, ...)
{
    va_list argptr;
    va_start(argptr, message);
    log_to_file(AL_LOG_FILE, message, argptr);
    va_end(argptr);
    if (error)
    {
        va_start(argptr, message);
        log_to_console(AL_LOG_FILE, message, argptr);
        va_end(argptr);
    }
    return true;
}
コード例 #9
0
ファイル: multiplayer.c プロジェクト: BackupTheBerlios/bmc
void connect_to_server()
{
	IPaddress ip;
	if(this_version_is_invalid)return;
	if(set)
		{
			SDLNet_FreeSocketSet(set);
			set=0;
		}
	if(my_socket)
		{
			SDLNet_TCP_Close(my_socket);
			my_socket=0;
		}

	log_to_console(c_red1,connect_to_server_str);
	draw_scene();	// update the screen
	set=SDLNet_AllocSocketSet(1);
	if(!set)
        {
            char str[120];
            sprintf(str,"SDLNet_AllocSocketSet: %s\n", SDLNet_GetError());
            log_error(str);
			SDLNet_Quit();
			SDL_Quit();
			exit(4); //most of the time this is a major error, but do what you want.

        }

	if(SDLNet_ResolveHost(&ip,server_address,port)==-1)
		{
			log_to_console(c_red2,failed_resolve);
			return;
		}

	my_socket=SDLNet_TCP_Open(&ip);
	if(!my_socket)
		{
			//check to see if the player is a moron...
			if(server_address[0]=='1' && server_address[1]=='9' && server_address[2]=='2'
			   && server_address[3]=='.' && server_address[4]=='1' && server_address[5]=='6'
			   && server_address[6]=='8')
			  	{
			   		log_to_console(c_red1,license_check);
					log_to_console(c_red1,alt_x_quit);
				}
			else
				{
					log_to_console(c_red1,failed_connect);
					log_to_console(c_red1,reconnect_str);
					log_to_console(c_red1,alt_x_quit);
				}
            return;
		}

	if(SDLNet_TCP_AddSocket(set,my_socket)==-1)
		{
            char str[120];
            sprintf(str,"SDLNet_TCP_AddSocket: %s\n",SDLNet_GetError());
            log_error(str);
			SDLNet_Quit();
			SDL_Quit();
			exit(2);
		}
	disconnected=0;
	//ask for the opening screen
	if(!previously_logged_in)
		{
			Uint8 str[1];
			str[0]=SEND_OPENING_SCREEN;
			my_tcp_send(my_socket,str,1);
		}
	else
		{
			yourself=-1;
			you_sit=0;
			destroy_all_actors();
			send_login_info();
		}

    //send the current version to the server
    send_version_to_server(&ip);
    last_heart_beat=cur_time;
	hide_window(trade_win);
}
コード例 #10
0
ファイル: multiplayer.c プロジェクト: BackupTheBerlios/bmc
void process_message_from_server(unsigned char *in_data, int data_lenght)
{
	//see what kind of data we got
	switch (in_data[PROTOCOL])
		{
		case RAW_TEXT:
			{
				// do filtering and ignoring
				data_lenght=filter_or_ignore_text(&in_data[3],data_lenght-3)+3;
				if(data_lenght > 3)
					{
						//how to display it
						if(interface_mode!=interface_opening)
							put_text_in_buffer(&in_data[3],data_lenght-3,0);
						else put_text_in_buffer(&in_data[3],data_lenght-3,54);
						//lets log it
						write_to_log(&in_data[3],data_lenght-3);
					}
			}
			break;
		
		case SMALL_WINDOW_TEXT:
			{
				add_text_to_small_text_buffer(in_data+3, data_lenght-3);
				display_small_text_window();
			}
			break;

		case ADD_NEW_ACTOR:
			{
				add_actor_from_server(&in_data[3]);
			}
			break;

		case ADD_NEW_ENHANCED_ACTOR:
			{
				add_enhanced_actor_from_server(&in_data[3]);
			}
			break;

		case ADD_ACTOR_COMMAND:
			{
				add_command_to_actor(*((short *)(in_data+3)),in_data[5]);
			}
			break;

		case REMOVE_ACTOR:
			{
				destroy_actor(*((short *)(in_data+3)));
			}
			break;

		case KILL_ALL_ACTORS:
			{
				destroy_all_actors();
			}
			break;

		case NEW_MINUTE:
			{
				game_minute=*((short *)(in_data+3));
				new_minute();
			}
			break;

		case LOG_IN_OK:
			{
				interface_mode=interface_game;
				previously_logged_in=1;
			}
			break;

		case HERE_YOUR_STATS:
			{
				get_the_stats((Sint16 *)(in_data+3));
			}
			break;

		case SEND_PARTIAL_STAT:
			{
				get_partial_stat(*((Uint8 *)(in_data+3)),*((Sint32 *)(in_data+4)));
			}
			break;

		case GET_KNOWLEDGE_LIST:
			{
				get_knowledge_list(*(Uint16 *)(in_data+1)-1, in_data+3);
			}
			break;

		case GET_NEW_KNOWLEDGE:
			{
				get_new_knowledge(*(Uint16 *)(in_data+3));
			}
			break;

		case HERE_YOUR_INVENTORY:
			{
				get_your_items(in_data+3);
			}
			break;

		case GET_NEW_INVENTORY_ITEM:
			{
				get_new_inventory_item(in_data+3);
			}
			break;

		case REMOVE_ITEM_FROM_INVENTORY:
			{
				remove_item_from_inventory(*((Uint8 *)(in_data+3)));
			}
			break;

		case INVENTORY_ITEM_TEXT:
			{
				put_small_text_in_box(&in_data[3],data_lenght-3,6*51+100,items_string);
				if(!(get_show_window(items_win)||get_show_window(trade_win)))
					{
						put_text_in_buffer(&in_data[3],data_lenght-3,0);
					}
			}
			break;

		case GET_KNOWLEDGE_TEXT:
			{
				put_small_text_in_box(&in_data[3],data_lenght-3,6*51+150,knowledge_string);
			}
			break;

		case CHANGE_MAP:
			{
				current_sector=-1;
				if(map_file_name[0]!=0)
					save_map(map_file_name);
				object_under_mouse=-1;//to prevent a nasty crash, while looking for bags, when we change the map
				close_dialogue();	// close the dialogue window if open
				destroy_all_particles();

				if(!load_map(&in_data[4])){ // creating map if it does not exist
					int size=(in_data[3]&0x1f)<<4;
					new_map(size,size);
					dungeon=(in_data[3]&0x20)?1:0;
					strcpy(map_file_name,&in_data[4]);
					save_map(map_file_name);
				}
				kill_local_sounds();
#ifndef	NO_MUSIC
				playing_music=0;
#endif	//NO_MUSIC
				get_map_playlist();
				have_a_map=1;
				//also, stop the rain
				seconds_till_rain_starts=-1;
				seconds_till_rain_stops=-1;
				is_raining=0;
				rain_sound=0;//kill local sounds also kills the rain sound
				weather_light_offset=0;
				rain_light_offset=0;
			}
			break;

		case GET_TELEPORTERS_LIST:
			{
				add_teleporters_from_list(&in_data[3]);
			}
			break;

		case PLAY_MUSIC:
			{
				if(!no_sound)play_music(*((short *)(in_data+3)));
			}
			break;

		case PLAY_SOUND:
			{
				if(!no_sound)add_sound_object(*((short *)(in_data+3)),*((short *)(in_data+5)),*((short *)(in_data+7)),*((char *)(in_data+9)),*((short *)(in_data+10)));
			}
			break;

		case TELEPORT_OUT:
			{
				add_particle_sys_at_tile("./particles/teleport_in.part",*((short *)(in_data+3)),*((short *)(in_data+5)));
				if(!no_sound)add_sound_object(snd_tele_out,*((short *)(in_data+3)),*((short *)(in_data+5)),1,0);
			}
			break;

		case TELEPORT_IN:
			{
				add_particle_sys_at_tile("./particles/teleport_in.part",*((short *)(in_data+3)),*((short *)(in_data+5)));
				if(!no_sound)add_sound_object(snd_tele_in,*((short *)(in_data+3)),*((short *)(in_data+5)),1,0);
			}
			break;

		case LOG_IN_NOT_OK:
			{
				sprintf(log_in_error_str,"%s: %s",reg_error_str,invalid_pass);
			}
			break;

		case REDEFINE_YOUR_COLORS:
			{
				strcpy(log_in_error_str,redefine_your_colours);
			}
			break;

		case YOU_DONT_EXIST:
			{
				sprintf(log_in_error_str,"%s: %s",reg_error_str,char_dont_exist);
			}
			break;


		case CREATE_CHAR_NOT_OK:
			{
				sprintf(create_char_error_str,"%s: %s",reg_error_str,char_name_in_use);
				return;
			}
			break;


		case CREATE_CHAR_OK:
			{
				login_from_new_char();
			}
			break;

		case YOU_ARE:
			{
				yourself=*((short *)(in_data+3));
			}
			break;

		case START_RAIN:
			{
				seconds_till_rain_starts=*((Uint8 *)(in_data+3));
				seconds_till_rain_stops=-1;
			}
			break;

		case STOP_RAIN:
			{
				seconds_till_rain_stops=*((Uint8 *)(in_data+3));
				seconds_till_rain_starts=-1;
			}
			break;

		case THUNDER:
			{
				add_thunder(rand()%5,*((Uint8 *)(in_data+3)));
			}
			break;


		case SYNC_CLOCK:
			{
				server_time_stamp=*((int *)(in_data+3));
				client_time_stamp=SDL_GetTicks();
				client_server_delta_time=server_time_stamp-client_time_stamp;
			}
			break;

		case PONG:
			{
				Uint8 str[160];
				sprintf(str,"%s: %i MS",server_latency, SDL_GetTicks()-*((Uint32 *)(in_data+3)));
				log_to_console(c_green1,str);
			}
			break;

		case UPGRADE_NEW_VERSION:
			{
				log_to_console(c_red1,update_your_client);
				log_to_console(c_red1,(char*)web_update_address);
			}
			break;

		case UPGRADE_TOO_OLD:
			{
				log_to_console(c_red1,client_ver_not_supported);
				log_to_console(c_red1,(char*)web_update_address);
				this_version_is_invalid=1;
			}
			break;

		case GET_NEW_BAG:
			{
				put_bag_on_ground(*((Uint16 *)(in_data+3)),*((Uint16 *)(in_data+5)),*((Uint8 *)(in_data+7)));
			}
			break;

		case GET_BAGS_LIST:
			{
				add_bags_from_list(&in_data[3]);
			}
			break;

		case SPAWN_BAG_PARTICLES:
			{
			  add_particle_sys_at_tile("./particles/bag_in.part",*((Uint16 *)(in_data+3)),*((Uint16 *)(in_data+5)));
			}
			break;

		case GET_NEW_GROUND_ITEM:
			{
				get_bag_item(in_data+3);
			}
			break;

		case HERE_YOUR_GROUND_ITEMS:
			{
				get_bags_items_list(&in_data[3]);
			}
			break;

		case CLOSE_BAG:
			{
				hide_window(ground_items_win);
			}
			break;

		case REMOVE_ITEM_FROM_GROUND:
			{
				remove_item_from_ground(in_data[3]);
			}
			break;

		case DESTROY_BAG:
			{
				remove_bag(in_data[3]);
			}
			break;

		case NPC_TEXT:
			{
				put_small_text_in_box(&in_data[3],data_lenght-3,dialogue_menu_x_len-70,dialogue_string);
				display_dialogue();
				if(in_data[3]>=127 && in_data[4]>=127)
					{
						add_questlog(&in_data[4],data_lenght-4);
					}
			}
			break;

		case SEND_NPC_INFO:
			{
				my_strcp(npc_name,&in_data[3]);
				cur_portrait=in_data[23];
			}
			break;

		case NPC_OPTIONS_LIST:
			{
				build_response_entries(&in_data[3],*((Uint16 *)(in_data+1)));
			}
			break;

		case GET_TRADE_ACCEPT:
			{
				if(!in_data[3])trade_you_accepted=1;
				else
					trade_other_accepted=1;
			}
			break;

		case GET_TRADE_REJECT:
			{
				if(!in_data[3])trade_you_accepted=0;
				else
					trade_other_accepted=0;
			}
			break;

		case GET_TRADE_EXIT:
			{
				hide_window(trade_win);
			}
			break;

		case GET_YOUR_TRADEOBJECTS:
			{
				get_your_trade_objects(in_data+3);
			}
			break;

		case GET_TRADE_OBJECT:
			{
				put_item_on_trade(in_data+3);
			}
			break;

		case REMOVE_TRADE_OBJECT:
			{
				remove_item_from_trade(in_data+3);
			}
			break;

		case GET_TRADE_PARTNER_NAME:
			{
				get_trade_partner_name(&in_data[3],*((Uint16 *)(in_data+1))-1);
			}
			break;

		case GET_ACTOR_DAMAGE:
			{
				get_actor_damage(*((Uint16 *)(in_data+3)),in_data[5]);
			}
			break;

		case GET_ACTOR_HEAL:
			{
				get_actor_heal(*((Uint16 *)(in_data+3)),in_data[5]);
			}
			break;

		case ACTOR_UNWEAR_ITEM:
			{
				unwear_item_from_actor(*((Uint16 *)(in_data+3)),in_data[5]);
			}
			break;

		case ACTOR_WEAR_ITEM:
			{
				actor_wear_item(*((Uint16 *)(in_data+3)),in_data[5],in_data[6]);
			}
			break;

		case NPC_SAY_OVERTEXT:
			{
				add_displayed_text_to_actor(
					get_actor_ptr_from_id( *((Uint16 *)(in_data+3)) ), in_data+5 );
			}
			break;

		case BUDDY_EVENT:
			{
				if(in_data[3]==1)
					add_buddy(&in_data[5],in_data[4],data_lenght-5);
				else if(in_data[3]==0)
					del_buddy(&in_data[4],data_lenght-4);
			}
			break;

		// BARREN MOON NEW MESSAGES
		case THIS_IS_ACTIVE_SECTOR:
			active_sector=*((Uint16 *)(in_data+3));
			break;

		case GET_TILE_DATA:
			get_tile_data(in_data+3);
			break;

		case GET_3D_OBJECTS:
			get_3d_objects(in_data+3);
			break;

		case GET_2D_OBJECTS:
			get_2d_objects(in_data+3);
			break;

		case GET_LIGHT_OBJECTS:
			get_light_objects(in_data+3);
			break;

		case GET_PARTICLE_OBJECTS:
			get_particle_objects(in_data+3);
			break;

		case GET_3D_OBJECTS_FULL_ROTATION:
			get_3d_objects_full_rotation(in_data+3);
			break;

		case GET_CHECKSUMS:
		{
			actor *actor=pf_get_our_actor();
			get_checksums(in_data+3, sector_get(actor->x_pos,actor->y_pos));
			break;
		}

		case ADD_3D_OBJECT:
			add_3d_object(in_data+3);
			break;

		case ADD_3D_OBJECT_FULL_ROTATION:
			add_3d_object_fullrotation(in_data+3);
			break;

		case DELETE_3D_OBJECT:
			delete_3d_object(in_data+3);
			break;

		case REPLACE_3D_OBJECT:
			replace_3d_object(in_data+3);
			break;

		case ADD_2D_OBJECT:
			add_2d_object(in_data+3);
			break;

		case DELETE_2D_OBJECT:
			delete_2d_object(in_data+3);
			break;

		case REPLACE_2D_OBJECT:
			replace_2d_object(in_data+3);
			break;

		case ADD_LIGHT:
			add_lights(in_data+3);
			break;

		case DELETE_LIGHT:
			delete_light(in_data+3);
			break;

		case ADD_PARTICLE:
			add_particle(in_data+3);
			break;

		case DELETE_PARTICLE:
			delete_particle(in_data+3);
			break;

		case REPLACE_PARTICLE:
			replace_particle(in_data+3);
			break;

		default:
			{
				/* Unknown data type?? */;
			}
			break;
		}
}
コード例 #11
0
ファイル: Adaptors.cpp プロジェクト: AliSayed/MoSync
/**
* Example using STL adaptors
*/
void STLMoblet::STL_adaptors()
{
	LOG("\n");
	LOG("========================= STL adaptors ==========================================================================");

	LOG("/**");
	LOG("* Function object adaptors are used to create a function object from another function object."				);
	LOG("* The created function object, is not the same as the original functor, but is adapted to a certain need."	);
	LOG("* For example if we have a function object like std::less, and we want to compare all the elements"		);
	LOG("* in a range against 10, then be can use an STL adaptor (bind2nd), that bounds the second argument"		);
	LOG("* of std::less to 10. Then we can use std::less with algorithms like remove_copy_if,"						);
	LOG("* that need a unary predicate."																			);
	LOG("*"																											);
	LOG("* STL provides two functor adaptors: bind1st and bind2nd."													);
	LOG("*"																											);
	LOG("* 	bind1st: constructs an unary function object from a binary function object, by binding"					);
	LOG("* 	the first argument to a fixed value."																	);
	LOG("*"																											);
	LOG("* 	bind1st template function is defined like this:"														);
	LOG("*"																											);
	LOG("*   binder1st<SomeFunctor> bind1st (const SomeFunctor& fun, const T& fixedValue"							);
	LOG("*	{"																										);
	LOG("*		return binder1st<SomeFunctor>(fun, x);"																);
	LOG("*	}"																										);
	LOG("*"																											);
	LOG("*	bind1st returns an binder1st object, which is actually a functor that forwards the function calls"		);
	LOG("*	to the \"fun\" argument it takes as a parameter, when constructed:"										);
	LOG("*"																											);
	LOG("*	template <class Functor> class binder1st {"																);
	LOG("*"																											);
	LOG("*		binder1st(const Functor &fun, Functor::first_argument_type &fixed)"									);
	LOG("*		{"																									);
	LOG("*			mFun = fun;"																					);
	LOG("*			mFixedValue = fixed;"																			);
	LOG("*		}"																									);
	LOG("*"																											);
	LOG("*		Functor::result_type operator()(Functor::second_argument_type &someValue){"							);
	LOG("*			return mFun(mFixedValue, someValue);"															);
	LOG("*		}"																									);
	LOG("*	};"																										);
	LOG("*"																											);
	LOG("*	bind2nd is implemented in a similar way, but instead of binding the first argument,"					);
	LOG("*	bind2nd it will bind the second one to a fixed value."													);
	LOG("*"																											);
	LOG("*	bind1st and bind2nd function templates are defined in the <functional> header."							);
	LOG("*/");
	LOG("\n");

	LOG("				Example using adaptors 							  ");


	LOG("\n																				   ");
	LOG("/**"																				);
	LOG("*  bind1st function template: constructs an unary function object from a"			);
	LOG("*  binary function object, by binding the first parameter to a certain value."		);
	LOG("\n    */"																			);

	log_to_console("\n     Example using std::bind1st:\n");

	int array[] = { 1, -99, 2, -100 };
	int arraySize = sizeof(array)/sizeof(array[0]);

	std::vector<int> vec1(array, array + arraySize);
	log_to_console(vec1, "vec1 contains: ");

	LOG("\n"																		);
	LOG("/**std::remove_if calls std::less(0, element). If less(0,element) returns"	);
	LOG("*  true => removes that element."											);
	LOG("*  less(0,element) is equivalent to 0<element."							);
	LOG("*/"																		);
	LOG("\n"																		);

	TRACE(std::vector<int>::iterator newEnd = std::remove_if(vec1.begin(),
			vec1.end(), bind1st(std::less<int>(), 1)));

	log_to_console("vec1 after calling std::remove_if(vec1.begin(), vec1.end(), "
			"bind1st(std::less<int>(), 0)): ");
	for(std::vector<int>::iterator it = vec1.begin(); it != newEnd; ++it)
	{
		log_to_console(*it);
	}


	LOG("\n"															      	  );
	LOG("/**"																  	  );
	LOG("*  bind2nd function template: constructs an unary function object from a");
	LOG("*  binary function object, by binding the second parameter to a certain" );
	LOG("*  value."															 	  );
	LOG("*/"																	  );

	log_to_console("\n     Example using std::bind2nd:\n");

	std::vector<int> vec2(array, array + arraySize);
	log_to_console(vec2, "vec2 contains: ");

	LOG("\n"																	  );
	LOG("/**  std::remove_if calls std::greater(element, 0)."					  );
	LOG("*  If std::greater(element, 0) returns true => removes that element."	  );
	LOG("*  std::greater(element, 0) is equivalent to element > 0"				  );
	LOG("*/"																	  );
	LOG("\n");

	TRACE(newEnd = std::remove_if(vec2.begin(), vec2.end(),
			bind2nd(std::greater<int>(), 0)));

	log_to_console("vec2 after calling: std::remove_if(vec2.begin(), vec2.end(), "
			"bind2nd(std::greater<int>(), 0));");

	for(std::vector<int>::iterator it = vec2.begin(); it != newEnd; ++it)
	{
		log_to_console(*it);
	}
	LOG("\n");
}
コード例 #12
0
ファイル: Iterators.cpp プロジェクト: Felard/MoSync
void STLMoblet::STL_iterators()
{
	LOG("========================= STL iterators ========================================================================");

	LOG("/**");
	LOG("*  Input iterators: allow only reading elements from a sequence and moving forward, one step,");
	LOG("*  using operator++. The elements are read with operator*.");
	LOG("*  Provides also operator== and operator!=.");
	LOG("*  An input iterator implemented in STL is for example the one provided by std::istream.");
	LOG("*/");
	LOG("\n");

	LOG("/**");
	LOG("*  Output iterators: allow only writing elements from a sequence and only moving forward, one step,");
	LOG("*  using operator++. They elements are written with operator*.");
	LOG("*  Provides also operator== and operator!=.");
	LOG("*  An input iterator implemented in STL is for example the one provided by std::ostream.");
	LOG("*/");
	LOG("\n");

	LOG("/**");
	LOG("*  Forward iterators: allow reading and writing elements from a sequence. Only moving forward, one step,");
	LOG("*  using operator++ is possible. They elements are read and written with operator*.");
	LOG("*  Provides also operator== and operator!=.");
	LOG("*  An input iterator implemented in STL is for example the one provided by std::ostream.");
	LOG("*/");

	LOG("/**");
	LOG("*  Bidirectional iterators: allow reading and writing elements from a sequence. Allows moving forward and backward,");
	LOG("*  one step,using operator++/operator--. Their elements are read and written with operator*.");
	LOG("*  Provides also operator== and operator!=.");
	LOG("*  An input iterator implemented in STL is for example the ones provided by list, multiset, map, multimap.");
	LOG("*/");
	LOG("\n");

	LOG("		   Example using iterators 	     		  ");

	int sArray[] = { 0, 11, 22, 33, 44 };
	int sArraySize = sizeof(sArray)/sizeof(sArray[0]);
	std::list<int> myList(sArray, sArray + sArraySize);

	LOG("Create a list object (myList) and fill it with: 0, 11, 22, 33, 44\n");

	LOG("\n");
	LOG("/**");
	LOG("*  create an bidirectional iterator");
	LOG("*/");

	LOG("std::list<int>::iterator iter;");
	std::list<int>::iterator iter;

	iter = myList.begin();
	LOG("iter = myList.begin();");

	LOG("\n");
	LOG("/**");
	LOG("*  read operation");
	LOG("*/");

	int r = *iter;
	log_to_console(r, "int r = *iter	//r = ");

	LOG("\n");
	LOG("/**");
	LOG("*  write operation");
	LOG("*/");

	*iter = 99;
	LOG("*iter = 99; //myList will contain now: 99, 11, 22, 33, 44");

	LOG("\n");
	LOG("/**");
	LOG("*  operator++");
	LOG("*/");

	iter++;
	log_to_console(*iter, "iter++;	//*iter is now: ");


	LOG("\n");
	LOG("/**");
	LOG("*  operator--");
	LOG("*/");

    --iter;
    log_to_console(*iter, "iter--;	//*iter is now: ");

    LOG("\n");
    LOG("/**");
    LOG("*  Random access iterators: allows all operations a normal pointer does: add and subtract integral values,");
    LOG("*  move forward and backward, one or more steps, use operator[] on it, subtract one iterator from another.");
    LOG("*  It overloads operator<, operator>, operator==, operator!=.");
    LOG("*  An input iterator implemented in STL is for example the ones provided by vector, deque, string.");
    LOG("*/");
    LOG("\n");

    LOG("Create vector object (myVector) and fill with: 0, 11, 22, 33, 44");
    std::vector<int> myVector(sArray, sArray + sArraySize);	//myVector contains now: 0, 11, 22, 33, 44


	LOG("\n");
	LOG("/**");
	LOG("*  create an random iterator");
	LOG("*/");

	std::vector<int>::iterator randomAcessIter;
	randomAcessIter = myVector.begin();

	LOG("std::vector<int>::iterator randomAcessIter;");
	LOG("randomAcessIter = myVector.begin();");

	LOG("\n");
	LOG("/**");
	LOG("*  read operation");
	LOG("*/");
	r = *randomAcessIter;
	log_to_console(r, "r = *randomAcessIter;	//r = ");

	LOG("\n");
	LOG("/**");
	LOG("*  write operation");
	LOG("*/");

	*randomAcessIter = 99;
	log_to_console(myVector, "*randomAcessIter = 99;//myVector will contain now: ");

	LOG("\n");
	LOG("/**");
	LOG("*  operator++");
	LOG("*/");

	randomAcessIter++;
	log_to_console(*randomAcessIter, "randomAcessIter++; //*randomAcessIter = ");

	LOG("\n");
	LOG("/**");
	LOG("*  operator--");
	LOG("*/");

	--randomAcessIter;
	log_to_console(*randomAcessIter, "randomAcessIter--; //*randomAcessIter = ");

	LOG("\n");
	LOG("/**");
	LOG("*  move two steps forward");
	LOG("*/");
	LOG("\n");

	randomAcessIter += 2;
	log_to_console(*randomAcessIter, "randomAcessIter +=2; //*randomAcessIter = ");

	LOG("\n");
}
コード例 #13
0
ファイル: elconfig.c プロジェクト: BackupTheBerlios/bmc
int check_var(char * str, int type)
{
	int i,*p;
	char * ptr=str;
	float foo;
	for(i=0;i<our_vars.no;i++)
		{
			if(type?!strncmp(str,our_vars.var[i]->name,our_vars.var[i]->nlen):!strncmp(str,our_vars.var[i]->shortname,our_vars.var[i]->snlen))
				{
					//Allright, it's the right variable... now move ptr forward
					ptr+=type?our_vars.var[i]->nlen:our_vars.var[i]->snlen;
					while(*ptr && (*ptr==' '||*ptr=='='))ptr++;//go to the string occurence
					if(!*ptr||*ptr=='\n')return -1;//hmm, why would you do such a stupid thing?
					if(*ptr=='"')
						{
							//Accurate quoting
							char *tptr=++ptr;
							while(*tptr && *tptr!='"')
								{
									if(*tptr==0x0a||*tptr==0x0d)
										{
#ifdef ELC
											char str[200];
											snprintf(str,200,"Reached newline without an ending \" in %s",our_vars.var[i]->name);
											log_to_console(c_red2,str);
#endif
											break;
										}
									tptr++;
								}
							*tptr=0;
						}
					else
						{
							//Strip it
							char our_string[200];
							char *tptr=our_string;
							while(*ptr && *ptr!=0x0a && *ptr!=0x0d)
								{
									if(*ptr!=' ')*tptr++=*ptr++; //Strip all spaces
									else ptr++;
								}
							*tptr=0;
							ptr=our_string;
						}
					switch(our_vars.var[i]->type)
						{
							case SPECINT:
								our_vars.var[i]->func(atoi(ptr));
								return 1;
							case SPECCHAR:
								our_vars.var[i]->func(ptr);
								return 1;
							case INT:
								our_vars.var[i]->func(our_vars.var[i]->var,atoi(ptr));
								return 1;
							case SPEC:
								p=our_vars.var[i]->var;
								if(*p!=atoi(ptr))our_vars.var[i]->func();//the variable has changed
								return 1;
							case BOOL:
								p=our_vars.var[i]->var;
								if((atoi(ptr)>0)!=*p) our_vars.var[i]->func(our_vars.var[i]->var);
								return 1;
							case STRING:
								our_vars.var[i]->func(our_vars.var[i]->var,ptr,our_vars.var[i]->len);
								return 1;
							case FLOAT:
								foo=atof(ptr);
								our_vars.var[i]->func(our_vars.var[i]->var,&foo);
								return 1;
						}
				}
		}
	return -1;//no variable was found
}
コード例 #14
0
ファイル: AboutPredicates.cpp プロジェクト: Felard/MoSync
/**
* Function for illustrating predicates
*/
void STLMoblet::predicates_explained()
{
	LOG("\n");
	LOG("========================= about predicates ======================================================================");
	LOG("/**");
	LOG("* A predicate is a function that returns a boolean value based on some");
	LOG("* comparison criterion.");
	LOG("* Predicates are used usually with STL algorithms.");
	LOG("* Binary predicates - predicates that take two arguments.");
	LOG("* Unary predicates - predicates taking one argument.");
	LOG("* Usually binary predicates are used with algorithms that need to compare two");
	LOG("* elements (e.g sorting algorithms).");
	LOG("*/");
	LOG("\n");

	LOG("				Example using predicates: 						  ");

	LOG("\n    Unary predicate example...");

	int array[] = { 0, 1, 2, 3, 4};
	int sizeArray = sizeof(array)/sizeof(array[0]);
	std::vector<int> myVector(array, array + sizeArray); //fill a vector

	log_to_console(myVector, "myVector contains: ");

	LOG("/**");
	LOG("* std::countf_if algorithm: counts the number of elements that satisfy the");
	LOG("* condition we supply (e.g isEven, isNegative)");
	LOG("*/");

	log_to_console("Calling: std::count_if(myVector.begin(), myVector.end(), "
			"isEven);");

	int res = std::count_if(myVector.begin(), myVector.end(),
			NumericUtilities::isEven);	//returns the how many numbers are even

	log_to_console(res, "int res = std::count_if(myVector.begin(), myVector.end(), "
			"isEven); //res =  ");

	log_to_console("\n    Binary predicate example...");

	Employee staff[] = { 	Employee(3, "Jonny"),
							Employee(2, "Bob"),
							Employee(20, "Filomela")};

	int staffSize = sizeof(staff)/sizeof(staff[0]);

	std::vector<Employee> myStaff( staff, staff + staffSize);
	log_to_console(myStaff, "myStaff contains: ");

	LOG("\n");
	LOG("/**");
	LOG("* std::sort algorithm: sorts the elements, from a range, into ascending");
	LOG("* order");
	LOG("* lessExperience - a binary predicate for comparing employees");
	LOG("*/");
	LOG("\n");

	TRACE(std::sort(myStaff.begin(), myStaff.end(), lessExperiencePredicate));;

	log_to_console(myStaff, "myStaff contains now: ");

	LOG("\n");
}