C++ ArrayList_GetItem函數代碼示例

static rdpChannels* freerdp_channels_find_by_instance(freerdp* instance)
{
	int index;
	BOOL found = FALSE;
	rdpChannels* channels = NULL;

	ArrayList_Lock(g_ChannelsList);

	index = 0;
	channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, index++);

	while (channels)
	{
		if (channels->instance == instance)
		{
			found = TRUE;
			break;
		}

		channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, index++);
	}

	ArrayList_Unlock(g_ChannelsList);

	return (found) ? channels : NULL;
}

IWTSVirtualChannel *dvcman_find_channel_by_id(IWTSVirtualChannelManager *pChannelMgr, UINT32 ChannelId)
{
	int index;
	BOOL found = FALSE;
	DVCMAN_CHANNEL *channel;
	DVCMAN *dvcman = (DVCMAN *) pChannelMgr;
	assert(dvcman);
	ArrayList_Lock(dvcman->channels);
	index = 0;
	channel = (DVCMAN_CHANNEL *) ArrayList_GetItem(dvcman->channels, index++);

	while (channel)
	{
		if (channel->channel_id == ChannelId)
		{
			found = TRUE;
			break;
		}

		channel = (DVCMAN_CHANNEL *) ArrayList_GetItem(dvcman->channels, index++);
	}

	ArrayList_Unlock(dvcman->channels);
	return (found) ? ((IWTSVirtualChannel *) channel) : NULL;
}

int SortedLimitedList_AddItem (SortedLimitedList* self, void* value)
{
	int pos = ArrayList_Count(&self->base);
	while (pos > 0 && self->comparator.compareTo(&self->comparator, ArrayList_GetItem(&self->base, pos-1), value) >= 0) {
		if (pos < self->max) {
			if (pos==self->max-1) {
				if (ArrayList_Count(&self->base) == self->max) {
					if (self->deletefn) {
						self->deletefn(ArrayList_GetItem(&self->base, pos));
					}
				}
			}
			SortedLimitedList_SetItem(self, pos, ArrayList_GetItem(&self->base, pos-1));
		}
		pos --;
	}
	
	if (pos < self->max) {
		if (pos==self->max-1) {
			if (ArrayList_Count(&self->base) == self->max) {
				if (self->deletefn) {
					self->deletefn(ArrayList_GetItem(&self->base, pos));
				}
			}
		}
	        SortedLimitedList_SetItem(self, pos, value);
	} else {
		if (self->deletefn) {
			self->deletefn(value);
		}
		pos = -1;
	}
	
	return pos;
}

int main (int argc, char* argv[])
{
	ArrayList* al = ArrayList_new0 (FilterPoint_delete);
	Random* rnd = Random_new0 ();

	int n;
	for (n = 0 ; n < 10 ; ++n) {
		FilterPoint* p = FilterPoint_new0 ();
	
		p->x = Random_NextDouble(rnd) * 400.0;
		p->y = Random_NextDouble(rnd) * 400.0;
	
		ArrayList_AddItem(al, p);
	}
	int i;
	for(i=0; i<ArrayList_Count(al); i++) {
		FilterPoint* p = ArrayList_GetItem(al, i);
		WriteLine ("%f %f # GNUPLOT1", p->x, p->y);
	}

	AreaFilter* conv = AreaFilter_new0 ();
	ArrayList* hull = AreaFilter_CreateConvexHull(conv, al);
	
	WriteLine ("\nhull: %d elements", ArrayList_Count(hull));
	int j;
	for(j=0; j<ArrayList_Count(hull); j++) {
		FilterPoint* p = ArrayList_GetItem(hull, j);
		WriteLine ("%f %f # GNUPLOT2", p->x, p->y);
	}
	
	WriteLine ("\npolygon area: %f", AreaFilter_PolygonArea(conv, hull));
	ArrayList_delete(al);
	return 0;
}

ArrayList* MatchKeys_FilterJoins (ArrayList* matches)
{
	HashTable* ht = HashTable_new0 (NULL, NULL);
	
	// Count the references to each keypoint
	int i;
	for(i=0; i<ArrayList_Count(matches); i++) {
		Match* m = (Match*) ArrayList_GetItem(matches, i);
		int lI = (HashTable_GetItem(ht, m->kp1) == NULL) ? 0 : (int) HashTable_GetItem(ht, m->kp1);
		HashTable_SetItem(ht, m->kp1, (void*)(lI + 1));
		int rI = (HashTable_GetItem(ht, m->kp2) == NULL) ? 0 : (int) HashTable_GetItem(ht, m->kp2);
		HashTable_SetItem(ht, m->kp2, (void*)(rI + 1));
	}

	ArrayList* survivors = ArrayList_new0(NULL);
	int removed = 0;
	int j;
	for(j=0; j<ArrayList_Count(matches); j++) {
		Match* m = (Match*) ArrayList_GetItem(matches, j);
		//WriteLine ("match: %d, %d", (int) HashTable_GetItem(ht, m->kp1), (int) HashTable_GetItem(ht, m->kp2));
		
		if (((int) HashTable_GetItem(ht, m->kp1)) <= 1 && ((int) HashTable_GetItem(ht, m->kp2)) <= 1)
			ArrayList_AddItem(survivors, m);
		else
			removed += 1;
	}
	
	HashTable_delete(ht);

	return (survivors);
}

static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* pindex)
{
	int i, j;
	BOOL found = FALSE;
	rdpChannels* channels = NULL;

	ArrayList_Lock(g_ChannelsList);

	i = j = 0;
	channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, i++);

	while (channels)
	{
		for (j = 0; j < channels->channelDataCount; j++)
		{
			if (channels->channelDataList[j].open_handle == open_handle)
			{
				*pindex = j;
				found = TRUE;
				break;
			}
		}

		if (found)
			break;

		channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, i++);
	}

	ArrayList_Unlock(g_ChannelsList);

	return (found) ? channels : NULL;
}

static rdpSvcPlugin* svc_plugin_find_by_open_handle(UINT32 open_handle)
{
	int index;
	BOOL found = FALSE;
	rdpSvcPlugin* plugin;

	ArrayList_Lock(g_AddinList);

	index = 0;
	plugin = (rdpSvcPlugin*) ArrayList_GetItem(g_AddinList, index++);

	while (plugin)
	{
		if (plugin->open_handle == open_handle)
		{
			found = TRUE;
			break;
		}

		plugin = (rdpSvcPlugin*) ArrayList_GetItem(g_AddinList, index++);
	}

	ArrayList_Unlock(g_AddinList);

	return (found) ? plugin : NULL;
}

VOID WINAPI FreeRDP_WTSCloseServer(HANDLE hServer)
{
	int index;
	int count;
	rdpPeerChannel* channel;
	WTSVirtualChannelManager* vcm;
	vcm = (WTSVirtualChannelManager*) hServer;

	if (vcm)
	{
		HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR) vcm->SessionId);
		ArrayList_Lock(vcm->dynamicVirtualChannels);
		count = ArrayList_Count(vcm->dynamicVirtualChannels);

		for (index = 0; index < count; index++)
		{
			channel = (rdpPeerChannel*) ArrayList_GetItem(vcm->dynamicVirtualChannels,
			          index);
			WTSVirtualChannelClose(channel);
		}

		ArrayList_Unlock(vcm->dynamicVirtualChannels);
		ArrayList_Free(vcm->dynamicVirtualChannels);

		if (vcm->drdynvc_channel)
		{
			WTSVirtualChannelClose(vcm->drdynvc_channel);
			vcm->drdynvc_channel = NULL;
		}

		MessageQueue_Free(vcm->queue);
		free(vcm);
	}
}

static void _Publish(rdpShadowMultiClientEvent* event)
{
	wArrayList* subscribers;
	struct rdp_shadow_multiclient_subscriber* subscriber = NULL;
	int i;

	subscribers = event->subscribers;

	assert(event->consuming == 0);

	/* Count subscribing clients */
	ArrayList_Lock(subscribers);
	for (i = 0; i < ArrayList_Count(subscribers); i++)
	{
		subscriber = (struct rdp_shadow_multiclient_subscriber *)ArrayList_GetItem(subscribers, i);
		/* Set flag to subscriber: I acknowledge and please handle */
		subscriber->pleaseHandle = TRUE;
		event->consuming++;
	}
	ArrayList_Unlock(subscribers);

	if (event->consuming > 0)
	{
		event->eventid = (event->eventid & 0xff) + 1;
		WLog_VRB(TAG, "Server published event %d. %d clients.\n", event->eventid, event->consuming);
		ResetEvent(event->doneEvent);
		SetEvent(event->event);
	}

	return;
}

// Measure the absolute area of a non self-intersecting polygon.
// Formula by Paul Bourke
// (http://astronomy.swin.edu.au/~pbourke/geometry/polyarea/)
//
// The input points must be ordered (clock- or counter-clockwise). The
// polygon is closed automatically between the first and the last point,
// so there should not be two same points in the polygon point set.
double AreaFilter_PolygonArea (AreaFilter* self, ArrayList* orderedPoints)
{
	double A = 0.0;
	
	int n;
	for (n = 0 ; n < ArrayList_Count(orderedPoints) ; ++n) {
		FilterPoint* p0 = (FilterPoint*) ArrayList_GetItem(orderedPoints,n);
		FilterPoint* p1 = (FilterPoint*) ArrayList_GetItem(orderedPoints, (n + 1) % ArrayList_Count(orderedPoints));
		
		A += p0->x * p1->y - p1->x * p0->y;
	}

	A *= 0.5;
	
	return (abs (A));
}

WNDCLASSEXA* FindWindowClass(LPCSTR lpClassName)
{
	int index;
	int count;
	BOOL found = FALSE;
	WNDCLASSEXA* lpwcx = NULL;

	ArrayList_Lock(g_WindowClasses);

	count = ArrayList_Count(g_WindowClasses);

	for (index = 0; index < count; index++)
	{
		lpwcx = (WNDCLASSEXA*) ArrayList_GetItem(g_WindowClasses, index);

		if (strcmp(lpClassName, lpwcx->lpszClassName) == 0)
		{
			found = TRUE;
			break;
		}
	}

	ArrayList_Unlock(g_WindowClasses);

	return (found) ? lpwcx : NULL;
}

static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm, UINT32 ChannelId)
{
	int index;
	int count;
	BOOL found = FALSE;
	rdpPeerChannel* channel = NULL;

	ArrayList_Lock(vcm->dynamicVirtualChannels);

	count = ArrayList_Count(vcm->dynamicVirtualChannels);

	for (index = 0; index < count; index++)
	{
		channel = (rdpPeerChannel*) ArrayList_GetItem(vcm->dynamicVirtualChannels, index);

		if (channel->channelId == ChannelId)
		{
			found = TRUE;
			break;
		}
	}

	ArrayList_Unlock(vcm->dynamicVirtualChannels);

	return found ? channel : NULL;
}

int shadow_client_boardcast_msg(rdpShadowServer* server, void* context, UINT32 type, SHADOW_MSG_OUT* msg, void* lParam)
{
	wMessage message = {0};
	rdpShadowClient* client = NULL;
	int count = 0;
	int index = 0;

	message.context = context;
	message.id = type;
	message.wParam = (void *)msg;
	message.lParam = lParam;
	message.Free = shadow_msg_out_release;

	/* First add reference as we reference it in this function.
     * Therefore it would not be free'ed during post. */
	shadow_msg_out_addref(&message);

	ArrayList_Lock(server->clients);
	for (index = 0; index < ArrayList_Count(server->clients); index++)
	{
		client = (rdpShadowClient*)ArrayList_GetItem(server->clients, index);
		if (shadow_client_dispatch_msg(client, &message))
		{
			count++;
		}
	}
	ArrayList_Unlock(server->clients);

    /* Release the reference for this function */
	shadow_msg_out_release(&message);

	return count;
}

TSMF_PRESENTATION* tsmf_presentation_find_by_id(const BYTE *guid)
{
	UINT32 index;
	UINT32 count;
	BOOL found = FALSE;
	char guid_str[GUID_SIZE * 2 + 1];
	TSMF_PRESENTATION* presentation;

	ArrayList_Lock(presentation_list);
	count = ArrayList_Count(presentation_list);

	for (index = 0; index < count; index++)
	{
		presentation = (TSMF_PRESENTATION*) ArrayList_GetItem(presentation_list, index);

		if (memcmp(presentation->presentation_id, guid, GUID_SIZE) == 0)
		{
			found = TRUE;
			break;
		}
	}

	ArrayList_Unlock(presentation_list);

	if (!found)
		WLog_WARN(TAG, "presentation id %s not found", guid_to_string(guid, guid_str, sizeof(guid_str)));

	return (found) ? presentation : NULL;
}

bool AreaFilter_ccw (ArrayList* points, int i, int j, int k)
{
	double a = ((FilterPoint*)ArrayList_GetItem(points, i))->x - ((FilterPoint*)ArrayList_GetItem(points, j))->x;
	double b = ((FilterPoint*)ArrayList_GetItem(points, i))->y - ((FilterPoint*)ArrayList_GetItem(points, j))->y;
	double c = ((FilterPoint*)ArrayList_GetItem(points, k))->x - ((FilterPoint*)ArrayList_GetItem(points, j))->x;
	double d = ((FilterPoint*)ArrayList_GetItem(points, k))->y - ((FilterPoint*)ArrayList_GetItem(points, j))->y;
	
	return ((a * d - b * c) <= 0.0);
}