Naturaleza social del ser humano
Enviado por ferabizu • 23 de Febrero de 2016 • Documentos de Investigación • 1.164 Palabras (5 Páginas) • 285 Visitas
#include "stdafx.h"
#include <iostream>
using namespace std;
/**************************
* DEFINICION DE CALLBACKS *
* (PROYECTO 1) *
**************************/
static int function1(int param)
{
cout << "Parametro: " << param << "\n";
cout << "Funcion: " << 1 << "\n";
return 1;
}
class ClassA
{
public:
static int function2(int param);
};
int ClassA::function2(int param)
{
cout << "Parametro: " << param << "\n";
cout << "Funcion: " << 2 << "\n";
return 2;
}
class ClassB
{
public:
static void setCallBack(int (ClassB::*&cb)(int));
private:
int function3(int param);
};
int ClassB::function3(int param)
{
cout << "Parametro: " << param << "\n";
cout << "Funcion: " << 3 << "\n";
return 3;
}
void ClassB::setCallBack(int (ClassB::*&cb)(int))
{
cb = &ClassB::function3;
}
typedef int(*CallBack)(int);
typedef int(ClassB::*CallBackB)(int);
/*****************************
* DEFINICION DE KERNEL Y PCB *
* (PROYECTO 2) *
*****************************/
#define MAX 10 //La cantidad maxima de procesos
//DEFINICION DE CONSTANTES PARA ESTADOS DEL PROCESO
//NOTA: No todas las constantes se utilizan por ahora
#define RUNNING 1 //El proceso se esta ejecutando
#define BLOCKED 2 //El proceso se encuentra bloqueado
#define READY 3 //El proceso se encuentra listo para su ejecucion
#define SUSPENDED 4 //El proceso se ha suspendido
#define WAITING 5
#define DONE 6
#define READY_AND_SUSPENDED (READY | SUSPENDED) //Listo y suspendido
#define BLOCKED_AND_SUSPENDED ((BLOCKED | SUSPENDED) + 2) //Bloqueado y suspendido
#define SUCCESSFUL 0 //Resultado exitoso ->UTILIZADA EN TODAS LAS FUNCIONES<-
//DEFINICION DE CONSTANTES DEL RESULTADO DE AGREGAR UN PROCESO
#define UNAVAILABLE 1 //Posicion no disponible para agregar al proceso
#define OVERFLOW 2 //La cantidad de procesos agregados ha sido alcanzada
#define OUT_OF_RANGE 3 //El indice para agregar ha sido sobrepasado
//DEFINICION DE CONSTANTES DEL RESULTADO DE CORRER UN PROCESO
//TODO: Pueden existir mas casos, revisar. Quizas sea mejor retornar el valor de status en el pcb
#define PROCESS_IS_NULL 1 //No hay proceso en esa posicion
#define PROCESS_IS_DONE 2 //El proceso ha sido terminado y desea ejecutarse
#define PROCESS_NOT_FOUND 3 //El proceso no ha sido encontrado
//TODO: Es probable que se necesite hacer un template con la clase PCB
///<summary>Process Control Block <para>Registra la informacion de un proceso</para></summary>
class PCB
{
private:
///<summary>Representa el identificador de proceso</summary>
int id;
public:
///<summary>status: Estado del proceso <para>*function: Puntero a la funcion que debe ejecutar</para></summary>
int status, *function;
///<summary>Objeto a utilizar en caso de que la funcion no sea estatica</summary>
ClassB *obj;
///<summary><param name = "id">Identificador de proceso</param>
///<param name = "status">Estado con el que se inicializa el proceso</param>
///<param name = "callback">puntero a la funcion</param></summary>
PCB(int id, int status, int *callback)
{
this->id = id;
this->status = status;
this->function = callback;
this->obj = NULL;
}
///<summary><param name = "id">Identificador de proceso</param>
///<param name = "status">Estado con el que se inicializa el proceso</param>
///<param name = "callback">puntero a la funcion</param>
///<param name = "obj">Objeto inicializado para una funcion no estatica</param></summary>
PCB(int id, int status, int *callback, ClassB *obj)
{
this->id = id;
this->status = status;
this->function = callback;
this->obj = obj;
}
~PCB()
{
this->id = this->status = 0;
this->function = NULL;
if (this->obj != NULL)
{ //TODO: Agregar el destructor de obj, si es necesario
this->obj = NULL;
}
}
///<summary>Retorna el id del PCB</summary>
int getId()
{
return this->id;
}
};
///<summary>Kernel que lleva la tabla de procesos</summary>
class Kernel
{
private:
///<summary>Contador de identificadores</summary>
int id_count;
///<summary>Valida si un proceso nuevo puede ser agregado en la posicion
///</param name = "index">Indice en que se quiere insertar el proceso</param>
///<para><returns>Entero que inidica el resultado</returns></para></summary>
int validateNewProcess(int index)
{
if (index >= MAX || index < 0)
return OUT_OF_RANGE;
if (this->pcb[index] != NULL)
{
if (this->pcb[index]->status != DONE)
return UNAVAILABLE;
else
killProcessAt(index);
}
if (count >= MAX)
return OVERFLOW;
return SUCCESSFUL;
}
///<summary>Corre un proceso al recibir el PCB
///<param name = "pcb">Puntero al Bloque de Control de Proceso</param></summary>
static void runProcess(PCB *pcb)
{
int result;
int *function = pcb->function;
pcb->status = RUNNING;
if (pcb->obj != NULL)
...