public PtsFileConverter(GetOpt opts) {
FileInputStream fin;
DataInputStream ins = null;
FileWriter fout = null;
try {
String inFileString = opts.getString("infile");
String[] inFiles = inFileString.split(",");
fout = new FileWriter(opts.getString("outfile"), false);
for (int i = 0; i < inFiles.length; i++) {
fin = new FileInputStream(inFiles[i]);
ins = new DataInputStream(fin);
FeatureCategory type;
if (opts.getString("type").equals("color")) {
type = FeatureCategory.COLOR;
} else if (opts.getString("type").equals("shape")) {
type = FeatureCategory.SHAPE;
} else {
type = FeatureCategory.SIZE;
}
if (ins != null && fout != null) {
convertFile(ins, fout, type);
}
ins.close();
fin.close();
}
} catch (Exception ex) {
System.err.println("ERR: " + ex);
ex.printStackTrace();
}
}
public static void main(String[] args) {
GetOpt opts = new GetOpt();
opts.addBoolean('h', "help", false, "Show this help screen");
opts.addString('i', "infile", null, "Input .pts file");
opts.addString('o', "outfile", null, "Output feature vector file");
opts.addString('t', "type", "shape", "Type of features to extract: {color, shape}");
if (!opts.parse(args)) {
System.err.println("ERR: " + opts.getReason());
System.exit(1);
}
if (opts.getBoolean("help")) {
opts.doHelp();
System.exit(1);
}
PtsFileConverter pfc = new PtsFileConverter(opts);
}
/**
* Programa principal para o projeto 2.
*
* @param args argumentos da linha de comando.
*/
public static void main(String[] args) {
// Faz o parsing dos argumentos da linha de comando.
GetOpt options = new GetOpt("Projeto2", args, "vr");
int opt;
while ((opt = options.nextOpt()) != -1) {
switch (opt) {
default:
usage();
break;
case 'v':
verbose = true;
break;
case 'r':
rand = new Random(0);
break;
}
}
if (rand == null) {
rand = new Random();
}
if (options.optind != args.length - 2) {
usage();
}
alambiqueCount = Integer.parseInt(args[options.optind]);
int iteracoes = Integer.parseInt(args[options.optind + 1]);
// Cria os atravessadores
atravessadores = new EnumMap<Cana, Atravessador>(Cana.class);
for (Cana g : Cana.values()) {
// Voc� precisa implementar a classe AtravessadorImpl para o programa funcionar.
atravessadores.put(g, new AtravessadorImpl(g));
}
// Criar o �nico fornecedor.
fornecedor = new Fornecedor(iteracoes);
Thread threadFornecedor = new Thread(fornecedor, "Fornecedor");
alambiques = new Alambique[alambiqueCount];
alambiqueThreads = new Thread[alambiqueCount];
for (int i = 0; i < alambiqueCount; i++) {
alambiques[i] = new Alambique();
alambiqueThreads[i] = new Thread(alambiques[i], "Alambique " + i);
}
// Inicia os threads
// Todos eles tem prioridade mais baixa que o thread pricniapl ent�o nenhum deles
// come�ar� a rodar antes que todos tenham sidos inicializados.
threadFornecedor.setPriority(Thread.NORM_PRIORITY - 1);
threadFornecedor.start();
for (Thread t : alambiqueThreads) {
t.setPriority(Thread.NORM_PRIORITY - 1);
t.start();
}
// Espera que todos os threads sejam finalizados
try {
// O thread do fornecedor ser� finalizado quando ele concluir todas as itera��es
// especificadas.
threadFornecedor.join();
// Espera 3 segundos para dar uma chance para os threads do alambique terminarem
// depois disso, todos que n�o finalizarem ser�o interrompidos.
Thread.sleep(3000);
for (Thread t : alambiqueThreads) {
t.interrupt();
t.join();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// imprime o estado final
out.printf("**** Finalizando%n");
Pedido quant;
Pedido balanco = new Pedido();
int produzido = 0;
int nosAtravessadores = 0;
int consumido = 0;
quant = fornecedor.getProducao();
out.printf("Produzido %s%n", quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, n);
produzido += n;
}
for (Cana g : Cana.values()) {
quant = atravessadores.get(g).getEstoqueDisponivel();
for (Cana c1 : Cana.values()) {
int n = quant.get(c1);
balanco.troca(c1, -n);
nosAtravessadores += n;
}
}
for (int i = 0; i < alambiqueCount; i++) {
quant = alambiques[i].getConsumo();
out.printf("O Alambique %d consumiu %s%n", i, quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, -n);
consumido += n;
}
}
out.printf("O balan�o final � %s%n", balanco);
out.printf(
"Total: produzido = %d, consumido = %d,"
+ " sobrando nos atravessadores = %d, liquido = %d%n",
produzido, consumido, nosAtravessadores, (produzido - consumido - nosAtravessadores));
} // main(String[])
/** M�todo principal */
public static void main(String[] args) {
// faz o parsing dos argumentos da linha de comnaod
GetOpt options = new GetOpt("Projeto3", args, "vr");
int opt;
while ((opt = options.nextOpt()) != -1) {
switch (opt) {
default:
uso();
break;
case 'v':
verbose = true;
break;
case 'r':
rand = new Random(0);
break;
}
}
if (rand == null) {
rand = new Random();
}
if (options.optind != args.length - 3) {
uso();
}
int algoritmo = Integer.parseInt(args[options.optind + 0]);
alambiqueN = Integer.parseInt(args[options.optind + 1]);
int iteracoes = Integer.parseInt(args[options.optind + 2]);
// Cria o dep�sito
deposito = new Deposito(algoritmo);
Thread dthread = new Thread(deposito, "Deposito");
// Cria o fornecedor
fornecedor = new Fornecedor(iteracoes);
Thread fThread = new Thread(fornecedor, "Fornecedor");
// Cria os alambiques
alambiques = new Alambique[alambiqueN];
alambiqueThreads = new Thread[alambiqueN];
for (int i = 0; i < alambiqueN; i++) {
alambiques[i] = new Alambique(i);
alambiqueThreads[i] = new Thread(alambiques[i], "Alambique" + i);
}
// Inicia os threads
dthread.setPriority(Thread.NORM_PRIORITY - 1);
dthread.start();
fThread.setPriority(Thread.NORM_PRIORITY - 1);
fThread.start();
for (Thread t : alambiqueThreads) {
t.setPriority(Thread.NORM_PRIORITY - 1);
t.start();
}
// Espera at� que todos os threads sejam encerrados
try {
// O thread do fornecedor se encerra quando ele completa todas as itera��es
fThread.join();
// Aguarda 3 segundos para dar chance a todos de terminarem o que est�o fazendo,
// em seguida todos s�o interrompidos
Thread.sleep(3000);
// Mata o thread do dep�sito
dthread.interrupt();
dthread.join();
// Mata os alambiques
for (Thread t : alambiqueThreads) {
t.interrupt();
t.join();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// imprime o estado final
out.printf("**** Programa terminando%n");
Pedido quant;
Pedido balanco = new Pedido();
int produzido = 0;
int noDeposito = 0;
int consumido = 0;
quant = fornecedor.getProducao();
out.printf("Produzido %s%n", quant);
balanco.troca(quant);
produzido += quant.total();
quant = deposito.getDisponivel();
for (Cana c1 : Cana.values()) {
int n = quant.get(c1);
balanco.troca(c1, -n);
noDeposito += n;
}
Pedido totalConsumido = new Pedido();
int totalRequisitado = 0;
int totalEspera = 0;
for (int i = 0; i < alambiqueN; i++) {
quant = alambiques[i].getConsumo();
int requisitado = alambiques[i].requisicoesConcluidas();
int espera = alambiques[i].tempoDeEspera();
totalConsumido.troca(quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, -n);
consumido += n;
}
out.printf("Alabique %d%n", i);
out.printf(" Cana consumida: %s%n", quant);
out.printf(" Requisi��es atendidas: %d%n", requisitado);
out.printf(" Tempo total de espera: %d ms%n", espera);
if (requisitado > 0) {
out.printf(" Tempo de espera m�dio: %.2f ms%n", espera / (double) requisitado);
}
totalRequisitado += requisitado;
totalEspera += espera;
}
out.printf("Balan�o (deficit) � %s%n", balanco);
out.printf(
"Total: produzido = %d, consumido = %d," + " restando no dep�sito = %d, l�quido = %d%n",
produzido, consumido, noDeposito, (produzido - consumido - noDeposito));
out.printf(
"Requisi��es conclu�das: %d, tempo de espera m�dio %.2fms%n",
totalRequisitado, totalEspera / (double) totalRequisitado);
}