#include <windows.h>
#include <stdio.h>
#pragma comment (lib, "winmm.lib")
int rampa(int canal, int valor_a, int valor_b, float duracion){


	double b_time = timeGetTime();
	double n_time = 0;

	if ((canal<1) || (canal>512) || (valor_a<0) || (valor_b>255) || 
		(valor_b<valor_a) || (valor_b>255) || (duracion<1.0))
    {
		return -1;
    }

	else
	{

		//n_time = timeGetTime();
		
		unsigned int ciclos=0;

		while( ((n_time-b_time)) <= 40){

			ciclos++;
			printf("diff: %f\n",((n_time-b_time)));
			printf("b_time: %f\n",b_time);
			printf("n_time: %f\n",n_time);
			printf("ciclos: %d\n",ciclos);
			printf("======================\n");

			for(unsigned int i=0; i<25; i++){

				n_time = timeGetTime();
			}

			n_time = timeGetTime();
		}
	}

	return 0;
}

int main(){


	if(!rampa(2,2,2,2)) {

		printf("Salida..\n");
		return 0;
	}

	printf("...............\n");
	while(getchar()!='\n');
	return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>
#include <fstream.h>
#include <list>
#include <string>

using namespace std;

struct ScheduledCommand
{
	string comando; 
	int prioridad; 
};

typedef list<ScheduledCommand> ScheduleList;
ScheduleList scheduleList;

void IngresarComando(){

	string cmd;
	char comando[21];
	memset(comando,0,sizeof(comando));
	cout << "Ingrese un comando" << endl;
	cin.getline(comando,20,'\n');
	cmd.assign(comando);

//	cout << const_cast<char*>(cmd.c_str()) << endl;
//	system("pause");

	if(cmd.empty()) // Si se ingresa una línea en blanco procede a mostrar los comandos en lista
	{
		list<ScheduledCommand>::iterator pos;
		for(pos=scheduleList.begin();pos!=scheduleList.end();++pos)
		{
			printf("pri:%d -- cmd:\"%s\"\n", (*pos).prioridad, (*pos).comando.c_str() );
		}
		return;
	}

	ScheduledCommand tmp;
	tmp.comando=cmd;
	tmp.prioridad=1;
	if(scheduleList.size()<32){
		scheduleList.push_back(tmp);
	}
}

void BorrarComandos(){

	scheduleList.erase(scheduleList.begin(),scheduleList.end());
}

void VerificarComandos(){

	cout << "\n";

	int cantidad=0;
	for( ScheduleList::iterator pos = scheduleList.begin(); pos != scheduleList.end(); ++pos)
	{
		// cantidad++;
		if( (*pos).prioridad == 1 )
		{
			cantidad++;
			cout << "Comando: " << const_cast<char*>((*pos).comando.c_str()) << endl;
			scheduleList.erase(pos); // lo borra luego de verificarlo
			break;
		}
	}

	if(cantidad==0)
		cout << "No hay comandos !" << endl;
}

int main(){

	IngresarComando();
	IngresarComando();
	IngresarComando();

	VerificarComandos();
	VerificarComandos();
	VerificarComandos();

	BorrarComandos();

	VerificarComandos();

	cin.get();
	return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>

#include <fstream.h>
#include <string>
#include <vector>

using namespace std;

typedef struct estructura_s{
	int a;
	int b;
	int c;
}estructura_t;

struct ent_info{ 
	estructura_s* ent;
};

vector<ent_info> vEntidad;

void AgregarEntidad(struct estructura_s* ent)
{
	ent_info dummy;
	dummy.ent = ent;
	if(vEntidad.size()<64)
		vEntidad.push_back(dummy);
}

void BorrarVectorDeEntidades()
{
	vEntidad.clear();
}

void ListarItemsDeEntidades(){

	for(unsigned int ab=0; ab<vEntidad.size(); ab++){
	
		cout << "La entidad: " << ab << endl;
		cout << "Item 1: " << vEntidad[ab].ent->a << endl;
		cout << "Item 2: " << vEntidad[ab].ent->b << endl;
		cout << "Item 3: " << vEntidad[ab].ent->c << endl;
	}
}

int main(){

	BorrarVectorDeEntidades();

	struct estructura_s ent1;
	struct estructura_s ent2;
	struct estructura_s ent3;
	ent1.a=111;
	ent1.b=222;
	ent1.c=333;
	ent2.a=444;
	ent2.b=555;
	ent2.c=666;
	ent3.a=777;
	ent3.b=888;
	ent3.c=999;

	AgregarEntidad(&ent1);
	AgregarEntidad(&ent2);
	AgregarEntidad(&ent3);

	ListarItemsDeEntidades();

	cin.get();
	return 0;
}

#define INDEXFIND_BY_ID   (((PrivateData*)my_data)->findByID)
#define INDEXFIND_BY_NAME (((PrivateData*)my_data)->findByName)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// UTN FRGP TSP
// BS
// mail: david_bs@live.com
// web: Etalking.Com.Ar
// 2012
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>

#include <fstream.h>
#include <map>
#include <string>
#include <vector>

using namespace std;

typedef map<int,int> MapIntInt;

struct PrivateData{
	MapIntInt findByID;
	string findByName;
};

void* my_data;

#define INDEXFIND_BY_ID   (((PrivateData*)my_data)->findByID)
#define INDEXFIND_BY_NAME (((PrivateData*)my_data)->findByName)

struct Info
{
	char	szName[36];
	int		iId;
};

vector<Info> infoList;

void Constructor()
{
	my_data = new PrivateData;
}

void Destructor()
{
    delete (PrivateData*)my_data;
}

void Completa(int id, const char* name){

	Info newElemento;

	strcpy( newElemento.szName, name );
	newElemento.iId = id;

	// find: retorna un iterator
	MapIntInt::iterator foundpos = (((PrivateData*)my_data)->findByID).find( newElemento.iId );
	
	typedef MapIntInt::value_type Entry;

	if(foundpos==((((PrivateData*)my_data)->findByID).end())) // al final (luego del último elemento)
	{
		int index = infoList.size();
		infoList.push_back(newElemento);
		(((PrivateData*)my_data)->findByID).insert(Entry(newElemento.iId,index)); // inserta elemento nuevo
		(((PrivateData*)my_data)->findByName).assign(newElemento.szName);
	} 
	else //repite
	{
		int index = foundpos->second; // un par tiene un segundo elemento..
		infoList[index]=newElemento;
	}
}

const char* getNamebyId(int id)
{
	MapIntInt::iterator foundpos = (((PrivateData*)my_data)->findByID).find( id );
	if(foundpos==((((PrivateData*)my_data)->findByID).end())) { return "ninguna"; }
	int index = foundpos->second;
	return infoList[index].szName;
}

int main(){

	Constructor();
	Completa(0, "AK");
	Completa(0, "SCOUT");
	Completa(1, "AP");
	Completa(2, "DESERT");

	Completa(1, "M4");
	Completa(1, "M4");
	Completa(1, "M4");

	cout << "La id 0 contiene: " << getNamebyId(0) << endl;
	cout << "La id 1 contiene: " << getNamebyId(1) << endl;
	cout << "La id 2 contiene: " << getNamebyId(2) << endl;


	cin.get();
	Destructor();
	return 0;
}