identifier
stringlengths 0
89
| parameters
stringlengths 0
399
| return_statement
stringlengths 0
982
⌀ | docstring
stringlengths 10
3.04k
| docstring_summary
stringlengths 0
3.04k
| function
stringlengths 13
25.8k
| function_tokens
sequence | start_point
sequence | end_point
sequence | argument_list
null | language
stringclasses 3
values | docstring_language
stringclasses 4
values | docstring_language_predictions
stringclasses 4
values | is_langid_reliable
stringclasses 2
values | is_langid_extra_reliable
bool 1
class | type
stringclasses 9
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ListaDinamica. | null | Limpar o conteudo da lista | Limpar o conteudo da lista | @SuppressWarnings("unused")
public void limpar() {
for (int i = contador; i >= 0; i--) {
Object item = retirar(i);
inicio = fim = null;
}
} | [
"@",
"SuppressWarnings",
"(",
"\"unused\"",
")",
"public",
"void",
"limpar",
"(",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"contador",
";",
"i",
">=",
"0",
";",
"i",
"--",
")",
"{",
"Object",
"item",
"=",
"retirar",
"(",
"i",
")",
";",
"inicio",
"=",
"fim",
"=",
"null",
";",
"}",
"}"
] | [
170,
1
] | [
176,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
DesafioMeuTimeApplication. | null | Retorna uma lista com o identificador dos top melhores jogadores, utilizar o menor identificador como critério de desempate. | Retorna uma lista com o identificador dos top melhores jogadores, utilizar o menor identificador como critério de desempate. | @Desafio("buscarTopJogadores")
public List<Long> buscarTopJogadores(Integer top) {
return this.jogadores
.stream()
.sorted(Comparator.comparing(Jogador::getNivelHabilidade).reversed()
.thenComparing(Jogador::getId))
.map(Jogador::getId)
.limit(top)
.collect(Collectors.toList());
} | [
"@",
"Desafio",
"(",
"\"buscarTopJogadores\"",
")",
"public",
"List",
"<",
"Long",
">",
"buscarTopJogadores",
"(",
"Integer",
"top",
")",
"{",
"return",
"this",
".",
"jogadores",
".",
"stream",
"(",
")",
".",
"sorted",
"(",
"Comparator",
".",
"comparing",
"(",
"Jogador",
"::",
"getNivelHabilidade",
")",
".",
"reversed",
"(",
")",
".",
"thenComparing",
"(",
"Jogador",
"::",
"getId",
")",
")",
".",
"map",
"(",
"Jogador",
"::",
"getId",
")",
".",
"limit",
"(",
"top",
")",
".",
"collect",
"(",
"Collectors",
".",
"toList",
"(",
")",
")",
";",
"}"
] | [
182,
1
] | [
192,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
WS3D_Controller. | null | Verifica se os leaflets já foram coletados | Verifica se os leaflets já foram coletados | private void BCheck_Leaflts_ok(){
if(leaflets.get(0).isCompleted() != true){
System.out.println("The leaflet still incomplete: " + 0);
} else {
System.out.println("Task Leaflet has completed: " + 0);
}
if(leaflets.get(1).isCompleted() == false){
System.out.println("The leaflet still incomplete: " + 1);
} else {
System.out.println("Task Leaflet has completed: " + 1);
}
if(leaflets.get(2).isCompleted() == false){
System.out.println("The leaflet still incomplete: " + 2);
} else {
System.out.println("Task Leaflet has completed: " + 2);
}
} | [
"private",
"void",
"BCheck_Leaflts_ok",
"(",
")",
"{",
"if",
"(",
"leaflets",
".",
"get",
"(",
"0",
")",
".",
"isCompleted",
"(",
")",
"!=",
"true",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"The leaflet still incomplete: \"",
"+",
"0",
")",
";",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Task Leaflet has completed: \"",
"+",
"0",
")",
";",
"}",
"if",
"(",
"leaflets",
".",
"get",
"(",
"1",
")",
".",
"isCompleted",
"(",
")",
"==",
"false",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"The leaflet still incomplete: \"",
"+",
"1",
")",
";",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Task Leaflet has completed: \"",
"+",
"1",
")",
";",
"}",
"if",
"(",
"leaflets",
".",
"get",
"(",
"2",
")",
".",
"isCompleted",
"(",
")",
"==",
"false",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"The leaflet still incomplete: \"",
"+",
"2",
")",
";",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Task Leaflet has completed: \"",
"+",
"2",
")",
";",
"}",
"}"
] | [
284,
4
] | [
302,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FilmeTest. | null | Filme Nao Assistido | Filme Nao Assistido | @Test
public void deveMarcarFilmeAssistidoEmFilmeNaoAssistido() {
filme.setEstado(FilmeEstadoNaoAssistido.getInstance());
assertEquals("Filme Assistido!", filme.marcarAssistido());
} | [
"@",
"Test",
"public",
"void",
"deveMarcarFilmeAssistidoEmFilmeNaoAssistido",
"(",
")",
"{",
"filme",
".",
"setEstado",
"(",
"FilmeEstadoNaoAssistido",
".",
"getInstance",
"(",
")",
")",
";",
"assertEquals",
"(",
"\"Filme Assistido!\"",
",",
"filme",
".",
"marcarAssistido",
"(",
")",
")",
";",
"}"
] | [
41,
4
] | [
45,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
GraphSemanticLevelMarkerStepMeta. | null | Gerar XML para salvar um .ktr | Gerar XML para salvar um .ktr | @Override
public String getXML() throws KettleException {
StringBuilder xml = new StringBuilder();
xml.append(XMLHandler.addTagValue(Field.INPUT_GRAPH.name(), inputGraph));
xml.append(XMLHandler.addTagValue(Field.OUTPUT_SUBJECT.name(), outputSubject));
xml.append(XMLHandler.addTagValue(Field.OUTPUT_PREDICATE.name(), outputPredicate));
xml.append(XMLHandler.addTagValue(Field.OUTPUT_OBJECT.name(), outputObject));
xml.append(XMLHandler.addTagValue(Field.INPUT_BROWSE_FILE_NAME.name(), browseFilename));
xml.append(XMLHandler.addTagValue(Field.INPUT_RULES_FILE_NAME.name(), rulesFilename));
return xml.toString();
} | [
"@",
"Override",
"public",
"String",
"getXML",
"(",
")",
"throws",
"KettleException",
"{",
"StringBuilder",
"xml",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"INPUT_GRAPH",
".",
"name",
"(",
")",
",",
"inputGraph",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"OUTPUT_SUBJECT",
".",
"name",
"(",
")",
",",
"outputSubject",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"OUTPUT_PREDICATE",
".",
"name",
"(",
")",
",",
"outputPredicate",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"OUTPUT_OBJECT",
".",
"name",
"(",
")",
",",
"outputObject",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"INPUT_BROWSE_FILE_NAME",
".",
"name",
"(",
")",
",",
"browseFilename",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"INPUT_RULES_FILE_NAME",
".",
"name",
"(",
")",
",",
"rulesFilename",
")",
")",
";",
"return",
"xml",
".",
"toString",
"(",
")",
";",
"}"
] | [
102,
1
] | [
114,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Posicao. | null | método público que define uma peça ocupante da posição, permite ao tabuleiro acesso às peças (na troca de peças, por exemplo): | método público que define uma peça ocupante da posição, permite ao tabuleiro acesso às peças (na troca de peças, por exemplo): | public void setPeca(Peca peca) {
this.peca = peca;
} | [
"public",
"void",
"setPeca",
"(",
"Peca",
"peca",
")",
"{",
"this",
".",
"peca",
"=",
"peca",
";",
"}"
] | [
69,
4
] | [
71,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
TelaCarro. | null | Metodo desabiliatarBotões | Metodo desabiliatarBotões | private void desabilitarBotao(){
btnCarCancelar.setEnabled(false);
btnCarExcluir.setEnabled(false);
btnCarAlterar.setEnabled(false);
btnCarLimpar.setEnabled(false);
//btnCarSelect.setEnabled(false);
btnCarSalve.setEnabled(false);
} | [
"private",
"void",
"desabilitarBotao",
"(",
")",
"{",
"btnCarCancelar",
".",
"setEnabled",
"(",
"false",
")",
";",
"btnCarExcluir",
".",
"setEnabled",
"(",
"false",
")",
";",
"btnCarAlterar",
".",
"setEnabled",
"(",
"false",
")",
";",
"btnCarLimpar",
".",
"setEnabled",
"(",
"false",
")",
";",
"//btnCarSelect.setEnabled(false);",
"btnCarSalve",
".",
"setEnabled",
"(",
"false",
")",
";",
"}"
] | [
65,
4
] | [
72,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | False | true | method_declaration |
|
SecurityConfigurations. | null | Configurações de recusos estaticos == JS, CSS, IMAGENS, etc. | Configurações de recusos estaticos == JS, CSS, IMAGENS, etc. | @Override
public void configure(WebSecurity web) throws Exception {
web.ignoring()
.antMatchers("/**.html", "/v2/api-docs", "/webjars/**", "/configuration/**", "/swagger-resources/**");
} | [
"@",
"Override",
"public",
"void",
"configure",
"(",
"WebSecurity",
"web",
")",
"throws",
"Exception",
"{",
"web",
".",
"ignoring",
"(",
")",
".",
"antMatchers",
"(",
"\"/**.html\"",
",",
"\"/v2/api-docs\"",
",",
"\"/webjars/**\"",
",",
"\"/configuration/**\"",
",",
"\"/swagger-resources/**\"",
")",
";",
"}"
] | [
32,
1
] | [
36,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Operacoes. | null | O metodo consultar eh do tipo "Time". O codigo do time eh passado como parametro | O metodo consultar eh do tipo "Time". O codigo do time eh passado como parametro | public Time consultar (int codigo){
//Realiza a conexao com o banco de dados
Conexao conn = new Conexao();
Connection cntn = conn.getConnection();
//Instancia de um objeto "time01"
Time time01 = new Time();
//Comando SQL para consulta de dados na tabela baseada no id do time
String sql = "select* from times_de_futebol where id_time=?";
//Declaracao da variavel "ps" de PreparedStatement
PreparedStatement ps;
try{
//Atribuicao a variavel "ps"
ps = cntn.prepareStatement(sql);
ps.setInt(1, codigo);
//O ResultSet eh utilizado para guardar dados vindos de um banco de dados
//Ele guarda o resultado de uma pesquisa numa estrutura de dados que pode ser percorrida
ResultSet rs = ps.executeQuery();
//Percorre o ResultSet
while(rs.next()){
//Guarda os valores em cada variavel especifica
int id_time = rs.getInt("id_time");
String nome = rs.getString("nome");
String apelido = rs.getString("apelido");
String mascote = rs.getString("mascote");
int ano = rs.getInt("ano_de_fundacao");
String localizacao = rs.getString("localizacao");
/*Adiciona os valores obtidos da consulta como caracteristicas do objeto instanciado
"time01"*/
//"time01" eh setado
time01.setId_time(id_time);
time01.setNome(nome);
time01.setApelido(apelido);
time01.setMascote(mascote);
time01.setAno_de_fundacao(ano);
time01.setLocalizacao(localizacao);
//Salva o codigo do time e ano de fundacao
x = id_time;
y = ano;
}
/*Devido a um erro de consulta, inseri essa verificacao. Se for retornado id_time = 0 e
ano_de_fundacao = 0, nao existe consulta para o codigo do time informado
*/
if(x != 0 && y != 0)
JOptionPane.showMessageDialog(null, "consultado com sucesso");
else
JOptionPane.showMessageDialog(null, "Consulta inválida");
//PreparedStatement encerrado
ps.close();
//Conexao com o o banco encerrada
cntn.close();
//Captura da excecao
}catch(SQLException ex){
//Exibe uma mensagem na tela para informar que ocorreu um erro ao consultar
JOptionPane.showMessageDialog(null, "problemas na consulta " + ex);
}
//retorna o objeto "time01"
return time01;
} | [
"public",
"Time",
"consultar",
"(",
"int",
"codigo",
")",
"{",
"//Realiza a conexao com o banco de dados",
"Conexao",
"conn",
"=",
"new",
"Conexao",
"(",
")",
";",
"Connection",
"cntn",
"=",
"conn",
".",
"getConnection",
"(",
")",
";",
"//Instancia de um objeto \"time01\"",
"Time",
"time01",
"=",
"new",
"Time",
"(",
")",
";",
"//Comando SQL para consulta de dados na tabela baseada no id do time",
"String",
"sql",
"=",
"\"select* from times_de_futebol where id_time=?\"",
";",
"//Declaracao da variavel \"ps\" de PreparedStatement",
"PreparedStatement",
"ps",
";",
"try",
"{",
"//Atribuicao a variavel \"ps\"",
"ps",
"=",
"cntn",
".",
"prepareStatement",
"(",
"sql",
")",
";",
"ps",
".",
"setInt",
"(",
"1",
",",
"codigo",
")",
";",
"//O ResultSet eh utilizado para guardar dados vindos de um banco de dados",
"//Ele guarda o resultado de uma pesquisa numa estrutura de dados que pode ser percorrida",
"ResultSet",
"rs",
"=",
"ps",
".",
"executeQuery",
"(",
")",
";",
"//Percorre o ResultSet",
"while",
"(",
"rs",
".",
"next",
"(",
")",
")",
"{",
"//Guarda os valores em cada variavel especifica",
"int",
"id_time",
"=",
"rs",
".",
"getInt",
"(",
"\"id_time\"",
")",
";",
"String",
"nome",
"=",
"rs",
".",
"getString",
"(",
"\"nome\"",
")",
";",
"String",
"apelido",
"=",
"rs",
".",
"getString",
"(",
"\"apelido\"",
")",
";",
"String",
"mascote",
"=",
"rs",
".",
"getString",
"(",
"\"mascote\"",
")",
";",
"int",
"ano",
"=",
"rs",
".",
"getInt",
"(",
"\"ano_de_fundacao\"",
")",
";",
"String",
"localizacao",
"=",
"rs",
".",
"getString",
"(",
"\"localizacao\"",
")",
";",
"/*Adiciona os valores obtidos da consulta como caracteristicas do objeto instanciado\n \"time01\"*/",
"//\"time01\" eh setado ",
"time01",
".",
"setId_time",
"(",
"id_time",
")",
";",
"time01",
".",
"setNome",
"(",
"nome",
")",
";",
"time01",
".",
"setApelido",
"(",
"apelido",
")",
";",
"time01",
".",
"setMascote",
"(",
"mascote",
")",
";",
"time01",
".",
"setAno_de_fundacao",
"(",
"ano",
")",
";",
"time01",
".",
"setLocalizacao",
"(",
"localizacao",
")",
";",
"//Salva o codigo do time e ano de fundacao",
"x",
"=",
"id_time",
";",
"y",
"=",
"ano",
";",
"}",
"/*Devido a um erro de consulta, inseri essa verificacao. Se for retornado id_time = 0 e\n ano_de_fundacao = 0, nao existe consulta para o codigo do time informado\n */",
"if",
"(",
"x",
"!=",
"0",
"&&",
"y",
"!=",
"0",
")",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"\"consultado com sucesso\"",
")",
";",
"else",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"\"Consulta inválida\")",
";",
"",
"//PreparedStatement encerrado",
"ps",
".",
"close",
"(",
")",
";",
"//Conexao com o o banco encerrada",
"cntn",
".",
"close",
"(",
")",
";",
"//Captura da excecao",
"}",
"catch",
"(",
"SQLException",
"ex",
")",
"{",
"//Exibe uma mensagem na tela para informar que ocorreu um erro ao consultar",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"\"problemas na consulta \"",
"+",
"ex",
")",
";",
"}",
"//retorna o objeto \"time01\"",
"return",
"time01",
";",
"}"
] | [
87,
4
] | [
147,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Rei. | null | método que checa um determinado movimento de uma peça: | método que checa um determinado movimento de uma peça: | @Override
public boolean checaMovimento(int linhaOrigem, char colunaOrigem, int linhaDestino, char colunaDestino) {
if (this.getStatus()) { //se a peça estiver ativa
int variacaoLinha = Math.abs(linhaDestino - linhaOrigem); //calculando a variação de linha
int variacaoColuna = Math.abs(((int)(colunaDestino - 97) - (int)(colunaOrigem - 97))); //calculando a variação de coluna
//lógica de movimentação:
if (variacaoLinha == 1) {
if (variacaoColuna == 1 || variacaoColuna == 0) {
return true;
}
} else if (variacaoColuna == 1) {
if (variacaoLinha == 1 || variacaoLinha == 0) {
return true;
}
}
//caso o movimento não seja válido:
return false;
}
return false;
} | [
"@",
"Override",
"public",
"boolean",
"checaMovimento",
"(",
"int",
"linhaOrigem",
",",
"char",
"colunaOrigem",
",",
"int",
"linhaDestino",
",",
"char",
"colunaDestino",
")",
"{",
"if",
"(",
"this",
".",
"getStatus",
"(",
")",
")",
"{",
"//se a peça estiver ativa",
"int",
"variacaoLinha",
"=",
"Math",
".",
"abs",
"(",
"linhaDestino",
"-",
"linhaOrigem",
")",
";",
"//calculando a variação de linha",
"int",
"variacaoColuna",
"=",
"Math",
".",
"abs",
"(",
"(",
"(",
"int",
")",
"(",
"colunaDestino",
"-",
"97",
")",
"-",
"(",
"int",
")",
"(",
"colunaOrigem",
"-",
"97",
")",
")",
")",
";",
"//calculando a variação de coluna",
"//lógica de movimentação: ",
"if",
"(",
"variacaoLinha",
"==",
"1",
")",
"{",
"if",
"(",
"variacaoColuna",
"==",
"1",
"||",
"variacaoColuna",
"==",
"0",
")",
"{",
"return",
"true",
";",
"}",
"}",
"else",
"if",
"(",
"variacaoColuna",
"==",
"1",
")",
"{",
"if",
"(",
"variacaoLinha",
"==",
"1",
"||",
"variacaoLinha",
"==",
"0",
")",
"{",
"return",
"true",
";",
"}",
"}",
"//caso o movimento não seja válido:",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}"
] | [
22,
4
] | [
42,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ListaIDs. | null | Retornar todas as ids de perguntas de um usuario
@param idUsuario ID do usuario que se quer todas as perguntas
@return Vetor de int contendo todas as ids das perguntas
Possível retorno de erro:
Null -> usuário nunca fez uma pergunta
| Retornar todas as ids de perguntas de um usuario | @Override
public int[] read(int idUsuario) {
int[] idsPerguntas = null;
try {
// Verificando se existe a posicao no arquivo
if(idUsuario*12 < this.indice.length()) {
this.indice.seek(idUsuario*12);
int numElementos = this.indice.readInt();
long posCabeca = this.indice.readLong();
// Verificar se a posição mesmo que válida, possui algum elemento válido
if(posCabeca != -1) {
this.pilhaIds.seek(posCabeca);
this.pilhaIds.readInt();
long proxPosicao = this.pilhaIds.readLong();
if (proxPosicao != -1) {
this.pilhaIds.seek(proxPosicao);
idsPerguntas = new int[numElementos];
long proxPos = -1;
for(int i = 0; i < numElementos; i++) {
idsPerguntas[i] = this.pilhaIds.readInt();
proxPos = this.pilhaIds.readLong();
if(proxPos != -1)
this.pilhaIds.seek(proxPos);
}
}
}
}
} catch(Exception e) { e.printStackTrace(); }
return idsPerguntas;
} | [
"@",
"Override",
"public",
"int",
"[",
"]",
"read",
"(",
"int",
"idUsuario",
")",
"{",
"int",
"[",
"]",
"idsPerguntas",
"=",
"null",
";",
"try",
"{",
"// Verificando se existe a posicao no arquivo",
"if",
"(",
"idUsuario",
"*",
"12",
"<",
"this",
".",
"indice",
".",
"length",
"(",
")",
")",
"{",
"this",
".",
"indice",
".",
"seek",
"(",
"idUsuario",
"*",
"12",
")",
";",
"int",
"numElementos",
"=",
"this",
".",
"indice",
".",
"readInt",
"(",
")",
";",
"long",
"posCabeca",
"=",
"this",
".",
"indice",
".",
"readLong",
"(",
")",
";",
"// Verificar se a posição mesmo que válida, possui algum elemento válido",
"if",
"(",
"posCabeca",
"!=",
"-",
"1",
")",
"{",
"this",
".",
"pilhaIds",
".",
"seek",
"(",
"posCabeca",
")",
";",
"this",
".",
"pilhaIds",
".",
"readInt",
"(",
")",
";",
"long",
"proxPosicao",
"=",
"this",
".",
"pilhaIds",
".",
"readLong",
"(",
")",
";",
"if",
"(",
"proxPosicao",
"!=",
"-",
"1",
")",
"{",
"this",
".",
"pilhaIds",
".",
"seek",
"(",
"proxPosicao",
")",
";",
"idsPerguntas",
"=",
"new",
"int",
"[",
"numElementos",
"]",
";",
"long",
"proxPos",
"=",
"-",
"1",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"numElementos",
";",
"i",
"++",
")",
"{",
"idsPerguntas",
"[",
"i",
"]",
"=",
"this",
".",
"pilhaIds",
".",
"readInt",
"(",
")",
";",
"proxPos",
"=",
"this",
".",
"pilhaIds",
".",
"readLong",
"(",
")",
";",
"if",
"(",
"proxPos",
"!=",
"-",
"1",
")",
"this",
".",
"pilhaIds",
".",
"seek",
"(",
"proxPos",
")",
";",
"}",
"}",
"}",
"}",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"return",
"idsPerguntas",
";",
"}"
] | [
145,
4
] | [
183,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
NotificationUtils. | null | Notificação simples sem abrir intent (usada para alertas, ex: no wear) | Notificação simples sem abrir intent (usada para alertas, ex: no wear) | public static void create(int smallIcon, String contentTitle, String contentText) {
NotificationManager manager =
(NotificationManager) Utils.getApp().getSystemService(Context.NOTIFICATION_SERVICE);
// Cria a notification
NotificationCompat.Builder builder = new NotificationCompat.Builder(Utils.getApp())
.setContentTitle(contentTitle)
.setContentText(contentText)
.setSmallIcon(smallIcon)
.setAutoCancel(true);
// Dispara a notification
Notification n = builder.build();
manager.notify(0, n);
} | [
"public",
"static",
"void",
"create",
"(",
"int",
"smallIcon",
",",
"String",
"contentTitle",
",",
"String",
"contentText",
")",
"{",
"NotificationManager",
"manager",
"=",
"(",
"NotificationManager",
")",
"Utils",
".",
"getApp",
"(",
")",
".",
"getSystemService",
"(",
"Context",
".",
"NOTIFICATION_SERVICE",
")",
";",
"// Cria a notification",
"NotificationCompat",
".",
"Builder",
"builder",
"=",
"new",
"NotificationCompat",
".",
"Builder",
"(",
"Utils",
".",
"getApp",
"(",
")",
")",
".",
"setContentTitle",
"(",
"contentTitle",
")",
".",
"setContentText",
"(",
"contentText",
")",
".",
"setSmallIcon",
"(",
"smallIcon",
")",
".",
"setAutoCancel",
"(",
"true",
")",
";",
"// Dispara a notification",
"Notification",
"n",
"=",
"builder",
".",
"build",
"(",
")",
";",
"manager",
".",
"notify",
"(",
"0",
",",
"n",
")",
";",
"}"
] | [
60,
4
] | [
74,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ApiExceptionHandler. | null | trata exceções do bean validation | trata exceções do bean validation | @Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status,
WebRequest request) {
return handleValidationInternal(ex, ex.getBindingResult(), headers, status, request);
} | [
"@",
"Override",
"protected",
"ResponseEntity",
"<",
"Object",
">",
"handleMethodArgumentNotValid",
"(",
"MethodArgumentNotValidException",
"ex",
",",
"HttpHeaders",
"headers",
",",
"HttpStatus",
"status",
",",
"WebRequest",
"request",
")",
"{",
"return",
"handleValidationInternal",
"(",
"ex",
",",
"ex",
".",
"getBindingResult",
"(",
")",
",",
"headers",
",",
"status",
",",
"request",
")",
";",
"}"
] | [
335,
1
] | [
339,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
PetShopTest. | null | testes para os casos em que alguma exceção será lançada. | testes para os casos em que alguma exceção será lançada. | @Test
public void testCadastrarAnimalNomeInvalido() {
assertThrows(IllegalArgumentException.class,
() -> petShop.cadastrarAnimal(null, "Gato", 10));
assertThrows(IllegalArgumentException.class,
() -> petShop.cadastrarAnimal("", "Gato", 10));
assertThrows(IllegalArgumentException.class,
() -> petShop.cadastrarAnimal(" ", "Gato", 10));
} | [
"@",
"Test",
"public",
"void",
"testCadastrarAnimalNomeInvalido",
"(",
")",
"{",
"assertThrows",
"(",
"IllegalArgumentException",
".",
"class",
",",
"(",
")",
"->",
"petShop",
".",
"cadastrarAnimal",
"(",
"null",
",",
"\"Gato\"",
",",
"10",
")",
")",
";",
"assertThrows",
"(",
"IllegalArgumentException",
".",
"class",
",",
"(",
")",
"->",
"petShop",
".",
"cadastrarAnimal",
"(",
"\"\"",
",",
"\"Gato\"",
",",
"10",
")",
")",
";",
"assertThrows",
"(",
"IllegalArgumentException",
".",
"class",
",",
"(",
")",
"->",
"petShop",
".",
"cadastrarAnimal",
"(",
"\" \"",
",",
"\"Gato\"",
",",
"10",
")",
")",
";",
"}"
] | [
16,
1
] | [
26,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Cliente. | null | /* Os métodos abaixo são utilizados para controle da conta do cliente.
Será retornando true em função que este controle será implementado posteriomente, se necessário.
| /* Os métodos abaixo são utilizados para controle da conta do cliente.
Será retornando true em função que este controle será implementado posteriomente, se necessário.
| @Override
public boolean isAccountNonExpired() {
return true;
} | [
"@",
"Override",
"public",
"boolean",
"isAccountNonExpired",
"(",
")",
"{",
"return",
"true",
";",
"}"
] | [
102,
4
] | [
105,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FXMLProcessosManutencoesDialogController. | null | Carrega os dados do ListView de Servicos | Carrega os dados do ListView de Servicos | public void carregarListViewServicos(){
observableListViewServicos = FXCollections.observableArrayList(servicosAdicionados);
listViewServicos.setItems(observableListViewServicos);
} | [
"public",
"void",
"carregarListViewServicos",
"(",
")",
"{",
"observableListViewServicos",
"=",
"FXCollections",
".",
"observableArrayList",
"(",
"servicosAdicionados",
")",
";",
"listViewServicos",
".",
"setItems",
"(",
"observableListViewServicos",
")",
";",
"}"
] | [
132,
4
] | [
135,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
GraphSparqlStepMeta. | null | TODO Gerar XML para salvar um .ktr | TODO Gerar XML para salvar um .ktr | @Override
public String getXML() throws KettleException {
StringBuilder xml = new StringBuilder();
XStream xs = new XStream(new DomDriver());
xml.append(XMLHandler.addTagValue(Field.ENDPOINT_URI.name(), endpointUri));
xml.append(XMLHandler.addTagValue(Field.DEFAULT_GRAPH.name(), defaultGraph));
xml.append(XMLHandler.addTagValue(Field.QUERY_STRING.name(), queryString));
xml.append(XMLHandler.addTagValue(Field.PREFIXES.name(), xs.toXML(prefixes)));
xml.append(XMLHandler.addTagValue(Field.VAR_RESULT.name(), varResult));
return xml.toString();
} | [
"@",
"Override",
"public",
"String",
"getXML",
"(",
")",
"throws",
"KettleException",
"{",
"StringBuilder",
"xml",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"XStream",
"xs",
"=",
"new",
"XStream",
"(",
"new",
"DomDriver",
"(",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"ENDPOINT_URI",
".",
"name",
"(",
")",
",",
"endpointUri",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"DEFAULT_GRAPH",
".",
"name",
"(",
")",
",",
"defaultGraph",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"QUERY_STRING",
".",
"name",
"(",
")",
",",
"queryString",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"PREFIXES",
".",
"name",
"(",
")",
",",
"xs",
".",
"toXML",
"(",
"prefixes",
")",
")",
")",
";",
"xml",
".",
"append",
"(",
"XMLHandler",
".",
"addTagValue",
"(",
"Field",
".",
"VAR_RESULT",
".",
"name",
"(",
")",
",",
"varResult",
")",
")",
";",
"return",
"xml",
".",
"toString",
"(",
")",
";",
"}"
] | [
103,
1
] | [
113,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Produto. | null | ======== Impressão ======== | ======== Impressão ======== | @Override
public String toString() {
String print = "Sabor: " + this.sabor + "\nIngredientes: " + getIngredientes();
return print;
} | [
"@",
"Override",
"public",
"String",
"toString",
"(",
")",
"{",
"String",
"print",
"=",
"\"Sabor: \"",
"+",
"this",
".",
"sabor",
"+",
"\"\\nIngredientes: \"",
"+",
"getIngredientes",
"(",
")",
";",
"return",
"print",
";",
"}"
] | [
55,
4
] | [
59,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
TelaCadastrarPacienteController. | null | ------> Ao clica no registro vai preenchendo o formulario acima | ------> Ao clica no registro vai preenchendo o formulario acima | @FXML
private void clicarTabela(MouseEvent event) {
setCamposFormulario();
} | [
"@",
"FXML",
"private",
"void",
"clicarTabela",
"(",
"MouseEvent",
"event",
")",
"{",
"setCamposFormulario",
"(",
")",
";",
"}"
] | [
261,
4
] | [
264,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Jogo. | null | método privado e interno para recebimento de jogada: | método privado e interno para recebimento de jogada: | private boolean fazerJogada() {
Scanner entrada = new Scanner(System.in);
System.out.println();
System.out.println("Insira o movimento que deseja realizar ou digite '0' para interromper a partida.\n");
int l1, l2;
char c1, c2;
String l1String = "";
String l2String = "";
System.out.println("[Coordenadas de origem]");
while(true) {
System.out.println("Insira a coluna origem:");
c1 = entrada.next().charAt(0); //lendo o primeiro caractere da entrada
if (c1 >= 'a' && c1 <= 'h') { //verificação de intervalo válido
break; //caso seja, o loop é finalizado
} else if (c1 == '0') { //caso a entrada seja zero (opção de interrupção)
salvarPartida(); //o método para salvar a partida (arquivo) é invocado
} else {
System.out.println("Entrada inválida! A coluna deve estar entre 'a' e 'h'."); //mensagem de aviso de entrada inválida
System.out.println("");
}
}
while(true) {
try {
System.out.println("Insira a linha origem:");
l1String = entrada.next(); //recebimento da entrada como string
if (l1String != null && l1String.matches("[1-8]")) { //verificação de entrada válida (uso de expressão regular)
l1 = Integer.parseInt(l1String); //conversão para inteiro
break; //quebra do loop, pois o valor é válido
} else if (l1String.matches("[0]")) {
salvarPartida();
} else {
System.out.println("Entrada inválida! A linha deve ser um inteiro entre 1 e 8."); //mensagem de aviso de entrada inválida
System.out.println("");
}
} catch (InputMismatchException e) {
System.out.println("Tipo de entrada inválida, tente novamente.\n");
}
}
System.out.println("\n[Coordenadas de destino]");
while(true) {
System.out.println("Insira a coluna destino:");
c2 = entrada.next().charAt(0); //lendo o primeiro caractere da entrada
if (c2 >= 'a' && c2 <= 'h') { //verificação de intervalo válido
break; //caso seja, o loop é finalizado
} else if (c2 == '0') {
salvarPartida();
} else {
System.out.println("Entrada inválida! A coluna deve estar entre 'a' e 'h'."); //mensagem de aviso de entrada inválida
System.out.println("");
}
}
while(true) {
try {
System.out.println("Insira a linha destino:");
l2String = entrada.next(); //recebimento da entrada como string
if (l2String != null && l2String.matches("[1-8]")) { //verificação de entrada válida (uso de expressão regular)
l2 = Integer.parseInt(l2String); //conversão para inteiro
break; //quebra do loop, pois o valor é válido
} else if (l2String.matches("[0]")) {
salvarPartida();
} else {
System.out.println("Entrada inválida! A linha deve ser inteiro entre 1 e 8."); //mensagem de aviso de entrada inválida
System.out.println("");
}
} catch (InputMismatchException e) {
System.out.println("Tipo de entrada inválida, tente novamente.\n");
}
}
if (getJogada() == 0) { //vez do jogador de peças brancas
if (this.tabuleiro.movimentaPeca(l1-1, c1, l2-1, c2, "branco", true)) { //tentiva de movimentação (com entradas válidas) de peças brancas
return true;
}
} else { //vez do jogador de peças pretas
if (this.tabuleiro.movimentaPeca(l1-1, c1, l2-1, c2, "preto", true)) { //tentiva de movimentação (com entradas válidas) de peças pretas
return true;
}
}
return false; //caso o movimento não seja possível, o retorno é falso
} | [
"private",
"boolean",
"fazerJogada",
"(",
")",
"{",
"Scanner",
"entrada",
"=",
"new",
"Scanner",
"(",
"System",
".",
"in",
")",
";",
"System",
".",
"out",
".",
"println",
"(",
")",
";",
"System",
".",
"out",
".",
"println",
"(",
"\"Insira o movimento que deseja realizar ou digite '0' para interromper a partida.\\n\"",
")",
";",
"int",
"l1",
",",
"l2",
";",
"char",
"c1",
",",
"c2",
";",
"String",
"l1String",
"=",
"\"\"",
";",
"String",
"l2String",
"=",
"\"\"",
";",
"System",
".",
"out",
".",
"println",
"(",
"\"[Coordenadas de origem]\"",
")",
";",
"while",
"(",
"true",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Insira a coluna origem:\"",
")",
";",
"c1",
"=",
"entrada",
".",
"next",
"(",
")",
".",
"charAt",
"(",
"0",
")",
";",
"//lendo o primeiro caractere da entrada",
"if",
"(",
"c1",
">=",
"'",
"'",
"&&",
"c1",
"<=",
"'",
"'",
")",
"{",
"//verificação de intervalo válido",
"break",
";",
"//caso seja, o loop é finalizado",
"}",
"else",
"if",
"(",
"c1",
"==",
"'",
"'",
")",
"{",
"//caso a entrada seja zero (opção de interrupção)",
"salvarPartida",
"(",
")",
";",
"//o método para salvar a partida (arquivo) é invocado",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Entrada inválida! A coluna deve estar entre 'a' e 'h'.\")",
";",
" ",
"/mensagem de aviso de entrada inválida",
"System",
".",
"out",
".",
"println",
"(",
"\"\"",
")",
";",
"}",
"}",
"while",
"(",
"true",
")",
"{",
"try",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Insira a linha origem:\"",
")",
";",
"l1String",
"=",
"entrada",
".",
"next",
"(",
")",
";",
"//recebimento da entrada como string",
"if",
"(",
"l1String",
"!=",
"null",
"&&",
"l1String",
".",
"matches",
"(",
"\"[1-8]\"",
")",
")",
"{",
"//verificação de entrada válida (uso de expressão regular)",
"l1",
"=",
"Integer",
".",
"parseInt",
"(",
"l1String",
")",
";",
"//conversão para inteiro",
"break",
";",
"//quebra do loop, pois o valor é válido",
"}",
"else",
"if",
"(",
"l1String",
".",
"matches",
"(",
"\"[0]\"",
")",
")",
"{",
"salvarPartida",
"(",
")",
";",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Entrada inválida! A linha deve ser um inteiro entre 1 e 8.\")",
";",
" ",
"/mensagem de aviso de entrada inválida",
"System",
".",
"out",
".",
"println",
"(",
"\"\"",
")",
";",
"}",
"}",
"catch",
"(",
"InputMismatchException",
"e",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Tipo de entrada inválida, tente novamente.\\n\")",
";",
"",
"}",
"}",
"System",
".",
"out",
".",
"println",
"(",
"\"\\n[Coordenadas de destino]\"",
")",
";",
"while",
"(",
"true",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Insira a coluna destino:\"",
")",
";",
"c2",
"=",
"entrada",
".",
"next",
"(",
")",
".",
"charAt",
"(",
"0",
")",
";",
"//lendo o primeiro caractere da entrada",
"if",
"(",
"c2",
">=",
"'",
"'",
"&&",
"c2",
"<=",
"'",
"'",
")",
"{",
"//verificação de intervalo válido",
"break",
";",
"//caso seja, o loop é finalizado",
"}",
"else",
"if",
"(",
"c2",
"==",
"'",
"'",
")",
"{",
"salvarPartida",
"(",
")",
";",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Entrada inválida! A coluna deve estar entre 'a' e 'h'.\")",
";",
" ",
"/mensagem de aviso de entrada inválida",
"System",
".",
"out",
".",
"println",
"(",
"\"\"",
")",
";",
"}",
"}",
"while",
"(",
"true",
")",
"{",
"try",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Insira a linha destino:\"",
")",
";",
"l2String",
"=",
"entrada",
".",
"next",
"(",
")",
";",
"//recebimento da entrada como string",
"if",
"(",
"l2String",
"!=",
"null",
"&&",
"l2String",
".",
"matches",
"(",
"\"[1-8]\"",
")",
")",
"{",
"//verificação de entrada válida (uso de expressão regular) ",
"l2",
"=",
"Integer",
".",
"parseInt",
"(",
"l2String",
")",
";",
"//conversão para inteiro",
"break",
";",
"//quebra do loop, pois o valor é válido",
"}",
"else",
"if",
"(",
"l2String",
".",
"matches",
"(",
"\"[0]\"",
")",
")",
"{",
"salvarPartida",
"(",
")",
";",
"}",
"else",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Entrada inválida! A linha deve ser inteiro entre 1 e 8.\")",
";",
" ",
"/mensagem de aviso de entrada inválida",
"System",
".",
"out",
".",
"println",
"(",
"\"\"",
")",
";",
"}",
"}",
"catch",
"(",
"InputMismatchException",
"e",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Tipo de entrada inválida, tente novamente.\\n\")",
";",
"",
"}",
"}",
"if",
"(",
"getJogada",
"(",
")",
"==",
"0",
")",
"{",
"//vez do jogador de peças brancas",
"if",
"(",
"this",
".",
"tabuleiro",
".",
"movimentaPeca",
"(",
"l1",
"-",
"1",
",",
"c1",
",",
"l2",
"-",
"1",
",",
"c2",
",",
"\"branco\"",
",",
"true",
")",
")",
"{",
"//tentiva de movimentação (com entradas válidas) de peças brancas",
"return",
"true",
";",
"}",
"}",
"else",
"{",
"//vez do jogador de peças pretas",
"if",
"(",
"this",
".",
"tabuleiro",
".",
"movimentaPeca",
"(",
"l1",
"-",
"1",
",",
"c1",
",",
"l2",
"-",
"1",
",",
"c2",
",",
"\"preto\"",
",",
"true",
")",
")",
"{",
"//tentiva de movimentação (com entradas válidas) de peças pretas",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"//caso o movimento não seja possível, o retorno é falso",
"}"
] | [
200,
4
] | [
287,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Frame1. | null | Esse idx é o índice da tarefa no nosso ArrayList `tarefas`. | Esse idx é o índice da tarefa no nosso ArrayList `tarefas`. | public static void removerTarefa(int idx) {
try {
tarefas.remove(idx);
Auxiliar.tarefasToJSON(tarefas);
}
catch(Exception e) {
JOptionPane.showMessageDialog(
null,
"Houve um erro ao deletar tarefa!\n" + e.toString(),
"Oops!", 0, UIManager.getIcon("OptionPane.errorIcon")
);
}
} | [
"public",
"static",
"void",
"removerTarefa",
"(",
"int",
"idx",
")",
"{",
"try",
"{",
"tarefas",
".",
"remove",
"(",
"idx",
")",
";",
"Auxiliar",
".",
"tarefasToJSON",
"(",
"tarefas",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"\"Houve um erro ao deletar tarefa!\\n\"",
"+",
"e",
".",
"toString",
"(",
")",
",",
"\"Oops!\"",
",",
"0",
",",
"UIManager",
".",
"getIcon",
"(",
"\"OptionPane.errorIcon\"",
")",
")",
";",
"}",
"}"
] | [
509,
4
] | [
521,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ExemploUso. | null | Só para efeitos de comparação. | Só para efeitos de comparação. | private static Cipher cipherInitializationJV(byte[] keyBytes, byte[] iv)
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
InvalidAlgorithmParameterException, NoSuchProviderException, IOException {
Security.addProvider(new BouncyCastleProvider());
SecretKey key = new SecretKeySpec(keyBytes, "AES");
Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding", "SunJCE");
IvParameterSpec paramSpec = new IvParameterSpec(iv);
SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES");
cipher.init(Cipher.ENCRYPT_MODE, keySpec, paramSpec);
return cipher;
} | [
"private",
"static",
"Cipher",
"cipherInitializationJV",
"(",
"byte",
"[",
"]",
"keyBytes",
",",
"byte",
"[",
"]",
"iv",
")",
"throws",
"NoSuchAlgorithmException",
",",
"NoSuchPaddingException",
",",
"InvalidKeyException",
",",
"InvalidAlgorithmParameterException",
",",
"NoSuchProviderException",
",",
"IOException",
"{",
"Security",
".",
"addProvider",
"(",
"new",
"BouncyCastleProvider",
"(",
")",
")",
";",
"SecretKey",
"key",
"=",
"new",
"SecretKeySpec",
"(",
"keyBytes",
",",
"\"AES\"",
")",
";",
"Cipher",
"cipher",
"=",
"Cipher",
".",
"getInstance",
"(",
"\"AES/CTR/NoPadding\"",
",",
"\"SunJCE\"",
")",
";",
"IvParameterSpec",
"paramSpec",
"=",
"new",
"IvParameterSpec",
"(",
"iv",
")",
";",
"SecretKeySpec",
"keySpec",
"=",
"new",
"SecretKeySpec",
"(",
"key",
".",
"getEncoded",
"(",
")",
",",
"\"AES\"",
")",
";",
"cipher",
".",
"init",
"(",
"Cipher",
".",
"ENCRYPT_MODE",
",",
"keySpec",
",",
"paramSpec",
")",
";",
"return",
"cipher",
";",
"}"
] | [
76,
1
] | [
90,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Gerenciador. | null | método privado e interno para recebimento dos nomes dos jogadores e instanciamento do jogo (situação inicial): | método privado e interno para recebimento dos nomes dos jogadores e instanciamento do jogo (situação inicial): | private void recebeJogadores() {
System.out.println("Por favor, informe os nomes do jogadores da partida.");
Scanner scanner = new Scanner(System.in);
System.out.println("Jogador(a) de peças brancas:");
String nome1 = scanner.nextLine(); //lendo o primeiro nome
System.out.println("Jogador(a) de peças pretas:");
String nome2 = scanner.nextLine(); //lendo o segundo nome
this.jogo = new Jogo(nome1, nome2); //instanciando o objeto do jogo
scanner.close();
} | [
"private",
"void",
"recebeJogadores",
"(",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Por favor, informe os nomes do jogadores da partida.\"",
")",
";",
"Scanner",
"scanner",
"=",
"new",
"Scanner",
"(",
"System",
".",
"in",
")",
";",
"System",
".",
"out",
".",
"println",
"(",
"\"Jogador(a) de peças brancas:\")",
";",
"",
"String",
"nome1",
"=",
"scanner",
".",
"nextLine",
"(",
")",
";",
"//lendo o primeiro nome",
"System",
".",
"out",
".",
"println",
"(",
"\"Jogador(a) de peças pretas:\")",
";",
"",
"String",
"nome2",
"=",
"scanner",
".",
"nextLine",
"(",
")",
";",
"//lendo o segundo nome",
"this",
".",
"jogo",
"=",
"new",
"Jogo",
"(",
"nome1",
",",
"nome2",
")",
";",
"//instanciando o objeto do jogo",
"scanner",
".",
"close",
"(",
")",
";",
"}"
] | [
49,
4
] | [
58,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FuncoesTopicos. | null | Retorn uma lista de imoveis ordenados em ordem crescente de valor | Retorn uma lista de imoveis ordenados em ordem crescente de valor | public static List<Imovel> q5FiltraPorTipo(String tipo) {
String tipoCompleto = "backend." + tipo;
List<Imovel> resultado = new ArrayList<>();
//Utiliza o iterador imovel para percorrer a lista
for (Imovel imovel : imoveis) {
//Compara se o tipo do imovel atual é o mesmo que o desejado
if (imovel.getClass().getName().equals(tipoCompleto)) {
resultado.add(imovel);
}
}
//Realiza a ordenação da lista
Collections.sort(resultado);
return resultado;
} | [
"public",
"static",
"List",
"<",
"Imovel",
">",
"q5FiltraPorTipo",
"(",
"String",
"tipo",
")",
"{",
"String",
"tipoCompleto",
"=",
"\"backend.\"",
"+",
"tipo",
";",
"List",
"<",
"Imovel",
">",
"resultado",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"//Utiliza o iterador imovel para percorrer a lista",
"for",
"(",
"Imovel",
"imovel",
":",
"imoveis",
")",
"{",
"//Compara se o tipo do imovel atual é o mesmo que o desejado",
"if",
"(",
"imovel",
".",
"getClass",
"(",
")",
".",
"getName",
"(",
")",
".",
"equals",
"(",
"tipoCompleto",
")",
")",
"{",
"resultado",
".",
"add",
"(",
"imovel",
")",
";",
"}",
"}",
"//Realiza a ordenação da lista",
"Collections",
".",
"sort",
"(",
"resultado",
")",
";",
"return",
"resultado",
";",
"}"
] | [
88,
4
] | [
104,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Tabuleiro. | null | método que verifica as posições de um determinado movimento estão dentro do tabuleiro: | método que verifica as posições de um determinado movimento estão dentro do tabuleiro: | private boolean limitesTabuleiro(Posicao pInicial, Posicao pFinal) {
//verificando se a linha e coluna de ambas as posições estão dentro do tabuleiro:
if (pInicial.getLinha() >= 0 && pInicial.getLinha() < 8 && pInicial.getColuna() >= 'a' && pInicial.getColuna() <= 'h' && pFinal.getLinha() >= 0 && pFinal.getLinha() < 8 && pFinal.getColuna() >= 'a' && pFinal.getColuna() <= 'h') {
return true;
} else {
return false;
}
} | [
"private",
"boolean",
"limitesTabuleiro",
"(",
"Posicao",
"pInicial",
",",
"Posicao",
"pFinal",
")",
"{",
"//verificando se a linha e coluna de ambas as posições estão dentro do tabuleiro:",
"if",
"(",
"pInicial",
".",
"getLinha",
"(",
")",
">=",
"0",
"&&",
"pInicial",
".",
"getLinha",
"(",
")",
"<",
"8",
"&&",
"pInicial",
".",
"getColuna",
"(",
")",
">=",
"'",
"'",
"&&",
"pInicial",
".",
"getColuna",
"(",
")",
"<=",
"'",
"'",
"&&",
"pFinal",
".",
"getLinha",
"(",
")",
">=",
"0",
"&&",
"pFinal",
".",
"getLinha",
"(",
")",
"<",
"8",
"&&",
"pFinal",
".",
"getColuna",
"(",
")",
">=",
"'",
"'",
"&&",
"pFinal",
".",
"getColuna",
"(",
")",
"<=",
"'",
"'",
")",
"{",
"return",
"true",
";",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"}"
] | [
276,
4
] | [
283,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
AutenticacaoActivity. | null | Método responsável por abrir a tela principal | Método responsável por abrir a tela principal | private void abrirTelaPrincipal(String tipoUsuario) {
if(tipoUsuario.equals("E")){
startActivity(new Intent(getApplicationContext(), EmpresaActivity.class));
finish();
}else {
startActivity(new Intent(getApplicationContext(), HomeActivity.class));
finish();
}
} | [
"private",
"void",
"abrirTelaPrincipal",
"(",
"String",
"tipoUsuario",
")",
"{",
"if",
"(",
"tipoUsuario",
".",
"equals",
"(",
"\"E\"",
")",
")",
"{",
"startActivity",
"(",
"new",
"Intent",
"(",
"getApplicationContext",
"(",
")",
",",
"EmpresaActivity",
".",
"class",
")",
")",
";",
"finish",
"(",
")",
";",
"}",
"else",
"{",
"startActivity",
"(",
"new",
"Intent",
"(",
"getApplicationContext",
"(",
")",
",",
"HomeActivity",
".",
"class",
")",
")",
";",
"finish",
"(",
")",
";",
"}",
"}"
] | [
157,
4
] | [
165,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
CategoriaRequest. | null | /* Jackson não está serializando dados para construtor com um parâmetro | /* Jackson não está serializando dados para construtor com um parâmetro | public void setNome(@NotBlank String nome) {
this.nome = nome;
} | [
"public",
"void",
"setNome",
"(",
"@",
"NotBlank",
"String",
"nome",
")",
"{",
"this",
".",
"nome",
"=",
"nome",
";",
"}"
] | [
20,
4
] | [
22,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
aula05ex. | null | posição número 1 fica 102 e por aí adiante. | posição número 1 fica 102 e por aí adiante. | public static int[] array50(){
int[] intArray = new int[50];
int startNum = 101;
for (int i=0; i<50; i++){
// Introduz o numero inicial (101) na posiçao do vector e incrementa o num para o proximo ciclo
intArray[i] = startNum++;
}
return intArray;
} | [
"public",
"static",
"int",
"[",
"]",
"array50",
"(",
")",
"{",
"int",
"[",
"]",
"intArray",
"=",
"new",
"int",
"[",
"50",
"]",
";",
"int",
"startNum",
"=",
"101",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"50",
";",
"i",
"++",
")",
"{",
"// Introduz o numero inicial (101) na posiçao do vector e incrementa o num para o proximo ciclo",
"intArray",
"[",
"i",
"]",
"=",
"startNum",
"++",
";",
"}",
"return",
"intArray",
";",
"}"
] | [
92,
4
] | [
100,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
UsuarioController. | null | Salva um usuário | Salva um usuário | @RequestMapping(value="/usuario", method=RequestMethod.POST)
@ApiOperation(value="Salva um usuário")
@ResponseStatus(HttpStatus.CREATED)
public ResponseEntity<?> salvaUsuario(@RequestBody Usuario usuario) {
Usuario obj = usuarioService.salvaUsuario(usuario);
return ResponseEntity.ok().body(obj);
} | [
"@",
"RequestMapping",
"(",
"value",
"=",
"\"/usuario\"",
",",
"method",
"=",
"RequestMethod",
".",
"POST",
")",
"@",
"ApiOperation",
"(",
"value",
"=",
"\"Salva um usuário\")",
"",
"@",
"ResponseStatus",
"(",
"HttpStatus",
".",
"CREATED",
")",
"public",
"ResponseEntity",
"<",
"?",
">",
"salvaUsuario",
"(",
"@",
"RequestBody",
"Usuario",
"usuario",
")",
"{",
"Usuario",
"obj",
"=",
"usuarioService",
".",
"salvaUsuario",
"(",
"usuario",
")",
";",
"return",
"ResponseEntity",
".",
"ok",
"(",
")",
".",
"body",
"(",
"obj",
")",
";",
"}"
] | [
45,
1
] | [
51,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Main. | null | =========== Método para listar todos os Usuários Cadastrados =========== | =========== Método para listar todos os Usuários Cadastrados =========== | private void listarCadastros() {
try {
Cadastro.dao.UsuarioDAO.listarTodosCadastros();
} catch (SQLException exception) {
System.out.println("Erro ao listar: " + exception);
exception.printStackTrace();
}
} | [
"private",
"void",
"listarCadastros",
"(",
")",
"{",
"try",
"{",
"Cadastro",
".",
"dao",
".",
"UsuarioDAO",
".",
"listarTodosCadastros",
"(",
")",
";",
"}",
"catch",
"(",
"SQLException",
"exception",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\"Erro ao listar: \"",
"+",
"exception",
")",
";",
"exception",
".",
"printStackTrace",
"(",
")",
";",
"}",
"}"
] | [
97,
1
] | [
105,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
PacientesResources. | null | Salvando o Produto via postman no banco de Dados | Salvando o Produto via postman no banco de Dados | @PostMapping("/pacientes")
@ApiOperation(value="Adicionar Paciente")
public Pacientes salvaPaciente(@RequestBody Pacientes paciente){
return pacienteRepository.save(paciente);
} | [
"@",
"PostMapping",
"(",
"\"/pacientes\"",
")",
"@",
"ApiOperation",
"(",
"value",
"=",
"\"Adicionar Paciente\"",
")",
"public",
"Pacientes",
"salvaPaciente",
"(",
"@",
"RequestBody",
"Pacientes",
"paciente",
")",
"{",
"return",
"pacienteRepository",
".",
"save",
"(",
"paciente",
")",
";",
"}"
] | [
47,
1
] | [
52,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
TelaOS. | null | método para alterar uma OS | método para alterar uma OS | private void alterar_os() {
String sql = "update tbos set tipo=?,situacao=?,equipamento=?,defeito=?,servico=?,tecnico=?,valor=? where os=?";
try {
pst = conexao.prepareStatement(sql);
pst.setString(1, tipo);
pst.setString(2, cboOsSit.getSelectedItem().toString());
pst.setString(3, txtOsEquip.getText());
pst.setString(4, txtOsDef.getText());
pst.setString(5, txtOsServ.getText());
pst.setString(6, txtOsTec.getText());
//.replace substitui a vírgula pelo ponto
pst.setString(7, txtOsValor.getText().replace(",", "."));
pst.setString(8, txtOs.getText());
//validação dos campos obrigatórios
if ((txtCliId.getText().isEmpty()) || (txtOsEquip.getText().isEmpty()) || (txtOsDef.getText().isEmpty())) {
JOptionPane.showMessageDialog(null, "Preencha todos os campos obrigatórios");
} else {
int adicionado = pst.executeUpdate();
if (adicionado > 0) {
JOptionPane.showMessageDialog(null, "OS alterada com sucesso");
txtOs.setText(null);
txtData.setText(null);
txtCliId.setText(null);
txtOsEquip.setText(null);
txtOsDef.setText(null);
txtOsServ.setText(null);
txtOsTec.setText(null);
txtOsValor.setText(null);
//habilitar os objetos
btnOsAdicionar.setEnabled(true);
txtCliPesquisar.setEnabled(true);
tblClientes.setVisible(true);
}
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e);
}
} | [
"private",
"void",
"alterar_os",
"(",
")",
"{",
"String",
"sql",
"=",
"\"update tbos set tipo=?,situacao=?,equipamento=?,defeito=?,servico=?,tecnico=?,valor=? where os=?\"",
";",
"try",
"{",
"pst",
"=",
"conexao",
".",
"prepareStatement",
"(",
"sql",
")",
";",
"pst",
".",
"setString",
"(",
"1",
",",
"tipo",
")",
";",
"pst",
".",
"setString",
"(",
"2",
",",
"cboOsSit",
".",
"getSelectedItem",
"(",
")",
".",
"toString",
"(",
")",
")",
";",
"pst",
".",
"setString",
"(",
"3",
",",
"txtOsEquip",
".",
"getText",
"(",
")",
")",
";",
"pst",
".",
"setString",
"(",
"4",
",",
"txtOsDef",
".",
"getText",
"(",
")",
")",
";",
"pst",
".",
"setString",
"(",
"5",
",",
"txtOsServ",
".",
"getText",
"(",
")",
")",
";",
"pst",
".",
"setString",
"(",
"6",
",",
"txtOsTec",
".",
"getText",
"(",
")",
")",
";",
"//.replace substitui a vírgula pelo ponto",
"pst",
".",
"setString",
"(",
"7",
",",
"txtOsValor",
".",
"getText",
"(",
")",
".",
"replace",
"(",
"\",\"",
",",
"\".\"",
")",
")",
";",
"pst",
".",
"setString",
"(",
"8",
",",
"txtOs",
".",
"getText",
"(",
")",
")",
";",
"//validação dos campos obrigatórios",
"if",
"(",
"(",
"txtCliId",
".",
"getText",
"(",
")",
".",
"isEmpty",
"(",
")",
")",
"||",
"(",
"txtOsEquip",
".",
"getText",
"(",
")",
".",
"isEmpty",
"(",
")",
")",
"||",
"(",
"txtOsDef",
".",
"getText",
"(",
")",
".",
"isEmpty",
"(",
")",
")",
")",
"{",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"\"Preencha todos os campos obrigatórios\")",
";",
"",
"}",
"else",
"{",
"int",
"adicionado",
"=",
"pst",
".",
"executeUpdate",
"(",
")",
";",
"if",
"(",
"adicionado",
">",
"0",
")",
"{",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"\"OS alterada com sucesso\"",
")",
";",
"txtOs",
".",
"setText",
"(",
"null",
")",
";",
"txtData",
".",
"setText",
"(",
"null",
")",
";",
"txtCliId",
".",
"setText",
"(",
"null",
")",
";",
"txtOsEquip",
".",
"setText",
"(",
"null",
")",
";",
"txtOsDef",
".",
"setText",
"(",
"null",
")",
";",
"txtOsServ",
".",
"setText",
"(",
"null",
")",
";",
"txtOsTec",
".",
"setText",
"(",
"null",
")",
";",
"txtOsValor",
".",
"setText",
"(",
"null",
")",
";",
"//habilitar os objetos",
"btnOsAdicionar",
".",
"setEnabled",
"(",
"true",
")",
";",
"txtCliPesquisar",
".",
"setEnabled",
"(",
"true",
")",
";",
"tblClientes",
".",
"setVisible",
"(",
"true",
")",
";",
"}",
"}",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"e",
")",
";",
"}",
"}"
] | [
135,
4
] | [
174,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
SecurityConfiguration. | null | configuracao de recursos estáticos(css, js, imagens) | configuracao de recursos estáticos(css, js, imagens) | @Override
public void configure(WebSecurity web) throws Exception {
web.ignoring().antMatchers("/**.html", "/v2/api-docs", "/webjars/**", "/configuration/**", "/swagger-resourses");
} | [
"@",
"Override",
"public",
"void",
"configure",
"(",
"WebSecurity",
"web",
")",
"throws",
"Exception",
"{",
"web",
".",
"ignoring",
"(",
")",
".",
"antMatchers",
"(",
"\"/**.html\"",
",",
"\"/v2/api-docs\"",
",",
"\"/webjars/**\"",
",",
"\"/configuration/**\"",
",",
"\"/swagger-resourses\"",
")",
";",
"}"
] | [
59,
2
] | [
62,
3
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
UsuarioController. | null | Retorna uma lista de Usuários | Retorna uma lista de Usuários | @RequestMapping(value="/", method=RequestMethod.GET)
@ApiOperation(value="Retorna uma lista de Usuários")
public ResponseEntity<?> listaUsuarios(){
List<Usuario> obj = usuarioService.listaUsuarios();
return ResponseEntity.ok().body(obj);
} | [
"@",
"RequestMapping",
"(",
"value",
"=",
"\"/\"",
",",
"method",
"=",
"RequestMethod",
".",
"GET",
")",
"@",
"ApiOperation",
"(",
"value",
"=",
"\"Retorna uma lista de Usuários\")",
"",
"public",
"ResponseEntity",
"<",
"?",
">",
"listaUsuarios",
"(",
")",
"{",
"List",
"<",
"Usuario",
">",
"obj",
"=",
"usuarioService",
".",
"listaUsuarios",
"(",
")",
";",
"return",
"ResponseEntity",
".",
"ok",
"(",
")",
".",
"body",
"(",
"obj",
")",
";",
"}"
] | [
29,
1
] | [
34,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
EnviarCorreo. | null | Getter para atributo Host | Getter para atributo Host | public String getHost()
{
return Host;
} | [
"public",
"String",
"getHost",
"(",
")",
"{",
"return",
"Host",
";",
"}"
] | [
135,
4
] | [
138,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
LBSTree. | null | Percorrer os nodos em uma ordem desejada | Percorrer os nodos em uma ordem desejada | public String caminhar(int nodo) {
treeString = "\n";
switch (nodo) {
case PREOrder:
preOrder(raiz);
break;
case INOrder:
inOrder(raiz);
break;
case POSTOrder:
postOrder(raiz);
break;
default:
System.out.println("ERRO: Modo de caminhamento desconhecido!");
}
return(treeString);
} | [
"public",
"String",
"caminhar",
"(",
"int",
"nodo",
")",
"{",
"treeString",
"=",
"\"\\n\"",
";",
"switch",
"(",
"nodo",
")",
"{",
"case",
"PREOrder",
":",
"preOrder",
"(",
"raiz",
")",
";",
"break",
";",
"case",
"INOrder",
":",
"inOrder",
"(",
"raiz",
")",
";",
"break",
";",
"case",
"POSTOrder",
":",
"postOrder",
"(",
"raiz",
")",
";",
"break",
";",
"default",
":",
"System",
".",
"out",
".",
"println",
"(",
"\"ERRO: Modo de caminhamento desconhecido!\"",
")",
";",
"}",
"return",
"(",
"treeString",
")",
";",
"}"
] | [
177,
1
] | [
193,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Main. | null | método que retorna um caractere que representa se existe ou não impedimento de acordo com o vetor de atacantes e defensores recebido | método que retorna um caractere que representa se existe ou não impedimento de acordo com o vetor de atacantes e defensores recebido | public static Character distances(int[] B, int[] C){
/*por eficiência a para evitar erros de acesso inválido, as condicionais a seguir avaliam se existem elementos nos vetores de defensores
e retornam uma resposta correspondente, por exemplo, não havendo atacantes, não existe impedimento*/
if(B.length == 0){return 'N';}
if(C.length == 0){return 'Y';}
//ordena ambos vetores recebidos para comparar seus valores
Arrays.sort(B);
Arrays.sort(C);
//caso o atacante mais próximo esteja mais perto do gol que o segundo defensor mais próximo, ele está impedido
if(B[0]<C[1]){return 'Y';}
//caso contrário, não está
else{return 'N';}
} | [
"public",
"static",
"Character",
"distances",
"(",
"int",
"[",
"]",
"B",
",",
"int",
"[",
"]",
"C",
")",
"{",
"/*por eficiência a para evitar erros de acesso inválido, as condicionais a seguir avaliam se existem elementos nos vetores de defensores\n e retornam uma resposta correspondente, por exemplo, não havendo atacantes, não existe impedimento*/",
"if",
"(",
"B",
".",
"length",
"==",
"0",
")",
"{",
"return",
"'",
"'",
";",
"}",
"if",
"(",
"C",
".",
"length",
"==",
"0",
")",
"{",
"return",
"'",
"'",
";",
"}",
"//ordena ambos vetores recebidos para comparar seus valores",
"Arrays",
".",
"sort",
"(",
"B",
")",
";",
"Arrays",
".",
"sort",
"(",
"C",
")",
";",
"//caso o atacante mais próximo esteja mais perto do gol que o segundo defensor mais próximo, ele está impedido",
"if",
"(",
"B",
"[",
"0",
"]",
"<",
"C",
"[",
"1",
"]",
")",
"{",
"return",
"'",
"'",
";",
"}",
"//caso contrário, não está",
"else",
"{",
"return",
"'",
"'",
";",
"}",
"}"
] | [
40,
4
] | [
54,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
SecurityConfig. | null | Metodo para chamar toda a autenticação. Esse metodo chama a autenticação e criptografa a mesma | Metodo para chamar toda a autenticação. Esse metodo chama a autenticação e criptografa a mesma | @Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userService)
.passwordEncoder(new BCryptPasswordEncoder());
} | [
"@",
"Override",
"protected",
"void",
"configure",
"(",
"AuthenticationManagerBuilder",
"auth",
")",
"throws",
"Exception",
"{",
"auth",
".",
"userDetailsService",
"(",
"userService",
")",
".",
"passwordEncoder",
"(",
"new",
"BCryptPasswordEncoder",
"(",
")",
")",
";",
"}"
] | [
66,
4
] | [
70,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Tela. | null | finaliza a partida para o player1 | finaliza a partida para o player1 | public void finalizaP1(){
switch(id){
case 1:
valor = JOptionPane.showOptionDialog(this, "Você ganhou!", "Fim de Jogo!",JOptionPane.PLAIN_MESSAGE, JOptionPane.PLAIN_MESSAGE,null, opcoes,opcoes[0]);
break;
case 2:
valor = JOptionPane.showOptionDialog(this, "Você perdeu!", "Fim de Jogo!",JOptionPane.PLAIN_MESSAGE, JOptionPane.PLAIN_MESSAGE,null, opcoes,opcoes[0]);
break;
}
valor();
} | [
"public",
"void",
"finalizaP1",
"(",
")",
"{",
"switch",
"(",
"id",
")",
"{",
"case",
"1",
":",
"valor",
"=",
"JOptionPane",
".",
"showOptionDialog",
"(",
"this",
",",
"\"Você ganhou!\",",
" ",
"Fim de Jogo!\",",
"J",
"OptionPane.",
"P",
"LAIN_MESSAGE,",
" ",
"OptionPane.",
"P",
"LAIN_MESSAGE,",
"n",
"ull,",
" ",
"pcoes,",
"o",
"pcoes[",
"0",
"]",
")",
";",
"",
"break",
";",
"case",
"2",
":",
"valor",
"=",
"JOptionPane",
".",
"showOptionDialog",
"(",
"this",
",",
"\"Você perdeu!\",",
" ",
"Fim de Jogo!\",",
"J",
"OptionPane.",
"P",
"LAIN_MESSAGE,",
" ",
"OptionPane.",
"P",
"LAIN_MESSAGE,",
"n",
"ull,",
" ",
"pcoes,",
"o",
"pcoes[",
"0",
"]",
")",
";",
"",
"break",
";",
"}",
"valor",
"(",
")",
";",
"}"
] | [
166,
4
] | [
176,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
SearchLanguage. | null | /*public String containLang(){ precisa criar uma tratamento de erro caso o item não esteja na lista.
if(list.contains(lang)){
return "Procurando item: ";
} else {
return "Item não consta na lista";
}
} | /*public String containLang(){ precisa criar uma tratamento de erro caso o item não esteja na lista.
if(list.contains(lang)){
return "Procurando item: ";
} else {
return "Item não consta na lista";
}
} | public int times() {
int size = 0;
String item = "";
for (int i = 0; i < list.size(); i++) {
item = list.get(i);
if (lang.getName().equals(item)) {
size++;
}
}
return size;
} | [
"public",
"int",
"times",
"(",
")",
"{",
"int",
"size",
"=",
"0",
";",
"String",
"item",
"=",
"\"\"",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"list",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"item",
"=",
"list",
".",
"get",
"(",
"i",
")",
";",
"if",
"(",
"lang",
".",
"getName",
"(",
")",
".",
"equals",
"(",
"item",
")",
")",
"{",
"size",
"++",
";",
"}",
"}",
"return",
"size",
";",
"}"
] | [
24,
4
] | [
35,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
MainSceneController. | null | Metodo para tratar o evento do menu item TURMA | Metodo para tratar o evento do menu item TURMA | @FXML
public void onMenuItemTurmaAction() {
loadView("TurmaControllerView.fxml", (TurmaController controller) -> {
controller.setTurmaService(new TurmaService()); //ProfessorService tem metodo que recebe colecao de PROFESSOR
controller.updateTableView(); //Metodo updateView recebe
});
} | [
"@",
"FXML",
"public",
"void",
"onMenuItemTurmaAction",
"(",
")",
"{",
"loadView",
"(",
"\"TurmaControllerView.fxml\"",
",",
"(",
"TurmaController",
"controller",
")",
"->",
"{",
"controller",
".",
"setTurmaService",
"(",
"new",
"TurmaService",
"(",
")",
")",
";",
"//ProfessorService tem metodo que recebe colecao de PROFESSOR",
"controller",
".",
"updateTableView",
"(",
")",
";",
"//Metodo updateView recebe ",
"}",
")",
";",
"}"
] | [
63,
4
] | [
69,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Bank. | null | Devolve a conta com o maior saldo | Devolve a conta com o maior saldo | public BankAccount getMaximum() {
BankAccount maior = accounts.get(0);
for (int i = 1; i < accounts.size(); i++)
if (accounts.get(i).getBalance() > maior.getBalance())
maior = accounts.get(i);
return maior;
} | [
"public",
"BankAccount",
"getMaximum",
"(",
")",
"{",
"BankAccount",
"maior",
"=",
"accounts",
".",
"get",
"(",
"0",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"accounts",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"if",
"(",
"accounts",
".",
"get",
"(",
"i",
")",
".",
"getBalance",
"(",
")",
">",
"maior",
".",
"getBalance",
"(",
")",
")",
"maior",
"=",
"accounts",
".",
"get",
"(",
"i",
")",
";",
"return",
"maior",
";",
"}"
] | [
84,
4
] | [
90,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Professor. | null | Professor consulta os nomes dos alunos cadastrados em uma disciplina | Professor consulta os nomes dos alunos cadastrados em uma disciplina | public void consultar (int matriculaDisciplina) {
for (Disciplina disciplina : disciplinasLecionadas) {
if (disciplina.getID() == matriculaDisciplina)
disciplina.getAlunosMatriculados();
}
} | [
"public",
"void",
"consultar",
"(",
"int",
"matriculaDisciplina",
")",
"{",
"for",
"(",
"Disciplina",
"disciplina",
":",
"disciplinasLecionadas",
")",
"{",
"if",
"(",
"disciplina",
".",
"getID",
"(",
")",
"==",
"matriculaDisciplina",
")",
"disciplina",
".",
"getAlunosMatriculados",
"(",
")",
";",
"}",
"}"
] | [
15,
4
] | [
20,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
AdapterProduto. | null | Fazendo a contagem de produtos | Fazendo a contagem de produtos | @Override
public int getItemCount() {
return produtos.size();
} | [
"@",
"Override",
"public",
"int",
"getItemCount",
"(",
")",
"{",
"return",
"produtos",
".",
"size",
"(",
")",
";",
"}"
] | [
41,
4
] | [
44,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
NetworkToolkit. | null | Responsavel por realizar a operação de PUT | Responsavel por realizar a operação de PUT | public static String doPut(String url, String putContent) {
String retorno = "";
try {
URL apiEnd = new URL(url);
int codigoResposta;
HttpURLConnection conexao;
InputStream is;
conexao = (HttpURLConnection) apiEnd.openConnection();
conexao.setRequestMethod("PUT");
conexao.setReadTimeout(15000);
conexao.setConnectTimeout(15000);
conexao.setDoInput(true);
conexao.setDoOutput(true);
OutputStream os = conexao.getOutputStream();
PrintStream ps = new PrintStream(os);
ps.print(putContent);
ps.close();
conexao.connect();
codigoResposta = conexao.getResponseCode();
if(codigoResposta < HttpURLConnection.HTTP_BAD_REQUEST){
is = conexao.getInputStream();
}else{
is = conexao.getErrorStream();
}
retorno = converterInputStreamToString(is);
os.close();
conexao.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return retorno;
} | [
"public",
"static",
"String",
"doPut",
"(",
"String",
"url",
",",
"String",
"putContent",
")",
"{",
"String",
"retorno",
"=",
"\"\"",
";",
"try",
"{",
"URL",
"apiEnd",
"=",
"new",
"URL",
"(",
"url",
")",
";",
"int",
"codigoResposta",
";",
"HttpURLConnection",
"conexao",
";",
"InputStream",
"is",
";",
"conexao",
"=",
"(",
"HttpURLConnection",
")",
"apiEnd",
".",
"openConnection",
"(",
")",
";",
"conexao",
".",
"setRequestMethod",
"(",
"\"PUT\"",
")",
";",
"conexao",
".",
"setReadTimeout",
"(",
"15000",
")",
";",
"conexao",
".",
"setConnectTimeout",
"(",
"15000",
")",
";",
"conexao",
".",
"setDoInput",
"(",
"true",
")",
";",
"conexao",
".",
"setDoOutput",
"(",
"true",
")",
";",
"OutputStream",
"os",
"=",
"conexao",
".",
"getOutputStream",
"(",
")",
";",
"PrintStream",
"ps",
"=",
"new",
"PrintStream",
"(",
"os",
")",
";",
"ps",
".",
"print",
"(",
"putContent",
")",
";",
"ps",
".",
"close",
"(",
")",
";",
"conexao",
".",
"connect",
"(",
")",
";",
"codigoResposta",
"=",
"conexao",
".",
"getResponseCode",
"(",
")",
";",
"if",
"(",
"codigoResposta",
"<",
"HttpURLConnection",
".",
"HTTP_BAD_REQUEST",
")",
"{",
"is",
"=",
"conexao",
".",
"getInputStream",
"(",
")",
";",
"}",
"else",
"{",
"is",
"=",
"conexao",
".",
"getErrorStream",
"(",
")",
";",
"}",
"retorno",
"=",
"converterInputStreamToString",
"(",
"is",
")",
";",
"os",
".",
"close",
"(",
")",
";",
"conexao",
".",
"disconnect",
"(",
")",
";",
"}",
"catch",
"(",
"MalformedURLException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"return",
"retorno",
";",
"}"
] | [
97,
4
] | [
139,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ConfiguracaoSeguranca. | null | configurações de autenticação | configurações de autenticação | @Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(servicoAutenticacao).passwordEncoder(new BCryptPasswordEncoder());
} | [
"@",
"Override",
"protected",
"void",
"configure",
"(",
"AuthenticationManagerBuilder",
"auth",
")",
"throws",
"Exception",
"{",
"auth",
".",
"userDetailsService",
"(",
"servicoAutenticacao",
")",
".",
"passwordEncoder",
"(",
"new",
"BCryptPasswordEncoder",
"(",
")",
")",
";",
"}"
] | [
39,
1
] | [
42,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ServidorUDP. | null | Conversão de um vetor de bytes em uma String | Conversão de um vetor de bytes em uma String | public static StringBuilder data(byte[] a) {
if (a == null) {
return null;
}
StringBuilder ret = new StringBuilder();
int i = 0;
while (a[i] != 0) {
ret.append((char) a[i]);
i++;
}
return ret;
} | [
"public",
"static",
"StringBuilder",
"data",
"(",
"byte",
"[",
"]",
"a",
")",
"{",
"if",
"(",
"a",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"StringBuilder",
"ret",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"int",
"i",
"=",
"0",
";",
"while",
"(",
"a",
"[",
"i",
"]",
"!=",
"0",
")",
"{",
"ret",
".",
"append",
"(",
"(",
"char",
")",
"a",
"[",
"i",
"]",
")",
";",
"i",
"++",
";",
"}",
"return",
"ret",
";",
"}"
] | [
49,
4
] | [
60,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Tabuleiro. | null | Array de caracter que simula um tabuleiro de jogo da velha 3x3 | Array de caracter que simula um tabuleiro de jogo da velha 3x3 | public void mostrar() { //metodo para percorrer o array tabuleiro e exibir sua posições
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(tabuleiro[i][j] + "|");
}
System.out.println();
}
} | [
"public",
"void",
"mostrar",
"(",
")",
"{",
"//metodo para percorrer o array tabuleiro e exibir sua posições",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"3",
";",
"i",
"++",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"3",
";",
"j",
"++",
")",
"{",
"System",
".",
"out",
".",
"print",
"(",
"tabuleiro",
"[",
"i",
"]",
"[",
"j",
"]",
"+",
"\"|\"",
")",
";",
"}",
"System",
".",
"out",
".",
"println",
"(",
")",
";",
"}",
"}"
] | [
24,
8
] | [
32,
9
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
EspecieController. | null | Deleta uma especie | Deleta uma especie | @RequestMapping(value="/especie", method=RequestMethod.DELETE)
@ApiOperation(value="Deleta uma especie")
public void deletaBioterio(@RequestBody Especie especie) {
especieService.deletaEspecie(especie);
} | [
"@",
"RequestMapping",
"(",
"value",
"=",
"\"/especie\"",
",",
"method",
"=",
"RequestMethod",
".",
"DELETE",
")",
"@",
"ApiOperation",
"(",
"value",
"=",
"\"Deleta uma especie\"",
")",
"public",
"void",
"deletaBioterio",
"(",
"@",
"RequestBody",
"Especie",
"especie",
")",
"{",
"especieService",
".",
"deletaEspecie",
"(",
"especie",
")",
";",
"}"
] | [
54,
1
] | [
58,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FXMLEntregaController. | null | Carrega o combobox com os pedidos para inserção de uma entrega | Carrega o combobox com os pedidos para inserção de uma entrega | public void carregarComboBoxPedido() {
listaPedido = pedidoService.listAll();
observableListPedido = FXCollections.observableArrayList(listaPedido);
comboboxPedido.setItems(observableListPedido);
} | [
"public",
"void",
"carregarComboBoxPedido",
"(",
")",
"{",
"listaPedido",
"=",
"pedidoService",
".",
"listAll",
"(",
")",
";",
"observableListPedido",
"=",
"FXCollections",
".",
"observableArrayList",
"(",
"listaPedido",
")",
";",
"comboboxPedido",
".",
"setItems",
"(",
"observableListPedido",
")",
";",
"}"
] | [
136,
1
] | [
140,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Tabuleiro. | null | método privado e interno para troca de peças, caso o movimento seja válido: | método privado e interno para troca de peças, caso o movimento seja válido: | private void trocaPecas(Posicao inicio, Posicao fim) {
if (!fim.getStatus()) { //se a posição destino estiver ocupada (movimento "de comer")
fim.getPeca().setStatus(false); //a peça "comida" é retirada do jogo
} //se a posição destino estiver livre (movimento simples - "só andou")
fim.setPeca(inicio.getPeca()); //a peça presente na posição final passa a ser a peça que estava na posição inicial
inicio.setStatus(true); //a posição inicial se torna livre (desocupada)
inicio.setPeca(null); //o objeto Peca que ocupava a posição início passa a ser nulo
fim.setStatus(false); //a posição final se torna ocupada (status = false)
} | [
"private",
"void",
"trocaPecas",
"(",
"Posicao",
"inicio",
",",
"Posicao",
"fim",
")",
"{",
"if",
"(",
"!",
"fim",
".",
"getStatus",
"(",
")",
")",
"{",
"//se a posição destino estiver ocupada (movimento \"de comer\")",
"fim",
".",
"getPeca",
"(",
")",
".",
"setStatus",
"(",
"false",
")",
";",
"//a peça \"comida\" é retirada do jogo",
"}",
"//se a posição destino estiver livre (movimento simples - \"só andou\")",
"fim",
".",
"setPeca",
"(",
"inicio",
".",
"getPeca",
"(",
")",
")",
";",
"//a peça presente na posição final passa a ser a peça que estava na posição inicial",
"inicio",
".",
"setStatus",
"(",
"true",
")",
";",
"//a posição inicial se torna livre (desocupada)",
"inicio",
".",
"setPeca",
"(",
"null",
")",
";",
"//o objeto Peca que ocupava a posição início passa a ser nulo",
"fim",
".",
"setStatus",
"(",
"false",
")",
";",
"//a posição final se torna ocupada (status = false)",
"}"
] | [
453,
4
] | [
461,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
BuscaDominioController. | null | Esta método é para remover um domínio. | Esta método é para remover um domínio. | @GetMapping("/remover/{id}")
public String remover(@PathVariable("id") Integer idDominio, RedirectAttributes attr) {
dominioRepository.deleteById(idDominio);
return "redirect:/dominio/buscar";
} | [
"@",
"GetMapping",
"(",
"\"/remover/{id}\"",
")",
"public",
"String",
"remover",
"(",
"@",
"PathVariable",
"(",
"\"id\"",
")",
"Integer",
"idDominio",
",",
"RedirectAttributes",
"attr",
")",
"{",
"dominioRepository",
".",
"deleteById",
"(",
"idDominio",
")",
";",
"return",
"\"redirect:/dominio/buscar\"",
";",
"}"
] | [
45,
2
] | [
49,
3
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ASCIInterface. | null | Calcular quanto tamanho vertical(de linhas) é necessario para
* colocar um array
@param array é o array de Strings com o conteúdo que o usuário quer inserir
@param largura é o tamanho máximo de linhas
@return numero de linhas necessaria para colocar um array
| Calcular quanto tamanho vertical(de linhas) é necessario para
* colocar um array | private int calcularTamanho(String[] array,int largura) {
int tamanhoString = 0;
int numDeArrays = 1;
for ( String i : array) {
if (tamanhoString + i.length() < largura) {
tamanhoString += i.length() + 1;
}
else {
tamanhoString = i.length() + 1;
numDeArrays++;
}
}
return numDeArrays;
} | [
"private",
"int",
"calcularTamanho",
"(",
"String",
"[",
"]",
"array",
",",
"int",
"largura",
")",
"{",
"int",
"tamanhoString",
"=",
"0",
";",
"int",
"numDeArrays",
"=",
"1",
";",
"for",
"(",
"String",
"i",
":",
"array",
")",
"{",
"if",
"(",
"tamanhoString",
"+",
"i",
".",
"length",
"(",
")",
"<",
"largura",
")",
"{",
"tamanhoString",
"+=",
"i",
".",
"length",
"(",
")",
"+",
"1",
";",
"}",
"else",
"{",
"tamanhoString",
"=",
"i",
".",
"length",
"(",
")",
"+",
"1",
";",
"numDeArrays",
"++",
";",
"}",
"}",
"return",
"numDeArrays",
";",
"}"
] | [
342,
4
] | [
358,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Tabuleiro. | null | método privado e interno para distribuição das peças do tabuleiro, em uma situação de nova partida: | método privado e interno para distribuição das peças do tabuleiro, em uma situação de nova partida: | private void distribuicaoInicial(Peca[] todasAsPecas) {
//percorredno o tabuleiro e instanciando cada posição (ainda vazias):
for (int i = 0; i < 8; i++) {
char coluna = 'a';
for (int j = 0; j < 8; j++) {
tabuleiro[i][j] = new Posicao(i, coluna, true);
coluna++;
}
}
//percorrendo o vetor de peças - parâmetro - e colocoando-as em suas respectivas posições no tabuleiro:
for (int i = 0; i < 32; i++) {
switch(i) {
case 0:
tabuleiro[0][2].setPeca(todasAsPecas[i]);
tabuleiro[0][2].setStatus(false);
break;
case 1:
tabuleiro[0][5].setPeca(todasAsPecas[i]);
tabuleiro[0][5].setStatus(false);
break;
case 2:
tabuleiro[0][1].setPeca(todasAsPecas[i]);
tabuleiro[0][1].setStatus(false);
break;
case 3:
tabuleiro[0][6].setPeca(todasAsPecas[i]);
tabuleiro[0][6].setStatus(false);
break;
case 4:
tabuleiro[0][0].setPeca(todasAsPecas[i]);
tabuleiro[0][0].setStatus(false);
break;
case 5:
tabuleiro[0][7].setPeca(todasAsPecas[i]);
tabuleiro[0][7].setStatus(false);
break;
case 6:
tabuleiro[0][3].setPeca(todasAsPecas[i]);
tabuleiro[0][3].setStatus(false);
break;
case 7:
tabuleiro[0][4].setPeca(todasAsPecas[i]);
tabuleiro[0][4].setStatus(false);
break;
case 8:
tabuleiro[1][0].setPeca(todasAsPecas[i]);
tabuleiro[1][0].setStatus(false);
break;
case 9:
tabuleiro[1][1].setPeca(todasAsPecas[i]);
tabuleiro[1][1].setStatus(false);
break;
case 10:
tabuleiro[1][2].setPeca(todasAsPecas[i]);
tabuleiro[1][2].setStatus(false);
break;
case 11:
tabuleiro[1][3].setPeca(todasAsPecas[i]);
tabuleiro[1][3].setStatus(false);
break;
case 12:
tabuleiro[1][4].setPeca(todasAsPecas[i]);
tabuleiro[1][4].setStatus(false);
break;
case 13:
tabuleiro[1][5].setPeca(todasAsPecas[i]);
tabuleiro[1][5].setStatus(false);
break;
case 14:
tabuleiro[1][6].setPeca(todasAsPecas[i]);
tabuleiro[1][6].setStatus(false);
break;
case 15:
tabuleiro[1][7].setPeca(todasAsPecas[i]);
tabuleiro[1][7].setStatus(false);
break;
case 16:
tabuleiro[7][2].setPeca(todasAsPecas[i]);
tabuleiro[7][2].setStatus(false);
break;
case 17:
tabuleiro[7][5].setPeca(todasAsPecas[i]);
tabuleiro[7][5].setStatus(false);
break;
case 18:
tabuleiro[7][1].setPeca(todasAsPecas[i]);
tabuleiro[7][1].setStatus(false);
break;
case 19:
tabuleiro[7][6].setPeca(todasAsPecas[i]);
tabuleiro[7][6].setStatus(false);
break;
case 20:
tabuleiro[7][0].setPeca(todasAsPecas[i]);
tabuleiro[7][0].setStatus(false);
break;
case 21:
tabuleiro[7][7].setPeca(todasAsPecas[i]);
tabuleiro[7][7].setStatus(false);
break;
case 22:
tabuleiro[7][3].setPeca(todasAsPecas[i]);
tabuleiro[7][3].setStatus(false);
break;
case 23:
tabuleiro[7][4].setPeca(todasAsPecas[i]);
tabuleiro[7][4].setStatus(false);
break;
case 24:
tabuleiro[6][0].setPeca(todasAsPecas[i]);
tabuleiro[6][0].setStatus(false);
break;
case 25:
tabuleiro[6][1].setPeca(todasAsPecas[i]);
tabuleiro[6][1].setStatus(false);
break;
case 26:
tabuleiro[6][2].setPeca(todasAsPecas[i]);
tabuleiro[6][2].setStatus(false);
break;
case 27:
tabuleiro[6][3].setPeca(todasAsPecas[i]);
tabuleiro[6][3].setStatus(false);
break;
case 28:
tabuleiro[6][4].setPeca(todasAsPecas[i]);
tabuleiro[6][4].setStatus(false);
break;
case 29:
tabuleiro[6][5].setPeca(todasAsPecas[i]);
tabuleiro[6][5].setStatus(false);
break;
case 30:
tabuleiro[6][6].setPeca(todasAsPecas[i]);
tabuleiro[6][6].setStatus(false);
break;
case 31:
tabuleiro[6][7].setPeca(todasAsPecas[i]);
tabuleiro[6][7].setStatus(false);
break;
}
}
} | [
"private",
"void",
"distribuicaoInicial",
"(",
"Peca",
"[",
"]",
"todasAsPecas",
")",
"{",
"//percorredno o tabuleiro e instanciando cada posição (ainda vazias):",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"8",
";",
"i",
"++",
")",
"{",
"char",
"coluna",
"=",
"'",
"'",
";",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"8",
";",
"j",
"++",
")",
"{",
"tabuleiro",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"new",
"Posicao",
"(",
"i",
",",
"coluna",
",",
"true",
")",
";",
"coluna",
"++",
";",
"}",
"}",
"//percorrendo o vetor de peças - parâmetro - e colocoando-as em suas respectivas posições no tabuleiro:",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"32",
";",
"i",
"++",
")",
"{",
"switch",
"(",
"i",
")",
"{",
"case",
"0",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"2",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"2",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"1",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"5",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"5",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"2",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"1",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"1",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"3",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"6",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"6",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"4",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"0",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"0",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"5",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"7",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"7",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"6",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"3",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"3",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"7",
":",
"tabuleiro",
"[",
"0",
"]",
"[",
"4",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"0",
"]",
"[",
"4",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"8",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"0",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"0",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"9",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"1",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"1",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"10",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"2",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"2",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"11",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"3",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"3",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"12",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"4",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"4",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"13",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"5",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"5",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"14",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"6",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"6",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"15",
":",
"tabuleiro",
"[",
"1",
"]",
"[",
"7",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"1",
"]",
"[",
"7",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"16",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"2",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"2",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"17",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"5",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"5",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"18",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"1",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"1",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"19",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"6",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"6",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"20",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"0",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"0",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"21",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"7",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"7",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"22",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"3",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"3",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"23",
":",
"tabuleiro",
"[",
"7",
"]",
"[",
"4",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"7",
"]",
"[",
"4",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"24",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"0",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"0",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"25",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"1",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"1",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"26",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"2",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"2",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"27",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"3",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"3",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"28",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"4",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"4",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"29",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"5",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"5",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"30",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"6",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"6",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"case",
"31",
":",
"tabuleiro",
"[",
"6",
"]",
"[",
"7",
"]",
".",
"setPeca",
"(",
"todasAsPecas",
"[",
"i",
"]",
")",
";",
"tabuleiro",
"[",
"6",
"]",
"[",
"7",
"]",
".",
"setStatus",
"(",
"false",
")",
";",
"break",
";",
"}",
"}",
"}"
] | [
15,
4
] | [
189,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FilmeController. | null | /* Este método insere um Filme esperando receber dois parâmetros no Request:
artista: objeto Filme no formato de String JSON
artistaImagem: File
| /* Este método insere um Filme esperando receber dois parâmetros no Request:
artista: objeto Filme no formato de String JSON
artistaImagem: File
| @RequestMapping(value = "/insertfile", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public ResponseEntity<Filme> insert(@RequestParam("filme") String filme, @RequestParam("filmeImagem") MultipartFile filmeImagem) {
Filme obj;
try {
obj = new ObjectMapper().readValue(filme, Filme.class);
obj.setImagem(filmeImagem.getBytes());
obj = service.insert(obj);
return ResponseEntity.ok().body(obj);
} catch (IOException e) {
e.printStackTrace();
}
return null;
} | [
"@",
"RequestMapping",
"(",
"value",
"=",
"\"/insertfile\"",
",",
"method",
"=",
"RequestMethod",
".",
"POST",
",",
"consumes",
"=",
"MediaType",
".",
"MULTIPART_FORM_DATA_VALUE",
")",
"public",
"ResponseEntity",
"<",
"Filme",
">",
"insert",
"(",
"@",
"RequestParam",
"(",
"\"filme\"",
")",
"String",
"filme",
",",
"@",
"RequestParam",
"(",
"\"filmeImagem\"",
")",
"MultipartFile",
"filmeImagem",
")",
"{",
"Filme",
"obj",
";",
"try",
"{",
"obj",
"=",
"new",
"ObjectMapper",
"(",
")",
".",
"readValue",
"(",
"filme",
",",
"Filme",
".",
"class",
")",
";",
"obj",
".",
"setImagem",
"(",
"filmeImagem",
".",
"getBytes",
"(",
")",
")",
";",
"obj",
"=",
"service",
".",
"insert",
"(",
"obj",
")",
";",
"return",
"ResponseEntity",
".",
"ok",
"(",
")",
".",
"body",
"(",
"obj",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
] | [
49,
1
] | [
61,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Usuario. | null | Set nome do email | Set nome do email | public void setEmail(String email) {
this.email = email;
} | [
"public",
"void",
"setEmail",
"(",
"String",
"email",
")",
"{",
"this",
".",
"email",
"=",
"email",
";",
"}"
] | [
48,
4
] | [
50,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Enemy. | null | * Retorna melhor decisao de caminho, retorna 'S' caso nao tenha movimentos possiveis ** | * Retorna melhor decisao de caminho, retorna 'S' caso nao tenha movimentos possiveis ** | protected char getBestDirection() {
ArrayList<Direction> list = new ArrayList<Direction>(4);
if(iPos - 1 >= 0 && map.getCell(iPos-1,jPos).isWalkableEnemy() && map.getEnemy(iPos - 1, jPos) == null) {
int upDistance = minDistanceToBravia(iPos-1, jPos);
System.out.print("upDistance: "); //DEBUG
System.out.println(upDistance);
if(upDistance >= 0) {
Direction up = new Direction(upDistance, 'U');
list.add(up);
}
}
if(iPos + 1 < map.getMapHeight() && map.getCell(iPos+1,jPos).isWalkableEnemy() && map.getEnemy(iPos + 1, jPos) == null) {
int downDistance = minDistanceToBravia(iPos+1, jPos);
System.out.print("downDistance: "); //DEBUG
System.out.println(downDistance);
if(downDistance >= 0) {
Direction down = new Direction(downDistance, 'D');
list.add(down);
}
}
if(jPos - 1 >= 0 && map.getCell(iPos,jPos-1).isWalkableEnemy() && map.getEnemy(iPos, jPos - 1) == null) {
int leftDistance = minDistanceToBravia(iPos, jPos-1);
System.out.print("leftDistance: "); //DEBUG
System.out.println(leftDistance);
if(leftDistance >= 0) {
Direction left = new Direction(leftDistance, 'L');
list.add(left);
}
}
if(jPos + 1 < map.getMapWidth() && map.getCell(iPos, jPos + 1).isWalkableEnemy() && map.getEnemy(iPos, jPos + 1) == null) {
int rightDistance = minDistanceToBravia(iPos, jPos+1);
System.out.print("rightDistance: "); //DEBUG
System.out.println(rightDistance);
if(rightDistance >= 0) {
Direction right = new Direction(rightDistance, 'R');
list.add(right);
}
}
if(list.isEmpty()) {
return 'S';
}else {
Collections.sort(list);
return list.get(0).direction;
}
} | [
"protected",
"char",
"getBestDirection",
"(",
")",
"{",
"ArrayList",
"<",
"Direction",
">",
"list",
"=",
"new",
"ArrayList",
"<",
"Direction",
">",
"(",
"4",
")",
";",
"if",
"(",
"iPos",
"-",
"1",
">=",
"0",
"&&",
"map",
".",
"getCell",
"(",
"iPos",
"-",
"1",
",",
"jPos",
")",
".",
"isWalkableEnemy",
"(",
")",
"&&",
"map",
".",
"getEnemy",
"(",
"iPos",
"-",
"1",
",",
"jPos",
")",
"==",
"null",
")",
"{",
"int",
"upDistance",
"=",
"minDistanceToBravia",
"(",
"iPos",
"-",
"1",
",",
"jPos",
")",
";",
"System",
".",
"out",
".",
"print",
"(",
"\"upDistance: \"",
")",
";",
"//DEBUG",
"System",
".",
"out",
".",
"println",
"(",
"upDistance",
")",
";",
"if",
"(",
"upDistance",
">=",
"0",
")",
"{",
"Direction",
"up",
"=",
"new",
"Direction",
"(",
"upDistance",
",",
"'",
"'",
")",
";",
"list",
".",
"add",
"(",
"up",
")",
";",
"}",
"}",
"if",
"(",
"iPos",
"+",
"1",
"<",
"map",
".",
"getMapHeight",
"(",
")",
"&&",
"map",
".",
"getCell",
"(",
"iPos",
"+",
"1",
",",
"jPos",
")",
".",
"isWalkableEnemy",
"(",
")",
"&&",
"map",
".",
"getEnemy",
"(",
"iPos",
"+",
"1",
",",
"jPos",
")",
"==",
"null",
")",
"{",
"int",
"downDistance",
"=",
"minDistanceToBravia",
"(",
"iPos",
"+",
"1",
",",
"jPos",
")",
";",
"System",
".",
"out",
".",
"print",
"(",
"\"downDistance: \"",
")",
";",
"//DEBUG",
"System",
".",
"out",
".",
"println",
"(",
"downDistance",
")",
";",
"if",
"(",
"downDistance",
">=",
"0",
")",
"{",
"Direction",
"down",
"=",
"new",
"Direction",
"(",
"downDistance",
",",
"'",
"'",
")",
";",
"list",
".",
"add",
"(",
"down",
")",
";",
"}",
"}",
"if",
"(",
"jPos",
"-",
"1",
">=",
"0",
"&&",
"map",
".",
"getCell",
"(",
"iPos",
",",
"jPos",
"-",
"1",
")",
".",
"isWalkableEnemy",
"(",
")",
"&&",
"map",
".",
"getEnemy",
"(",
"iPos",
",",
"jPos",
"-",
"1",
")",
"==",
"null",
")",
"{",
"int",
"leftDistance",
"=",
"minDistanceToBravia",
"(",
"iPos",
",",
"jPos",
"-",
"1",
")",
";",
"System",
".",
"out",
".",
"print",
"(",
"\"leftDistance: \"",
")",
";",
"//DEBUG",
"System",
".",
"out",
".",
"println",
"(",
"leftDistance",
")",
";",
"if",
"(",
"leftDistance",
">=",
"0",
")",
"{",
"Direction",
"left",
"=",
"new",
"Direction",
"(",
"leftDistance",
",",
"'",
"'",
")",
";",
"list",
".",
"add",
"(",
"left",
")",
";",
"}",
"}",
"if",
"(",
"jPos",
"+",
"1",
"<",
"map",
".",
"getMapWidth",
"(",
")",
"&&",
"map",
".",
"getCell",
"(",
"iPos",
",",
"jPos",
"+",
"1",
")",
".",
"isWalkableEnemy",
"(",
")",
"&&",
"map",
".",
"getEnemy",
"(",
"iPos",
",",
"jPos",
"+",
"1",
")",
"==",
"null",
")",
"{",
"int",
"rightDistance",
"=",
"minDistanceToBravia",
"(",
"iPos",
",",
"jPos",
"+",
"1",
")",
";",
"System",
".",
"out",
".",
"print",
"(",
"\"rightDistance: \"",
")",
";",
"//DEBUG",
"System",
".",
"out",
".",
"println",
"(",
"rightDistance",
")",
";",
"if",
"(",
"rightDistance",
">=",
"0",
")",
"{",
"Direction",
"right",
"=",
"new",
"Direction",
"(",
"rightDistance",
",",
"'",
"'",
")",
";",
"list",
".",
"add",
"(",
"right",
")",
";",
"}",
"}",
"if",
"(",
"list",
".",
"isEmpty",
"(",
")",
")",
"{",
"return",
"'",
"'",
";",
"}",
"else",
"{",
"Collections",
".",
"sort",
"(",
"list",
")",
";",
"return",
"list",
".",
"get",
"(",
"0",
")",
".",
"direction",
";",
"}",
"}"
] | [
28,
1
] | [
74,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Bloco. | null | Remove um valor do bloco | Remove um valor do bloco | public boolean delete(int d) {
if (empty())
return false;
int i = 0;
while (i < quantidade && d > dados[i])
i++;
if (d == dados[i]) {
while (i < quantidade - 1) {
dados[i] = dados[i + 1];
i++;
}
quantidade--;
return true;
} else
return false;
} | [
"public",
"boolean",
"delete",
"(",
"int",
"d",
")",
"{",
"if",
"(",
"empty",
"(",
")",
")",
"return",
"false",
";",
"int",
"i",
"=",
"0",
";",
"while",
"(",
"i",
"<",
"quantidade",
"&&",
"d",
">",
"dados",
"[",
"i",
"]",
")",
"i",
"++",
";",
"if",
"(",
"d",
"==",
"dados",
"[",
"i",
"]",
")",
"{",
"while",
"(",
"i",
"<",
"quantidade",
"-",
"1",
")",
"{",
"dados",
"[",
"i",
"]",
"=",
"dados",
"[",
"i",
"+",
"1",
"]",
";",
"i",
"++",
";",
"}",
"quantidade",
"--",
";",
"return",
"true",
";",
"}",
"else",
"return",
"false",
";",
"}"
] | [
106,
4
] | [
121,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ContaServiceTest. | null | Teste do método getContas() | Teste do método getContas() | @Test
public void testGetContasComSucesso(){
//preparo
ContaModelDb conta1 = new ContaModelDb();
conta1.setId("111111111");
conta1.setNome("Anderson");
conta1.setRg("123456789");
conta1.setValor(new BigDecimal("450.00"));
ContaModelDb conta2 = new ContaModelDb();
conta2.setId("222222222");
conta2.setNome("Beatriz");
conta2.setRg("234567890");
conta2.setValor(new BigDecimal("300.00"));
ContaModelDb conta3 = new ContaModelDb();
conta3.setId("333333333");
conta3.setNome("Caio");
conta3.setRg("345678901");
conta3.setValor(new BigDecimal("150.00"));
List<ContaModelDb> listaContasDb = new ArrayList<>();
listaContasDb.add(conta1);
listaContasDb.add(conta2);
listaContasDb.add(conta3);
//simulação do repository
when(contaRepository.findAll())
.thenReturn(listaContasDb);
//resultado experado
ContaModelResponse contaResposta1 = new ContaModelResponse();
contaResposta1 .setId("111111111");
contaResposta1 .setNome("Anderson");
contaResposta1 .setRg("123456789");
contaResposta1 .setValor(new BigDecimal("450.00"));
ContaModelResponse contaResposta2 = new ContaModelResponse();
contaResposta2.setId("222222222");
contaResposta2.setNome("Beatriz");
contaResposta2.setRg("234567890");
contaResposta2.setValor(new BigDecimal("300.00"));
ContaModelResponse contaResposta3 = new ContaModelResponse();
contaResposta3.setId("333333333");
contaResposta3.setNome("Caio");
contaResposta3.setRg("345678901");
contaResposta3.setValor(new BigDecimal("150.00"));
List<ContaModelResponse> listaEsperada = new ArrayList<>();
listaEsperada.add(contaResposta1);
listaEsperada.add(contaResposta2);
listaEsperada.add(contaResposta3);
//teste
List<ContaModelResponse> listaAtual = contaService.getContas();
assertArrayEquals(listaEsperada.toArray(), listaAtual.toArray());
} | [
"@",
"Test",
"public",
"void",
"testGetContasComSucesso",
"(",
")",
"{",
"//preparo",
"ContaModelDb",
"conta1",
"=",
"new",
"ContaModelDb",
"(",
")",
";",
"conta1",
".",
"setId",
"(",
"\"111111111\"",
")",
";",
"conta1",
".",
"setNome",
"(",
"\"Anderson\"",
")",
";",
"conta1",
".",
"setRg",
"(",
"\"123456789\"",
")",
";",
"conta1",
".",
"setValor",
"(",
"new",
"BigDecimal",
"(",
"\"450.00\"",
")",
")",
";",
"ContaModelDb",
"conta2",
"=",
"new",
"ContaModelDb",
"(",
")",
";",
"conta2",
".",
"setId",
"(",
"\"222222222\"",
")",
";",
"conta2",
".",
"setNome",
"(",
"\"Beatriz\"",
")",
";",
"conta2",
".",
"setRg",
"(",
"\"234567890\"",
")",
";",
"conta2",
".",
"setValor",
"(",
"new",
"BigDecimal",
"(",
"\"300.00\"",
")",
")",
";",
"ContaModelDb",
"conta3",
"=",
"new",
"ContaModelDb",
"(",
")",
";",
"conta3",
".",
"setId",
"(",
"\"333333333\"",
")",
";",
"conta3",
".",
"setNome",
"(",
"\"Caio\"",
")",
";",
"conta3",
".",
"setRg",
"(",
"\"345678901\"",
")",
";",
"conta3",
".",
"setValor",
"(",
"new",
"BigDecimal",
"(",
"\"150.00\"",
")",
")",
";",
"List",
"<",
"ContaModelDb",
">",
"listaContasDb",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"listaContasDb",
".",
"add",
"(",
"conta1",
")",
";",
"listaContasDb",
".",
"add",
"(",
"conta2",
")",
";",
"listaContasDb",
".",
"add",
"(",
"conta3",
")",
";",
"//simulação do repository",
"when",
"(",
"contaRepository",
".",
"findAll",
"(",
")",
")",
".",
"thenReturn",
"(",
"listaContasDb",
")",
";",
"//resultado experado",
"ContaModelResponse",
"contaResposta1",
"=",
"new",
"ContaModelResponse",
"(",
")",
";",
"contaResposta1",
".",
"setId",
"(",
"\"111111111\"",
")",
";",
"contaResposta1",
".",
"setNome",
"(",
"\"Anderson\"",
")",
";",
"contaResposta1",
".",
"setRg",
"(",
"\"123456789\"",
")",
";",
"contaResposta1",
".",
"setValor",
"(",
"new",
"BigDecimal",
"(",
"\"450.00\"",
")",
")",
";",
"ContaModelResponse",
"contaResposta2",
"=",
"new",
"ContaModelResponse",
"(",
")",
";",
"contaResposta2",
".",
"setId",
"(",
"\"222222222\"",
")",
";",
"contaResposta2",
".",
"setNome",
"(",
"\"Beatriz\"",
")",
";",
"contaResposta2",
".",
"setRg",
"(",
"\"234567890\"",
")",
";",
"contaResposta2",
".",
"setValor",
"(",
"new",
"BigDecimal",
"(",
"\"300.00\"",
")",
")",
";",
"ContaModelResponse",
"contaResposta3",
"=",
"new",
"ContaModelResponse",
"(",
")",
";",
"contaResposta3",
".",
"setId",
"(",
"\"333333333\"",
")",
";",
"contaResposta3",
".",
"setNome",
"(",
"\"Caio\"",
")",
";",
"contaResposta3",
".",
"setRg",
"(",
"\"345678901\"",
")",
";",
"contaResposta3",
".",
"setValor",
"(",
"new",
"BigDecimal",
"(",
"\"150.00\"",
")",
")",
";",
"List",
"<",
"ContaModelResponse",
">",
"listaEsperada",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"listaEsperada",
".",
"add",
"(",
"contaResposta1",
")",
";",
"listaEsperada",
".",
"add",
"(",
"contaResposta2",
")",
";",
"listaEsperada",
".",
"add",
"(",
"contaResposta3",
")",
";",
"//teste",
"List",
"<",
"ContaModelResponse",
">",
"listaAtual",
"=",
"contaService",
".",
"getContas",
"(",
")",
";",
"assertArrayEquals",
"(",
"listaEsperada",
".",
"toArray",
"(",
")",
",",
"listaAtual",
".",
"toArray",
"(",
")",
")",
";",
"}"
] | [
81,
4
] | [
143,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
BestScoreUpdate. | null | Funcao atira as exceçoes dadas para "cima", para a funcao que as chamou | Funcao atira as exceçoes dadas para "cima", para a funcao que as chamou | public static void bestScoreUpdate(HighScore score, List<HighScore> highscores) throws FileNotFoundException, IOException {
String filename = "HS FILE NAME";
// Se for Highscore (usa uma funçao adicional)
if (checkifHighScore(score, highscores)) {
// Adiciona à lista e ordena
highscores.add(score);
ComparatorOfHighScores comparator = new ComparatorOfHighScores();
Collections.sort(highscores, comparator);
// Escreve no ficheiro actualizado
File file = new File(filename);
// Utiliza o println do PrintStream que permite imprimir linha a linha
PrintStream writer = new PrintStream(file);
int i = 0;
//Percorre a lista
for (HighScore s : highscores) {
// Assim só vai imprimir os 10 primeiros resultados da lista
if (i >= 10) {
break;
} else {
// Escreve a linha no ficheiro
writer.println(s.toString());
i++;
}
}
}
} | [
"public",
"static",
"void",
"bestScoreUpdate",
"(",
"HighScore",
"score",
",",
"List",
"<",
"HighScore",
">",
"highscores",
")",
"throws",
"FileNotFoundException",
",",
"IOException",
"{",
"String",
"filename",
"=",
"\"HS FILE NAME\"",
";",
"// Se for Highscore (usa uma funçao adicional)",
"if",
"(",
"checkifHighScore",
"(",
"score",
",",
"highscores",
")",
")",
"{",
"// Adiciona à lista e ordena",
"highscores",
".",
"add",
"(",
"score",
")",
";",
"ComparatorOfHighScores",
"comparator",
"=",
"new",
"ComparatorOfHighScores",
"(",
")",
";",
"Collections",
".",
"sort",
"(",
"highscores",
",",
"comparator",
")",
";",
"// Escreve no ficheiro actualizado",
"File",
"file",
"=",
"new",
"File",
"(",
"filename",
")",
";",
"// Utiliza o println do PrintStream que permite imprimir linha a linha",
"PrintStream",
"writer",
"=",
"new",
"PrintStream",
"(",
"file",
")",
";",
"int",
"i",
"=",
"0",
";",
"//Percorre a lista",
"for",
"(",
"HighScore",
"s",
":",
"highscores",
")",
"{",
"// Assim só vai imprimir os 10 primeiros resultados da lista",
"if",
"(",
"i",
">=",
"10",
")",
"{",
"break",
";",
"}",
"else",
"{",
"// Escreve a linha no ficheiro",
"writer",
".",
"println",
"(",
"s",
".",
"toString",
"(",
")",
")",
";",
"i",
"++",
";",
"}",
"}",
"}",
"}"
] | [
10,
4
] | [
35,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Map. | null | * Lista todos os inimigos no mapa e retorna a lista ** | * Lista todos os inimigos no mapa e retorna a lista ** | public ArrayList<Enemy> listEnemies() {
listEnemy = new ArrayList<Enemy>();
for(int i=0;i < mapHeight; i++) {
for(int j=0; j < mapWidth; j++) {
if(mapEnemy[i][j] != null) {
listEnemy.add(mapEnemy[i][j]);
}
}
}
return listEnemy;
} | [
"public",
"ArrayList",
"<",
"Enemy",
">",
"listEnemies",
"(",
")",
"{",
"listEnemy",
"=",
"new",
"ArrayList",
"<",
"Enemy",
">",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"mapHeight",
";",
"i",
"++",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"mapWidth",
";",
"j",
"++",
")",
"{",
"if",
"(",
"mapEnemy",
"[",
"i",
"]",
"[",
"j",
"]",
"!=",
"null",
")",
"{",
"listEnemy",
".",
"add",
"(",
"mapEnemy",
"[",
"i",
"]",
"[",
"j",
"]",
")",
";",
"}",
"}",
"}",
"return",
"listEnemy",
";",
"}"
] | [
158,
1
] | [
168,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Element. | null | Método de espaço e visual | Método de espaço e visual | public void paint(Graphics2D g2) {
g2.fillRect((int) x - width / 2, (int) y - height / 2, width, height);
} | [
"public",
"void",
"paint",
"(",
"Graphics2D",
"g2",
")",
"{",
"g2",
".",
"fillRect",
"(",
"(",
"int",
")",
"x",
"-",
"width",
"/",
"2",
",",
"(",
"int",
")",
"y",
"-",
"height",
"/",
"2",
",",
"width",
",",
"height",
")",
";",
"}"
] | [
33,
4
] | [
35,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
DesafioMeuTimeApplication. | null | Define um jogador como capitão do seu time. Um time deve ter apenas um capitão, por tanto o capitão anterior voltará a ser apenas jogador. | Define um jogador como capitão do seu time. Um time deve ter apenas um capitão, por tanto o capitão anterior voltará a ser apenas jogador. | @Desafio("definirCapitao")
public void definirCapitao(Long idJogador) {
//Caso o jogador informado não exista, retornar br.com.codenation.desafio.exceptions.JogadorNaoEncontradoException
Jogador j = this.buscaJogadorPeloId(idJogador).orElseThrow(JogadorNaoEncontradoException::new);
Time t = this.buscaTimePeloId(j.getIdTime()).orElseThrow(TimeNaoEncontradoException::new);
t.setIdCapitao(idJogador);
} | [
"@",
"Desafio",
"(",
"\"definirCapitao\"",
")",
"public",
"void",
"definirCapitao",
"(",
"Long",
"idJogador",
")",
"{",
"//Caso o jogador informado não exista, retornar br.com.codenation.desafio.exceptions.JogadorNaoEncontradoException",
"Jogador",
"j",
"=",
"this",
".",
"buscaJogadorPeloId",
"(",
"idJogador",
")",
".",
"orElseThrow",
"(",
"JogadorNaoEncontradoException",
"::",
"new",
")",
";",
"Time",
"t",
"=",
"this",
".",
"buscaTimePeloId",
"(",
"j",
".",
"getIdTime",
"(",
")",
")",
".",
"orElseThrow",
"(",
"TimeNaoEncontradoException",
"::",
"new",
")",
";",
"t",
".",
"setIdCapitao",
"(",
"idJogador",
")",
";",
"}"
] | [
46,
1
] | [
53,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Pagina. | null | são preenchidos com espaços em branco | são preenchidos com espaços em branco | private byte[] completaBrancos(String str) {
byte[] aux;
byte[] buffer = new byte[TAMANHO_CHAVE];
aux = str.getBytes();
int i=0; while(i<aux.length) { buffer[i] = aux[i]; i++; }
while(i<TAMANHO_CHAVE) { buffer[i] = 0x20; i++; }
return buffer;
} | [
"private",
"byte",
"[",
"]",
"completaBrancos",
"(",
"String",
"str",
")",
"{",
"byte",
"[",
"]",
"aux",
";",
"byte",
"[",
"]",
"buffer",
"=",
"new",
"byte",
"[",
"TAMANHO_CHAVE",
"]",
";",
"aux",
"=",
"str",
".",
"getBytes",
"(",
")",
";",
"int",
"i",
"=",
"0",
";",
"while",
"(",
"i",
"<",
"aux",
".",
"length",
")",
"{",
"buffer",
"[",
"i",
"]",
"=",
"aux",
"[",
"i",
"]",
";",
"i",
"++",
";",
"}",
"while",
"(",
"i",
"<",
"TAMANHO_CHAVE",
")",
"{",
"buffer",
"[",
"i",
"]",
"=",
"0x20",
";",
"i",
"++",
";",
"}",
"return",
"buffer",
";",
"}"
] | [
100,
8
] | [
107,
9
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
MainSceneController. | null | Criando um FXMLLoader para carregar a tela,e sincronizandod evitando as threads | Criando um FXMLLoader para carregar a tela,e sincronizandod evitando as threads | private synchronized <T> void loadView(String absoluteName, Consumer<T> initializingAction) {
try {
FXMLLoader loader = new FXMLLoader(getClass().getResource(absoluteName));
VBox newVBox = loader.load();
Scene mainScene = Main.getMainScene();
VBox mainVBox = (VBox) ((ScrollPane) mainScene.getRoot()).getContent(); //GETROOT pega o primeiro elemento da View
//Manipulacao da tela principal
Node mainMenu = mainVBox.getChildren().get(0); //Creia um node recebe o Vbox
mainVBox.getChildren().clear();//Limpa todos os filhos do Main VBox
mainVBox.getChildren().add(mainMenu);//Pega os filhos do Main Nebu
mainVBox.getChildren().addAll(newVBox.getChildren()); //Adicionando uma colecao < os filhos do Vbox
//Executa a funcao
T controller = loader.getController();
initializingAction.accept(controller);
} catch (Exception e) {
//Caso ocorra a execao, o sistema ira msotrar uma Janela de alerta com o Erro
//Alerts.showAlert("IOException", "Error loading view", e.getMessage(), Alert.AlertType.ERROR);
e.printStackTrace();
}
} | [
"private",
"synchronized",
"<",
"T",
">",
"void",
"loadView",
"(",
"String",
"absoluteName",
",",
"Consumer",
"<",
"T",
">",
"initializingAction",
")",
"{",
"try",
"{",
"FXMLLoader",
"loader",
"=",
"new",
"FXMLLoader",
"(",
"getClass",
"(",
")",
".",
"getResource",
"(",
"absoluteName",
")",
")",
";",
"VBox",
"newVBox",
"=",
"loader",
".",
"load",
"(",
")",
";",
"Scene",
"mainScene",
"=",
"Main",
".",
"getMainScene",
"(",
")",
";",
"VBox",
"mainVBox",
"=",
"(",
"VBox",
")",
"(",
"(",
"ScrollPane",
")",
"mainScene",
".",
"getRoot",
"(",
")",
")",
".",
"getContent",
"(",
")",
";",
"//GETROOT pega o primeiro elemento da View",
"//Manipulacao da tela principal",
"Node",
"mainMenu",
"=",
"mainVBox",
".",
"getChildren",
"(",
")",
".",
"get",
"(",
"0",
")",
";",
"//Creia um node recebe o Vbox",
"mainVBox",
".",
"getChildren",
"(",
")",
".",
"clear",
"(",
")",
";",
"//Limpa todos os filhos do Main VBox",
"mainVBox",
".",
"getChildren",
"(",
")",
".",
"add",
"(",
"mainMenu",
")",
";",
"//Pega os filhos do Main Nebu",
"mainVBox",
".",
"getChildren",
"(",
")",
".",
"addAll",
"(",
"newVBox",
".",
"getChildren",
"(",
")",
")",
";",
"//Adicionando uma colecao < os filhos do Vbox",
"//Executa a funcao",
"T",
"controller",
"=",
"loader",
".",
"getController",
"(",
")",
";",
"initializingAction",
".",
"accept",
"(",
"controller",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"//Caso ocorra a execao, o sistema ira msotrar uma Janela de alerta com o Erro",
"//Alerts.showAlert(\"IOException\", \"Error loading view\", e.getMessage(), Alert.AlertType.ERROR);",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"}"
] | [
76,
4
] | [
99,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Node. | null | endereço para acessar o próximo item | endereço para acessar o próximo item | public Object getValue(){ //retorna o valor do nó
return value;
} | [
"public",
"Object",
"getValue",
"(",
")",
"{",
"//retorna o valor do nó",
"return",
"value",
";",
"}"
] | [
7,
4
] | [
9,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
CarDAO. | null | /*Consulta apenas para aprendizado, porém sempre dar preferência para JPQL ou criteriaQuery | /*Consulta apenas para aprendizado, porém sempre dar preferência para JPQL ou criteriaQuery | public List<Car> findAllWithNativeQuery() {
Query query = em.createNativeQuery(" select * from car", Car.class);
return query.getResultList();
} | [
"public",
"List",
"<",
"Car",
">",
"findAllWithNativeQuery",
"(",
")",
"{",
"Query",
"query",
"=",
"em",
".",
"createNativeQuery",
"(",
"\" select * from car\"",
",",
"Car",
".",
"class",
")",
";",
"return",
"query",
".",
"getResultList",
"(",
")",
";",
"}"
] | [
61,
4
] | [
64,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Testes. | null | Obtem informaçao do utilizador e cria o ficheiro | Obtem informaçao do utilizador e cria o ficheiro | public static File criaFicheiro(String nomeFicheiro) {
Scanner s = new Scanner(System.in);
System.out.println("Introduza o seu nome:");
String nome = s.nextLine();
System.out.println("Introduza a sua idade:");
// Aqui nao é relevante receber int porque ao ler o ficheiro e imprimirmos na consola
// vamos estar a imprimir a idade em formato String de qualquer maneira
String idade = s.nextLine();
// Obtem a directoria do project para aceder ao ficheiro
String localDir = System.getProperty("user.dir");
// Obtem a localizaçao correcta do ficheiro juntando o caminho localDir + o caminho relativo do projecto em que se está a trabalhar
// Este caminho é totalmente variável e depende da organizaçao do projecto de cada um e tambem se usam Mac, Windows ou Linux
File f = new File(localDir + "\\aulas\\src\\aula13\\exercicio2\\" + nomeFicheiro);
try { // Trata o erro
PrintWriter fileWriter = new PrintWriter(f);
// Escreve o nome e idade no ficheiro
fileWriter.println(nome + "," + idade);
fileWriter.close();
} catch (FileNotFoundException e) {
// Apanha e trata o erro
System.out.println("Ficheiro não encontrado");
e.printStackTrace();
}
return f;
} | [
"public",
"static",
"File",
"criaFicheiro",
"(",
"String",
"nomeFicheiro",
")",
"{",
"Scanner",
"s",
"=",
"new",
"Scanner",
"(",
"System",
".",
"in",
")",
";",
"System",
".",
"out",
".",
"println",
"(",
"\"Introduza o seu nome:\"",
")",
";",
"String",
"nome",
"=",
"s",
".",
"nextLine",
"(",
")",
";",
"System",
".",
"out",
".",
"println",
"(",
"\"Introduza a sua idade:\"",
")",
";",
"// Aqui nao é relevante receber int porque ao ler o ficheiro e imprimirmos na consola",
"// vamos estar a imprimir a idade em formato String de qualquer maneira",
"String",
"idade",
"=",
"s",
".",
"nextLine",
"(",
")",
";",
"// Obtem a directoria do project para aceder ao ficheiro",
"String",
"localDir",
"=",
"System",
".",
"getProperty",
"(",
"\"user.dir\"",
")",
";",
"// Obtem a localizaçao correcta do ficheiro juntando o caminho localDir + o caminho relativo do projecto em que se está a trabalhar",
"// Este caminho é totalmente variável e depende da organizaçao do projecto de cada um e tambem se usam Mac, Windows ou Linux",
"File",
"f",
"=",
"new",
"File",
"(",
"localDir",
"+",
"\"\\\\aulas\\\\src\\\\aula13\\\\exercicio2\\\\\"",
"+",
"nomeFicheiro",
")",
";",
"try",
"{",
"// Trata o erro",
"PrintWriter",
"fileWriter",
"=",
"new",
"PrintWriter",
"(",
"f",
")",
";",
"// Escreve o nome e idade no ficheiro",
"fileWriter",
".",
"println",
"(",
"nome",
"+",
"\",\"",
"+",
"idade",
")",
";",
"fileWriter",
".",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"FileNotFoundException",
"e",
")",
"{",
"// Apanha e trata o erro",
"System",
".",
"out",
".",
"println",
"(",
"\"Ficheiro não encontrado\")",
";",
"",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"return",
"f",
";",
"}"
] | [
32,
4
] | [
56,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FuncoesTopicos. | null | Retorna uma lista de imoveis ordenados em ordem decrescente de valor em uma cidade específica | Retorna uma lista de imoveis ordenados em ordem decrescente de valor em uma cidade específica | public static List<Imovel> q6FiltraPorCidade(String cidade) {
List<Imovel> resultado = new ArrayList<>();
//Utiliza o iterador imovel para percorrer a lista
for (Imovel imovel : imoveis) {
//Compara se a cidade do imovel atual é o mesmo que o desejado
if (imovel.getCidade().equals(cidade)) {
resultado.add(imovel);
}
}
//Ordena a lista de imoveis de forma reversa
Collections.sort(resultado, Collections.reverseOrder());
return resultado;
} | [
"public",
"static",
"List",
"<",
"Imovel",
">",
"q6FiltraPorCidade",
"(",
"String",
"cidade",
")",
"{",
"List",
"<",
"Imovel",
">",
"resultado",
"=",
"new",
"ArrayList",
"<>",
"(",
")",
";",
"//Utiliza o iterador imovel para percorrer a lista",
"for",
"(",
"Imovel",
"imovel",
":",
"imoveis",
")",
"{",
"//Compara se a cidade do imovel atual é o mesmo que o desejado",
"if",
"(",
"imovel",
".",
"getCidade",
"(",
")",
".",
"equals",
"(",
"cidade",
")",
")",
"{",
"resultado",
".",
"add",
"(",
"imovel",
")",
";",
"}",
"}",
"//Ordena a lista de imoveis de forma reversa",
"Collections",
".",
"sort",
"(",
"resultado",
",",
"Collections",
".",
"reverseOrder",
"(",
")",
")",
";",
"return",
"resultado",
";",
"}"
] | [
107,
4
] | [
122,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
GameBuilder. | null | * Instancia os dois principais objetos a serem criados ** | * Instancia os dois principais objetos a serem criados ** | private void buildGame() {
mapGenerated.setMapCell(mapCell);
mapGenerated.setMapEnemy(mapEnemy);
mapGenerated.setMapHeight(mapHeight);
mapGenerated.setMapWidth(mapWidth);
mapGenerated.setBravia(new Bravia(mapGenerated, IEntrance, JEntrance));
braviaGenerated = mapGenerated.getBravia();
//rotina para gerar checkpoint ao iniciar a fase
try {
Checkpoint.setStartPos(IEntrance, JEntrance);
Checkpoint.setKeyInventory(braviaGenerated);
Checkpoint.setMapCell(mapCell);
Checkpoint.setMapEnemy(mapEnemy);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
} | [
"private",
"void",
"buildGame",
"(",
")",
"{",
"mapGenerated",
".",
"setMapCell",
"(",
"mapCell",
")",
";",
"mapGenerated",
".",
"setMapEnemy",
"(",
"mapEnemy",
")",
";",
"mapGenerated",
".",
"setMapHeight",
"(",
"mapHeight",
")",
";",
"mapGenerated",
".",
"setMapWidth",
"(",
"mapWidth",
")",
";",
"mapGenerated",
".",
"setBravia",
"(",
"new",
"Bravia",
"(",
"mapGenerated",
",",
"IEntrance",
",",
"JEntrance",
")",
")",
";",
"braviaGenerated",
"=",
"mapGenerated",
".",
"getBravia",
"(",
")",
";",
"//rotina para gerar checkpoint ao iniciar a fase",
"try",
"{",
"Checkpoint",
".",
"setStartPos",
"(",
"IEntrance",
",",
"JEntrance",
")",
";",
"Checkpoint",
".",
"setKeyInventory",
"(",
"braviaGenerated",
")",
";",
"Checkpoint",
".",
"setMapCell",
"(",
"mapCell",
")",
";",
"Checkpoint",
".",
"setMapEnemy",
"(",
"mapEnemy",
")",
";",
"}",
"catch",
"(",
"CloneNotSupportedException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"}"
] | [
126,
1
] | [
143,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
QuickSort. | null | ===== Métodos de Ordenação por Dias sem Chuva ===== // | ===== Métodos de Ordenação por Dias sem Chuva ===== // | public void quickDiasSemChuvaCres() {
quickDiasSemChuvaCres(0, lista.size() - 1);
} | [
"public",
"void",
"quickDiasSemChuvaCres",
"(",
")",
"{",
"quickDiasSemChuvaCres",
"(",
"0",
",",
"lista",
".",
"size",
"(",
")",
"-",
"1",
")",
";",
"}"
] | [
563,
4
] | [
565,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FXMLEntregaController. | null | Carrega a tabela dados após selecionar um item na tabela da esquerda | Carrega a tabela dados após selecionar um item na tabela da esquerda | public void carregarTableViewDados(Entrega entrega) {
listaPedido = (List<Pedido>) entrega.getPedidos();
observableListPedido = FXCollections.observableArrayList(listaPedido);
tabbleViewDados.setItems(observableListPedido);
tabbleViewDados.refresh();
} | [
"public",
"void",
"carregarTableViewDados",
"(",
"Entrega",
"entrega",
")",
"{",
"listaPedido",
"=",
"(",
"List",
"<",
"Pedido",
">",
")",
"entrega",
".",
"getPedidos",
"(",
")",
";",
"observableListPedido",
"=",
"FXCollections",
".",
"observableArrayList",
"(",
"listaPedido",
")",
";",
"tabbleViewDados",
".",
"setItems",
"(",
"observableListPedido",
")",
";",
"tabbleViewDados",
".",
"refresh",
"(",
")",
";",
"}"
] | [
126,
1
] | [
133,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ImagemProduto. | null | p/ mapear em DetalheProduto | p/ mapear em DetalheProduto | public String getLink() {
return link;
} | [
"public",
"String",
"getLink",
"(",
")",
"{",
"return",
"link",
";",
"}"
] | [
34,
4
] | [
36,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
DBSReportBean. | null | Chama a metodo(evento) dentro das classe foram adicionadas na lista que possuem a implementação da respectiva interface | Chama a metodo(evento) dentro das classe foram adicionadas na lista que possuem a implementação da respectiva interface | private void pvFireEventLocal(DBSReportBeanEvent pEvent) throws DBSIOException{
if (pEvent.isOk()){
switch (pEvent.getEvent()) {
case INITIALIZE:
initialize(pEvent);
break;
case FINALIZE:
finalize(pEvent);
break;
case VALIDATE:
validate(pEvent);
break;
default:
break;
}
}
} | [
"private",
"void",
"pvFireEventLocal",
"(",
"DBSReportBeanEvent",
"pEvent",
")",
"throws",
"DBSIOException",
"{",
"if",
"(",
"pEvent",
".",
"isOk",
"(",
")",
")",
"{",
"switch",
"(",
"pEvent",
".",
"getEvent",
"(",
")",
")",
"{",
"case",
"INITIALIZE",
":",
"initialize",
"(",
"pEvent",
")",
";",
"break",
";",
"case",
"FINALIZE",
":",
"finalize",
"(",
"pEvent",
")",
";",
"break",
";",
"case",
"VALIDATE",
":",
"validate",
"(",
"pEvent",
")",
";",
"break",
";",
"default",
":",
"break",
";",
"}",
"}",
"}"
] | [
396,
1
] | [
412,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Formatacao. | null | Formatação e tratamento dos dados do indicador ALFA 3101C | Formatação e tratamento dos dados do indicador ALFA 3101C | public static Map<String, String> formatarDados3101C(String dado) {
Map<String, String> dados = new HashMap<String, String>();
//String dado = dataSerial();
String peso_bru = "";
String peso_liq = "";
String tara = "";
boolean sobrecarga = dado.contains("S<BRE");
boolean saturado = dado.contains("SATURA");
boolean temVirgula = dado.contains(",");
boolean comTara = false;
int casasDecimais = 0;
try {
//ALOCAÇÃO DE VALORES
if (temVirgula && !sobrecarga && !saturado) { //Se tiver virgula nos dados e não tiver sobrecarga/saturada
peso_bru = dado.substring(3, 10).replaceAll(",", "."); // Peso Bruto ( 00,000)
peso_liq = dado.substring(3, 10).replaceAll(",", "."); // Peso Liquido ( 00,000)
tara = dado.substring(13, 20).replaceAll(",", "."); // Tara( 00,000)
casasDecimais = (6 - tara.indexOf(".")); // Conta as casas decimais
} else if (!temVirgula && !sobrecarga && !saturado) { //Se não tiver virgula nos dados e não tiver sobrecarga/saturada
peso_bru = dado.substring(3, 9); // Peso Bruto ( 00000)
peso_liq = dado.substring(3, 9); // Peso Liquido ( 00000)
tara = dado.substring(12, 18); // Tara ( 00000)
}
//
if (!sobrecarga && !saturado) { //Se não estiver com sobrecarga/saturado
List<String> pesos = new ArrayList<String>();
pesos.add(peso_bru);
pesos.add(peso_liq);
pesos.add(tara);
int cnt = 0;
for (String peso : pesos) { //Para cada tipo de peso formatar
if (peso.equals(" 00000")) { //Se todos os digitos forem zero
peso = "0";
} else {
if (peso.contains("-")) { //Se tiver sinal negativo
if (peso.contains(".")) { // Se tiver ponto decimal
int pos = peso.indexOf(".");
//Retira os zeros a esquerda em excesso do sinal negativo até o ponto decimal
peso = "-" + peso.replace(peso.substring(0, (pos - 1)), peso.substring(1, (pos - 1)).replaceFirst("0*", ""));
} else { //Se não tiver ponto decimal
//Retira os zeros a esquerda mantém o sinal negativo
peso = "-" + peso.substring(1, 6).replaceFirst("0*", ""); //OK
}
} else { //Se tiver sinal positivo
if (peso.contains(".")) { //Se tiver ponto decimal
int pos = peso.indexOf(".");
//Retira zeros a esquerda em excesso até o ponto decimal
peso = (pos <= 2) ? peso.replaceFirst(peso.substring(1, (pos - 1)), peso.substring(1, (pos - 1)).replaceFirst("0*", "")) : peso.replace(peso.substring(1, (pos - 1)), peso.substring(1, (pos - 1)).replaceFirst("0*", ""));
} else { //Se não tiver ponto decimal
try {//Tente realizar essa substituição
//Retira zeros a esquerda
peso = peso.substring(1, 6).replaceFirst("0*", ""); //OK
} catch (Exception ex) { //Se houver problema use este bloco
//Retira zeros a esquerda
peso = peso.substring(1, 5).replaceFirst("0*", ""); //OK
}
}
}
}
//Retira espaços em branco do peso
peso = peso.trim();
//Atualiza o valor na lista de pesos
pesos.set(cnt, peso);
//Pega o valor de acordo com a contagem e atribui a variavel correta
switch (cnt) {
case 0:
peso_bru = peso;
break;
case 1:
peso_liq = peso;
break;
case 2:
//Identifica se tem tara(Valor diferente de 0)
if (Double.parseDouble(peso) != 0.0) {
comTara = true;
}
tara = peso;
break;
}
cnt++;
}
if (comTara) { //Se tiver tara
if (temVirgula) { //Se a tara tiver ponto decimal
//Faz o calculo do peso liquido com tara para resultar o peso bruto(com ponto decimal).
Float pb = Float.parseFloat(peso_liq) + Float.parseFloat(tara);
dados.put("peso_bru", formatoDecimal(casasDecimais, pb));
} else { // Se não tiver ponto decimal
//Faz o calculo do peso liquido com tara para resultar o peso bruto(sem ponto decimal).
int pb = Integer.parseInt(peso_liq) + Integer.parseInt(tara);
dados.put("peso_bru", String.valueOf(pb));
}
} else { //Se não tiver tara
dados.put("peso_bru", peso_bru);
}
dados.put("estavel", !dado.contains("*") ? "E" : "O");
dados.put("peso_liq", peso_liq);
dados.put("tara", tara);
} else if (sobrecarga) { //Se estiver com sobrecarga
dados.put("estavel", "SOB");
dados.put("peso_bru", "0");
dados.put("peso_liq", "0");
dados.put("tara", "0");
} else if (saturado) { //Se estiver saturado
dados.put("estavel", "SAT");
dados.put("peso_bru", "0");
dados.put("peso_liq", "0");
dados.put("tara", "0");
}
} catch (Exception ex) { //Se houver erro na formatação dos dados
dados.put("estavel", "ERR");
dados.put("peso_bru", "0");
dados.put("peso_liq", "0");
dados.put("tara", "0");
}
System.out.println("Peso Bruto: " + dados.get("peso_bru") + "/ Peso Liquido : " + dados.get("peso_liq") + "/ Tara : " + dados.get("tara"));
return dados;
} | [
"public",
"static",
"Map",
"<",
"String",
",",
"String",
">",
"formatarDados3101C",
"(",
"String",
"dado",
")",
"{",
"Map",
"<",
"String",
",",
"String",
">",
"dados",
"=",
"new",
"HashMap",
"<",
"String",
",",
"String",
">",
"(",
")",
";",
"//String dado = dataSerial();\r",
"String",
"peso_bru",
"=",
"\"\"",
";",
"String",
"peso_liq",
"=",
"\"\"",
";",
"String",
"tara",
"=",
"\"\"",
";",
"boolean",
"sobrecarga",
"=",
"dado",
".",
"contains",
"(",
"\"S<BRE\"",
")",
";",
"boolean",
"saturado",
"=",
"dado",
".",
"contains",
"(",
"\"SATURA\"",
")",
";",
"boolean",
"temVirgula",
"=",
"dado",
".",
"contains",
"(",
"\",\"",
")",
";",
"boolean",
"comTara",
"=",
"false",
";",
"int",
"casasDecimais",
"=",
"0",
";",
"try",
"{",
"//ALOCAÇÃO DE VALORES\r",
"if",
"(",
"temVirgula",
"&&",
"!",
"sobrecarga",
"&&",
"!",
"saturado",
")",
"{",
"//Se tiver virgula nos dados e não tiver sobrecarga/saturada\r",
"peso_bru",
"=",
"dado",
".",
"substring",
"(",
"3",
",",
"10",
")",
".",
"replaceAll",
"(",
"\",\"",
",",
"\".\"",
")",
";",
"// Peso Bruto ( 00,000) \r",
"peso_liq",
"=",
"dado",
".",
"substring",
"(",
"3",
",",
"10",
")",
".",
"replaceAll",
"(",
"\",\"",
",",
"\".\"",
")",
";",
"// Peso Liquido ( 00,000) \r",
"tara",
"=",
"dado",
".",
"substring",
"(",
"13",
",",
"20",
")",
".",
"replaceAll",
"(",
"\",\"",
",",
"\".\"",
")",
";",
"// Tara( 00,000) \r",
"casasDecimais",
"=",
"(",
"6",
"-",
"tara",
".",
"indexOf",
"(",
"\".\"",
")",
")",
";",
"// Conta as casas decimais\r",
"}",
"else",
"if",
"(",
"!",
"temVirgula",
"&&",
"!",
"sobrecarga",
"&&",
"!",
"saturado",
")",
"{",
"//Se não tiver virgula nos dados e não tiver sobrecarga/saturada\r",
"peso_bru",
"=",
"dado",
".",
"substring",
"(",
"3",
",",
"9",
")",
";",
"// Peso Bruto ( 00000) \r",
"peso_liq",
"=",
"dado",
".",
"substring",
"(",
"3",
",",
"9",
")",
";",
"// Peso Liquido ( 00000) \r",
"tara",
"=",
"dado",
".",
"substring",
"(",
"12",
",",
"18",
")",
";",
"// Tara ( 00000) \r",
"}",
"//\r",
"if",
"(",
"!",
"sobrecarga",
"&&",
"!",
"saturado",
")",
"{",
"//Se não estiver com sobrecarga/saturado\r",
"List",
"<",
"String",
">",
"pesos",
"=",
"new",
"ArrayList",
"<",
"String",
">",
"(",
")",
";",
"pesos",
".",
"add",
"(",
"peso_bru",
")",
";",
"pesos",
".",
"add",
"(",
"peso_liq",
")",
";",
"pesos",
".",
"add",
"(",
"tara",
")",
";",
"int",
"cnt",
"=",
"0",
";",
"for",
"(",
"String",
"peso",
":",
"pesos",
")",
"{",
"//Para cada tipo de peso formatar\r",
"if",
"(",
"peso",
".",
"equals",
"(",
"\" 00000\"",
")",
")",
"{",
"//Se todos os digitos forem zero\r",
"peso",
"=",
"\"0\"",
";",
"}",
"else",
"{",
"if",
"(",
"peso",
".",
"contains",
"(",
"\"-\"",
")",
")",
"{",
"//Se tiver sinal negativo\r",
"if",
"(",
"peso",
".",
"contains",
"(",
"\".\"",
")",
")",
"{",
"// Se tiver ponto decimal\r",
"int",
"pos",
"=",
"peso",
".",
"indexOf",
"(",
"\".\"",
")",
";",
"//Retira os zeros a esquerda em excesso do sinal negativo até o ponto decimal\r",
"peso",
"=",
"\"-\"",
"+",
"peso",
".",
"replace",
"(",
"peso",
".",
"substring",
"(",
"0",
",",
"(",
"pos",
"-",
"1",
")",
")",
",",
"peso",
".",
"substring",
"(",
"1",
",",
"(",
"pos",
"-",
"1",
")",
")",
".",
"replaceFirst",
"(",
"\"0*\"",
",",
"\"\"",
")",
")",
";",
"}",
"else",
"{",
"//Se não tiver ponto decimal\r",
"//Retira os zeros a esquerda mantém o sinal negativo\r",
"peso",
"=",
"\"-\"",
"+",
"peso",
".",
"substring",
"(",
"1",
",",
"6",
")",
".",
"replaceFirst",
"(",
"\"0*\"",
",",
"\"\"",
")",
";",
"//OK\r",
"}",
"}",
"else",
"{",
"//Se tiver sinal positivo\r",
"if",
"(",
"peso",
".",
"contains",
"(",
"\".\"",
")",
")",
"{",
"//Se tiver ponto decimal\r",
"int",
"pos",
"=",
"peso",
".",
"indexOf",
"(",
"\".\"",
")",
";",
"//Retira zeros a esquerda em excesso até o ponto decimal\r",
"peso",
"=",
"(",
"pos",
"<=",
"2",
")",
"?",
"peso",
".",
"replaceFirst",
"(",
"peso",
".",
"substring",
"(",
"1",
",",
"(",
"pos",
"-",
"1",
")",
")",
",",
"peso",
".",
"substring",
"(",
"1",
",",
"(",
"pos",
"-",
"1",
")",
")",
".",
"replaceFirst",
"(",
"\"0*\"",
",",
"\"\"",
")",
")",
":",
"peso",
".",
"replace",
"(",
"peso",
".",
"substring",
"(",
"1",
",",
"(",
"pos",
"-",
"1",
")",
")",
",",
"peso",
".",
"substring",
"(",
"1",
",",
"(",
"pos",
"-",
"1",
")",
")",
".",
"replaceFirst",
"(",
"\"0*\"",
",",
"\"\"",
")",
")",
";",
"}",
"else",
"{",
"//Se não tiver ponto decimal\r",
"try",
"{",
"//Tente realizar essa substituição\r",
"//Retira zeros a esquerda\r",
"peso",
"=",
"peso",
".",
"substring",
"(",
"1",
",",
"6",
")",
".",
"replaceFirst",
"(",
"\"0*\"",
",",
"\"\"",
")",
";",
"//OK\r",
"}",
"catch",
"(",
"Exception",
"ex",
")",
"{",
"//Se houver problema use este bloco\r",
"//Retira zeros a esquerda\r",
"peso",
"=",
"peso",
".",
"substring",
"(",
"1",
",",
"5",
")",
".",
"replaceFirst",
"(",
"\"0*\"",
",",
"\"\"",
")",
";",
"//OK\r",
"}",
"}",
"}",
"}",
"//Retira espaços em branco do peso\r",
"peso",
"=",
"peso",
".",
"trim",
"(",
")",
";",
"//Atualiza o valor na lista de pesos\r",
"pesos",
".",
"set",
"(",
"cnt",
",",
"peso",
")",
";",
"//Pega o valor de acordo com a contagem e atribui a variavel correta\r",
"switch",
"(",
"cnt",
")",
"{",
"case",
"0",
":",
"peso_bru",
"=",
"peso",
";",
"break",
";",
"case",
"1",
":",
"peso_liq",
"=",
"peso",
";",
"break",
";",
"case",
"2",
":",
"//Identifica se tem tara(Valor diferente de 0)\r",
"if",
"(",
"Double",
".",
"parseDouble",
"(",
"peso",
")",
"!=",
"0.0",
")",
"{",
"comTara",
"=",
"true",
";",
"}",
"tara",
"=",
"peso",
";",
"break",
";",
"}",
"cnt",
"++",
";",
"}",
"if",
"(",
"comTara",
")",
"{",
"//Se tiver tara\r",
"if",
"(",
"temVirgula",
")",
"{",
"//Se a tara tiver ponto decimal\r",
"//Faz o calculo do peso liquido com tara para resultar o peso bruto(com ponto decimal).\r",
"Float",
"pb",
"=",
"Float",
".",
"parseFloat",
"(",
"peso_liq",
")",
"+",
"Float",
".",
"parseFloat",
"(",
"tara",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_bru\"",
",",
"formatoDecimal",
"(",
"casasDecimais",
",",
"pb",
")",
")",
";",
"}",
"else",
"{",
"// Se não tiver ponto decimal\r",
"//Faz o calculo do peso liquido com tara para resultar o peso bruto(sem ponto decimal).\r",
"int",
"pb",
"=",
"Integer",
".",
"parseInt",
"(",
"peso_liq",
")",
"+",
"Integer",
".",
"parseInt",
"(",
"tara",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_bru\"",
",",
"String",
".",
"valueOf",
"(",
"pb",
")",
")",
";",
"}",
"}",
"else",
"{",
"//Se não tiver tara\r",
"dados",
".",
"put",
"(",
"\"peso_bru\"",
",",
"peso_bru",
")",
";",
"}",
"dados",
".",
"put",
"(",
"\"estavel\"",
",",
"!",
"dado",
".",
"contains",
"(",
"\"*\"",
")",
"?",
"\"E\"",
":",
"\"O\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_liq\"",
",",
"peso_liq",
")",
";",
"dados",
".",
"put",
"(",
"\"tara\"",
",",
"tara",
")",
";",
"}",
"else",
"if",
"(",
"sobrecarga",
")",
"{",
"//Se estiver com sobrecarga\r",
"dados",
".",
"put",
"(",
"\"estavel\"",
",",
"\"SOB\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_bru\"",
",",
"\"0\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_liq\"",
",",
"\"0\"",
")",
";",
"dados",
".",
"put",
"(",
"\"tara\"",
",",
"\"0\"",
")",
";",
"}",
"else",
"if",
"(",
"saturado",
")",
"{",
"//Se estiver saturado\r",
"dados",
".",
"put",
"(",
"\"estavel\"",
",",
"\"SAT\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_bru\"",
",",
"\"0\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_liq\"",
",",
"\"0\"",
")",
";",
"dados",
".",
"put",
"(",
"\"tara\"",
",",
"\"0\"",
")",
";",
"}",
"}",
"catch",
"(",
"Exception",
"ex",
")",
"{",
"//Se houver erro na formatação dos dados\r",
"dados",
".",
"put",
"(",
"\"estavel\"",
",",
"\"ERR\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_bru\"",
",",
"\"0\"",
")",
";",
"dados",
".",
"put",
"(",
"\"peso_liq\"",
",",
"\"0\"",
")",
";",
"dados",
".",
"put",
"(",
"\"tara\"",
",",
"\"0\"",
")",
";",
"}",
"System",
".",
"out",
".",
"println",
"(",
"\"Peso Bruto: \"",
"+",
"dados",
".",
"get",
"(",
"\"peso_bru\"",
")",
"+",
"\"/ Peso Liquido : \"",
"+",
"dados",
".",
"get",
"(",
"\"peso_liq\"",
")",
"+",
"\"/ Tara : \"",
"+",
"dados",
".",
"get",
"(",
"\"tara\"",
")",
")",
";",
"return",
"dados",
";",
"}"
] | [
22,
4
] | [
148,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FuncoesTopicos. | null | Carrega as cidades excluindo as repetidas | Carrega as cidades excluindo as repetidas | public static void iniciaDados() throws Exception{
gerenciarArquivo.abrirArquivo(0);
imoveis = gerenciarArquivo.leituraImoveis();
gerenciarArquivo.fecharArquivo(0);
listaCidades();
/* for (Imovel imovel : imoveis)
System.out.println(imovel.imprimirClasse());*/
} | [
"public",
"static",
"void",
"iniciaDados",
"(",
")",
"throws",
"Exception",
"{",
"gerenciarArquivo",
".",
"abrirArquivo",
"(",
"0",
")",
";",
"imoveis",
"=",
"gerenciarArquivo",
".",
"leituraImoveis",
"(",
")",
";",
"gerenciarArquivo",
".",
"fecharArquivo",
"(",
"0",
")",
";",
"listaCidades",
"(",
")",
";",
"/* for (Imovel imovel : imoveis) \n System.out.println(imovel.imprimirClasse());*/",
"}"
] | [
16,
4
] | [
23,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Jogador. | null | método invocado pela classe Jogo, para atribuir ao jogador suas peças após análise do tabuleiro carregado em arquivo: | método invocado pela classe Jogo, para atribuir ao jogador suas peças após análise do tabuleiro carregado em arquivo: | public void setPecas(Peca equipe[]) {
this.pecas = equipe;
} | [
"public",
"void",
"setPecas",
"(",
"Peca",
"equipe",
"[",
"]",
")",
"{",
"this",
".",
"pecas",
"=",
"equipe",
";",
"}"
] | [
24,
4
] | [
26,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Main. | null | Liste o nome completo (coluna `full_name`) dos 20 primeiros jogadores. | Liste o nome completo (coluna `full_name`) dos 20 primeiros jogadores. | public List<String> q3() {
return this.jogadores
.stream()
.limit(20)
.map(Jogador::getFullname)
.collect(Collectors.toList());
} | [
"public",
"List",
"<",
"String",
">",
"q3",
"(",
")",
"{",
"return",
"this",
".",
"jogadores",
".",
"stream",
"(",
")",
".",
"limit",
"(",
"20",
")",
".",
"map",
"(",
"Jogador",
"::",
"getFullname",
")",
".",
"collect",
"(",
"Collectors",
".",
"toList",
"(",
")",
")",
";",
"}"
] | [
35,
1
] | [
41,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Lote. | null | Retorna um boolean que valida o lote de acordo com a data de chegada e quantidade de vacinas | Retorna um boolean que valida o lote de acordo com a data de chegada e quantidade de vacinas | public boolean loteValido() {
return ((getDataDeChegada().equals(LocalDate.now()) || getDataDeChegada().equals(LocalDateTime.now().minusDays(1)))&& getQtdeDeVacinasFechadas()!=0);
} | [
"public",
"boolean",
"loteValido",
"(",
")",
"{",
"return",
"(",
"(",
"getDataDeChegada",
"(",
")",
".",
"equals",
"(",
"LocalDate",
".",
"now",
"(",
")",
")",
"||",
"getDataDeChegada",
"(",
")",
".",
"equals",
"(",
"LocalDateTime",
".",
"now",
"(",
")",
".",
"minusDays",
"(",
"1",
")",
")",
")",
"&&",
"getQtdeDeVacinasFechadas",
"(",
")",
"!=",
"0",
")",
";",
"}"
] | [
87,
1
] | [
89,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ReajusteServiceTest. | null | BeforeAll e AfterAll que rodam antes e após todos, precisam ser estáticos | BeforeAll e AfterAll que rodam antes e após todos, precisam ser estáticos | @BeforeAll
public static void antesDeTodos() {
System.out.println(" == Before All = Printa antes de todos! ==");
} | [
"@",
"BeforeAll",
"public",
"static",
"void",
"antesDeTodos",
"(",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"\" == Before All = Printa antes de todos! ==\"",
")",
";",
"}"
] | [
17,
4
] | [
20,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
clienteController. | null | Serviço para realizar um saque dessa conta corrente | Serviço para realizar um saque dessa conta corrente | @PutMapping("/v1/saque/{numeroConta}")
public ResponseEntity<Object> saque(@PathVariable("numeroConta") double numeroConta, @RequestBody double valor){
try {
Cliente cliente = clienteRepository.getOne(numeroConta);
cliente.saque(valor);
Cliente clienteSaque = clienteRepository.save(cliente);
return ResponseEntity.ok(clienteSaque);
} catch (Exception e) {
e.printStackTrace();
return ResponseEntity.status(500).body(null);
}
} | [
"@",
"PutMapping",
"(",
"\"/v1/saque/{numeroConta}\"",
")",
"public",
"ResponseEntity",
"<",
"Object",
">",
"saque",
"(",
"@",
"PathVariable",
"(",
"\"numeroConta\"",
")",
"double",
"numeroConta",
",",
"@",
"RequestBody",
"double",
"valor",
")",
"{",
"try",
"{",
"Cliente",
"cliente",
"=",
"clienteRepository",
".",
"getOne",
"(",
"numeroConta",
")",
";",
"cliente",
".",
"saque",
"(",
"valor",
")",
";",
"Cliente",
"clienteSaque",
"=",
"clienteRepository",
".",
"save",
"(",
"cliente",
")",
";",
"return",
"ResponseEntity",
".",
"ok",
"(",
"clienteSaque",
")",
";",
"}",
"catch",
"(",
"Exception",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"return",
"ResponseEntity",
".",
"status",
"(",
"500",
")",
".",
"body",
"(",
"null",
")",
";",
"}",
"}"
] | [
64,
4
] | [
75,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
NetworkToolkit. | null | Responsavel por realizar a operação de POST | Responsavel por realizar a operação de POST | public static String doPost(String url, String postContent) {
String retorno = "";
try {
URL apiEnd = new URL(url);
int codigoResposta;
HttpURLConnection conexao;
InputStream is;
conexao = (HttpURLConnection) apiEnd.openConnection();
conexao.setRequestMethod("POST");
conexao.setReadTimeout(15000);
conexao.setConnectTimeout(15000);
conexao.setDoInput(true);
conexao.setDoOutput(true);
OutputStream os = conexao.getOutputStream();
PrintStream ps = new PrintStream(os);
ps.print(postContent);
ps.close();
conexao.connect();
codigoResposta = conexao.getResponseCode();
if(codigoResposta < HttpURLConnection.HTTP_BAD_REQUEST){
is = conexao.getInputStream();
}else{
is = conexao.getErrorStream();
}
retorno = converterInputStreamToString(is);
os.close();
conexao.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return retorno;
} | [
"public",
"static",
"String",
"doPost",
"(",
"String",
"url",
",",
"String",
"postContent",
")",
"{",
"String",
"retorno",
"=",
"\"\"",
";",
"try",
"{",
"URL",
"apiEnd",
"=",
"new",
"URL",
"(",
"url",
")",
";",
"int",
"codigoResposta",
";",
"HttpURLConnection",
"conexao",
";",
"InputStream",
"is",
";",
"conexao",
"=",
"(",
"HttpURLConnection",
")",
"apiEnd",
".",
"openConnection",
"(",
")",
";",
"conexao",
".",
"setRequestMethod",
"(",
"\"POST\"",
")",
";",
"conexao",
".",
"setReadTimeout",
"(",
"15000",
")",
";",
"conexao",
".",
"setConnectTimeout",
"(",
"15000",
")",
";",
"conexao",
".",
"setDoInput",
"(",
"true",
")",
";",
"conexao",
".",
"setDoOutput",
"(",
"true",
")",
";",
"OutputStream",
"os",
"=",
"conexao",
".",
"getOutputStream",
"(",
")",
";",
"PrintStream",
"ps",
"=",
"new",
"PrintStream",
"(",
"os",
")",
";",
"ps",
".",
"print",
"(",
"postContent",
")",
";",
"ps",
".",
"close",
"(",
")",
";",
"conexao",
".",
"connect",
"(",
")",
";",
"codigoResposta",
"=",
"conexao",
".",
"getResponseCode",
"(",
")",
";",
"if",
"(",
"codigoResposta",
"<",
"HttpURLConnection",
".",
"HTTP_BAD_REQUEST",
")",
"{",
"is",
"=",
"conexao",
".",
"getInputStream",
"(",
")",
";",
"}",
"else",
"{",
"is",
"=",
"conexao",
".",
"getErrorStream",
"(",
")",
";",
"}",
"retorno",
"=",
"converterInputStreamToString",
"(",
"is",
")",
";",
"os",
".",
"close",
"(",
")",
";",
"conexao",
".",
"disconnect",
"(",
")",
";",
"}",
"catch",
"(",
"MalformedURLException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"e",
".",
"printStackTrace",
"(",
")",
";",
"}",
"return",
"retorno",
";",
"}"
] | [
52,
4
] | [
94,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
AreaDoProfessorController. | null | Metodo da janela de dialogo, para salvar os dados do Professor | Metodo da janela de dialogo, para salvar os dados do Professor | private void createDialogForm(Professor obj, String absoluteName, Stage parentStage) {
try {
FXMLLoader loader = new FXMLLoader(getClass().getResource(absoluteName));
Pane pane = loader.load();
//instancia um novo stage , criando um novo stage
ProfessorFormController controller = loader.getController();
controller.setProfessor(obj);
controller.setProfessorService(new ProfessorService());
controller.subscribeDataChangeListener(this);//Inscrevendo para receber o metodo onDataChange, obseervable list
controller.updateFormData(); //Carrega o Department no formulario
Stage dialogStage = new Stage();
dialogStage.setTitle("Enter Professor data");
dialogStage.setScene(new Scene(pane));
dialogStage.setResizable(false); //Resizable: Diz se janela pode ser redimencionada
dialogStage.initOwner(parentStage);
dialogStage.initModality(Modality.WINDOW_MODAL);//Trava a janela
dialogStage.showAndWait();
} catch (IOException e) {
Alerts.showAlert("IO Exception", "Error loading view ", e.getMessage(), Alert.AlertType.ERROR);
}
} | [
"private",
"void",
"createDialogForm",
"(",
"Professor",
"obj",
",",
"String",
"absoluteName",
",",
"Stage",
"parentStage",
")",
"{",
"try",
"{",
"FXMLLoader",
"loader",
"=",
"new",
"FXMLLoader",
"(",
"getClass",
"(",
")",
".",
"getResource",
"(",
"absoluteName",
")",
")",
";",
"Pane",
"pane",
"=",
"loader",
".",
"load",
"(",
")",
";",
"//instancia um novo stage , criando um novo stage",
"ProfessorFormController",
"controller",
"=",
"loader",
".",
"getController",
"(",
")",
";",
"controller",
".",
"setProfessor",
"(",
"obj",
")",
";",
"controller",
".",
"setProfessorService",
"(",
"new",
"ProfessorService",
"(",
")",
")",
";",
"controller",
".",
"subscribeDataChangeListener",
"(",
"this",
")",
";",
"//Inscrevendo para receber o metodo onDataChange, obseervable list",
"controller",
".",
"updateFormData",
"(",
")",
";",
"//Carrega o Department no formulario",
"Stage",
"dialogStage",
"=",
"new",
"Stage",
"(",
")",
";",
"dialogStage",
".",
"setTitle",
"(",
"\"Enter Professor data\"",
")",
";",
"dialogStage",
".",
"setScene",
"(",
"new",
"Scene",
"(",
"pane",
")",
")",
";",
"dialogStage",
".",
"setResizable",
"(",
"false",
")",
";",
"//Resizable: Diz se janela pode ser redimencionada",
"dialogStage",
".",
"initOwner",
"(",
"parentStage",
")",
";",
"dialogStage",
".",
"initModality",
"(",
"Modality",
".",
"WINDOW_MODAL",
")",
";",
"//Trava a janela",
"dialogStage",
".",
"showAndWait",
"(",
")",
";",
"}",
"catch",
"(",
"IOException",
"e",
")",
"{",
"Alerts",
".",
"showAlert",
"(",
"\"IO Exception\"",
",",
"\"Error loading view \"",
",",
"e",
".",
"getMessage",
"(",
")",
",",
"Alert",
".",
"AlertType",
".",
"ERROR",
")",
";",
"}",
"}"
] | [
143,
4
] | [
165,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
SecurityConfig. | null | Este método restringe e permite o acesso do usuário a determinadas páginas do site. | Este método restringe e permite o acesso do usuário a determinadas páginas do site. | @Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/estilo/**", "/imagens/**", "/usuarios/cadastro").permitAll()
.antMatchers("/publico/**", "/usuarios/salvar", "/").permitAll()
.antMatchers("/usuarios/busca**", "/buscar/**", "/usuarios/editar/**",
"/usuarios/remover**", "/dominio/buscaDominio**", "/dominio/editar/**", "/dominio/remover**", "/download").hasAuthority(Usuario.ADMIN)
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.defaultSuccessUrl("/", true)
.failureUrl("/login-error")
.permitAll()
.and()
.logout()
.logoutSuccessUrl("/");
} | [
"@",
"Override",
"protected",
"void",
"configure",
"(",
"HttpSecurity",
"http",
")",
"throws",
"Exception",
"{",
"http",
".",
"authorizeRequests",
"(",
")",
".",
"antMatchers",
"(",
"\"/estilo/**\"",
",",
"\"/imagens/**\"",
",",
"\"/usuarios/cadastro\"",
")",
".",
"permitAll",
"(",
")",
".",
"antMatchers",
"(",
"\"/publico/**\"",
",",
"\"/usuarios/salvar\"",
",",
"\"/\"",
")",
".",
"permitAll",
"(",
")",
".",
"antMatchers",
"(",
"\"/usuarios/busca**\"",
",",
"\"/buscar/**\"",
",",
"\"/usuarios/editar/**\"",
",",
"\"/usuarios/remover**\"",
",",
"\"/dominio/buscaDominio**\"",
",",
"\"/dominio/editar/**\"",
",",
"\"/dominio/remover**\"",
",",
"\"/download\"",
")",
".",
"hasAuthority",
"(",
"Usuario",
".",
"ADMIN",
")",
".",
"anyRequest",
"(",
")",
".",
"authenticated",
"(",
")",
".",
"and",
"(",
")",
".",
"formLogin",
"(",
")",
".",
"loginPage",
"(",
"\"/login\"",
")",
".",
"defaultSuccessUrl",
"(",
"\"/\"",
",",
"true",
")",
".",
"failureUrl",
"(",
"\"/login-error\"",
")",
".",
"permitAll",
"(",
")",
".",
"and",
"(",
")",
".",
"logout",
"(",
")",
".",
"logoutSuccessUrl",
"(",
"\"/\"",
")",
";",
"}"
] | [
23,
2
] | [
41,
3
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ScenePrincipal. | null | Função interna que cria uma reta! | Função interna que cria uma reta! | private Reta construirReta(){
Ponto p1 = new Ponto(Double.parseDouble(textP1x.getText()),
Double.parseDouble(textP1y.getText()));
Ponto p2 = new Ponto(Double.parseDouble(textP2x.getText()),
Double.parseDouble(textP2y.getText()));
Reta reta = new Reta(p1,p2);
return reta;
} | [
"private",
"Reta",
"construirReta",
"(",
")",
"{",
"Ponto",
"p1",
"=",
"new",
"Ponto",
"(",
"Double",
".",
"parseDouble",
"(",
"textP1x",
".",
"getText",
"(",
")",
")",
",",
"Double",
".",
"parseDouble",
"(",
"textP1y",
".",
"getText",
"(",
")",
")",
")",
";",
"Ponto",
"p2",
"=",
"new",
"Ponto",
"(",
"Double",
".",
"parseDouble",
"(",
"textP2x",
".",
"getText",
"(",
")",
")",
",",
"Double",
".",
"parseDouble",
"(",
"textP2y",
".",
"getText",
"(",
")",
")",
")",
";",
"Reta",
"reta",
"=",
"new",
"Reta",
"(",
"p1",
",",
"p2",
")",
";",
"return",
"reta",
";",
"}"
] | [
81,
4
] | [
90,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
FramePrincipal. | null | esse método vai criar a tela para o usuário com os devidos parâmetros | esse método vai criar a tela para o usuário com os devidos parâmetros | public void novaTela(int id){
//cria a tela
tela = new Tela(id);
add(tela);
setSize(700, 500);
setResizable(false);
setTitle("A Gun To Kill");
setLocationRelativeTo(this);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//cria o verificador do final da partida
Verificador verifica = new Verificador();
verifica.start();
} | [
"public",
"void",
"novaTela",
"(",
"int",
"id",
")",
"{",
"//cria a tela",
"tela",
"=",
"new",
"Tela",
"(",
"id",
")",
";",
"add",
"(",
"tela",
")",
";",
"setSize",
"(",
"700",
",",
"500",
")",
";",
"setResizable",
"(",
"false",
")",
";",
"setTitle",
"(",
"\"A Gun To Kill\"",
")",
";",
"setLocationRelativeTo",
"(",
"this",
")",
";",
"setDefaultCloseOperation",
"(",
"JFrame",
".",
"EXIT_ON_CLOSE",
")",
";",
"//cria o verificador do final da partida",
"Verificador",
"verifica",
"=",
"new",
"Verificador",
"(",
")",
";",
"verifica",
".",
"start",
"(",
")",
";",
"}"
] | [
102,
4
] | [
114,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
UserService. | null | busca o id do usuario no banco e retorna exceção se não encontrar | busca o id do usuario no banco e retorna exceção se não encontrar | public UserDetails loadUserById(Long userId) {
Optional<UserModel> user = userRepository.findById(userId);
return user.orElseThrow(() -> new UsernameNotFoundException("ID not found!"));
} | [
"public",
"UserDetails",
"loadUserById",
"(",
"Long",
"userId",
")",
"{",
"Optional",
"<",
"UserModel",
">",
"user",
"=",
"userRepository",
".",
"findById",
"(",
"userId",
")",
";",
"return",
"user",
".",
"orElseThrow",
"(",
"(",
")",
"->",
"new",
"UsernameNotFoundException",
"(",
"\"ID not found!\"",
")",
")",
";",
"}"
] | [
32,
4
] | [
36,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
LBSTree. | null | Encontra o item com menor valor na subarvore | Encontra o item com menor valor na subarvore | protected LBSTreeNode valorMaximo(LBSTreeNode treeNode) {
while (treeNode.linkRight != null) {
treeNode = treeNode.linkRight;
}
return(treeNode);
} | [
"protected",
"LBSTreeNode",
"valorMaximo",
"(",
"LBSTreeNode",
"treeNode",
")",
"{",
"while",
"(",
"treeNode",
".",
"linkRight",
"!=",
"null",
")",
"{",
"treeNode",
"=",
"treeNode",
".",
"linkRight",
";",
"}",
"return",
"(",
"treeNode",
")",
";",
"}"
] | [
122,
1
] | [
127,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
MainSceneController. | null | Metodo para tratar os eventos do menu item Aluno | Metodo para tratar os eventos do menu item Aluno | @FXML
public void onMenuItemAlunoAction() {
loadView("AreaDoAlunoController.fxml", (AreaDoAlunoController controller) -> {
controller.setAlunoService(new AlunoService()); //AlunoService tem metodo que recebe colecao de Aluno
controller.updateTableView(); //Metodo updateView recebe
});
} | [
"@",
"FXML",
"public",
"void",
"onMenuItemAlunoAction",
"(",
")",
"{",
"loadView",
"(",
"\"AreaDoAlunoController.fxml\"",
",",
"(",
"AreaDoAlunoController",
"controller",
")",
"->",
"{",
"controller",
".",
"setAlunoService",
"(",
"new",
"AlunoService",
"(",
")",
")",
";",
"//AlunoService tem metodo que recebe colecao de Aluno",
"controller",
".",
"updateTableView",
"(",
")",
";",
"//Metodo updateView recebe ",
"}",
")",
";",
"}"
] | [
45,
4
] | [
51,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Alien. | null | Método de colisão | Método de colisão | public void collide(Missile tiro) {
if (tiro != null && tiro.vivo) {
//Se o tiro estiver no alien
if (tiro.x > x && tiro.x < x + width && tiro.y > y && tiro.y < y + height) {
tiro.vivo = false; //tiro morto
vivo = false; //alien morto
death+= 100;
}
}
} | [
"public",
"void",
"collide",
"(",
"Missile",
"tiro",
")",
"{",
"if",
"(",
"tiro",
"!=",
"null",
"&&",
"tiro",
".",
"vivo",
")",
"{",
"//Se o tiro estiver no alien",
"if",
"(",
"tiro",
".",
"x",
">",
"x",
"&&",
"tiro",
".",
"x",
"<",
"x",
"+",
"width",
"&&",
"tiro",
".",
"y",
">",
"y",
"&&",
"tiro",
".",
"y",
"<",
"y",
"+",
"height",
")",
"{",
"tiro",
".",
"vivo",
"=",
"false",
";",
"//tiro morto ",
"vivo",
"=",
"false",
";",
"//alien morto",
"death",
"+=",
"100",
";",
"}",
"}",
"}"
] | [
31,
4
] | [
43,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
WS3D_Controller. | null | Metodo que verificar quais são os leaflets para coletar | Metodo que verificar quais são os leaflets para coletar | private void BTask_Leaflts(){
// Pegando os leaflets gerados leo metodo genleaflets e atribuindo a uma lista, que será apresentada
leaflets = Creature.getLeaflets();
// Realizando a entrega dos Leaflets no deliveri spoot
// Poderiamos implementar um loop para que a entrega dos Leaflets possa ocorrer mais rapido
// O metodo String.valueOF = ira converter o retorno do metodo get do leaflets para tipo long - String
for (int i =0; i < leaflets.size(); i++){
System.out.println(i +" "+ leaflets.get(i));
//Creatura.deliverLeaflet(inputLine);
//System.out.println("Lista do Leaflets: "+leaflets.get(i).getPayment());
//System.out.println("Lista do Leaflets: "+leaflets.get(i).getItems().toString());
}
} | [
"private",
"void",
"BTask_Leaflts",
"(",
")",
"{",
"// Pegando os leaflets gerados leo metodo genleaflets e atribuindo a uma lista, que será apresentada\r",
"leaflets",
"=",
"Creature",
".",
"getLeaflets",
"(",
")",
";",
"// Realizando a entrega dos Leaflets no deliveri spoot\r",
"// Poderiamos implementar um loop para que a entrega dos Leaflets possa ocorrer mais rapido\r",
"// O metodo String.valueOF = ira converter o retorno do metodo get do leaflets para tipo long - String\r",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"leaflets",
".",
"size",
"(",
")",
";",
"i",
"++",
")",
"{",
"System",
".",
"out",
".",
"println",
"(",
"i",
"+",
"\" \"",
"+",
"leaflets",
".",
"get",
"(",
"i",
")",
")",
";",
"//Creatura.deliverLeaflet(inputLine);\r",
"//System.out.println(\"Lista do Leaflets: \"+leaflets.get(i).getPayment());\r",
"//System.out.println(\"Lista do Leaflets: \"+leaflets.get(i).getItems().toString());\r",
"}",
"}"
] | [
270,
4
] | [
282,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
teste2. | null | Função responsável pelos cliques | Função responsável pelos cliques | public void actionPerformed(ActionEvent acesso){
String sSexo="";
String sNivel="",auxiliar="";
String sExec="";
int menu_option=1;
Boolean bChave=true;
//se o acesso for via botão gravar-ok
if(acesso.getSource() == btnGrav){
//pegando o nivel de escolaridade
sNivel=cmbNiv.getSelectedItem().toString();
//verificando os radios
if(radFem.isSelected())
sSexo="F";
if(radMasc.isSelected())
sSexo="M";
//montando a frase que será mostrada
sExec="Nome = '"+texNome.getText()+"'\n"+
"Sexo = '"+sSexo+"'\n"+
"Nivel= '"+sNivel+"'\n"+
"CPF = '"+texCPF.getText()+"'\n"+
"-----------------------------\n"+
"Interesses:\n"+
"Inglês? "+chkIng.isSelected()+"\n"+
"Matemática? "+chkMat.isSelected()+"\n"+
"Programação? "+chkPro.isSelected()+"\n"+
"Lógica? "+chkLog.isSelected();
//mostrando a frase
ex.setVisible(false);
JOptionPane.showMessageDialog(null,sExec,"Atenção",1);
do{
auxiliar = (String)JOptionPane.showInputDialog(null, "0 - Sair.\n1 - Cadastro.\n2 - Remoção.\n3 - Vínculos\n4 - Consulta.\n5 - Atualizar Dados.\n6 - Entrada.\n7 - Sincronizar contas com o banco.\n8 - Enviar comprovante para os professores", null, JOptionPane.QUESTION_MESSAGE, null, null, "");
if(auxiliar == null){
auxiliar = "0";
}
menu_option = Integer.parseInt(auxiliar);
}while(menu_option !=0);
ex.setVisible(true);
//se a chave for verdadeira, chama função limpaDados
if(bChave){
limpaDados();
}
//Muda o foco do componente
texNome.grabFocus();
}
} | [
"public",
"void",
"actionPerformed",
"(",
"ActionEvent",
"acesso",
")",
"{",
"String",
"sSexo",
"=",
"\"\"",
";",
"String",
"sNivel",
"=",
"\"\"",
",",
"auxiliar",
"=",
"\"\"",
";",
"String",
"sExec",
"=",
"\"\"",
";",
"int",
"menu_option",
"=",
"1",
";",
"Boolean",
"bChave",
"=",
"true",
";",
"//se o acesso for via botão gravar-ok",
"if",
"(",
"acesso",
".",
"getSource",
"(",
")",
"==",
"btnGrav",
")",
"{",
"//pegando o nivel de escolaridade",
"sNivel",
"=",
"cmbNiv",
".",
"getSelectedItem",
"(",
")",
".",
"toString",
"(",
")",
";",
"//verificando os radios",
"if",
"(",
"radFem",
".",
"isSelected",
"(",
")",
")",
"sSexo",
"=",
"\"F\"",
";",
"if",
"(",
"radMasc",
".",
"isSelected",
"(",
")",
")",
"sSexo",
"=",
"\"M\"",
";",
"//montando a frase que será mostrada",
"sExec",
"=",
"\"Nome = '\"",
"+",
"texNome",
".",
"getText",
"(",
")",
"+",
"\"'\\n\"",
"+",
"\"Sexo = '\"",
"+",
"sSexo",
"+",
"\"'\\n\"",
"+",
"\"Nivel= '\"",
"+",
"sNivel",
"+",
"\"'\\n\"",
"+",
"\"CPF = '\"",
"+",
"texCPF",
".",
"getText",
"(",
")",
"+",
"\"'\\n\"",
"+",
"\"-----------------------------\\n\"",
"+",
"\"Interesses:\\n\"",
"+",
"\"Inglês? \"+",
"c",
"hkIng.",
"i",
"sSelected(",
")",
"+",
"\"",
"\\n\"+",
"",
"\"Matemática? \"+",
"c",
"hkMat.",
"i",
"sSelected(",
")",
"+",
"\"",
"\\n\"+",
"",
"\"Programação? \"+c",
"h",
"kPro.i",
"s",
"Selected()",
"+",
"\"",
"\\",
"n\"+",
"",
"\"Lógica? \"+",
"c",
"hkLog.",
"i",
"sSelected(",
")",
";",
"",
"//mostrando a frase",
"ex",
".",
"setVisible",
"(",
"false",
")",
";",
"JOptionPane",
".",
"showMessageDialog",
"(",
"null",
",",
"sExec",
",",
"\"Atenção\",1",
")",
";",
"",
"",
"do",
"{",
"auxiliar",
"=",
"(",
"String",
")",
"JOptionPane",
".",
"showInputDialog",
"(",
"null",
",",
"\"0 - Sair.\\n1 - Cadastro.\\n2 - Remoção.\\n3 - Vínculos\\n4 - Consulta.\\n5 - Atualizar Dados.\\n6 - Entrada.\\n7 - Sincronizar contas com o banco.\\n8 - Enviar comprovante para os professores\", n",
"u",
"l, J",
"O",
"tionPane.QU",
"E",
"STION_MESSAGE, n",
"u",
"l, n",
"u",
"l, \"",
"\"",
";",
"",
"",
"if",
"(",
"auxiliar",
"==",
"null",
")",
"{",
"auxiliar",
"=",
"\"0\"",
";",
"}",
"menu_option",
"=",
"Integer",
".",
"parseInt",
"(",
"auxiliar",
")",
";",
"}",
"while",
"(",
"menu_option",
"!=",
"0",
")",
";",
"ex",
".",
"setVisible",
"(",
"true",
")",
";",
"//se a chave for verdadeira, chama função limpaDados",
"if",
"(",
"bChave",
")",
"{",
"limpaDados",
"(",
")",
";",
"}",
"//Muda o foco do componente",
"texNome",
".",
"grabFocus",
"(",
")",
";",
"}",
"}"
] | [
145,
2
] | [
192,
3
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
TelaCliente. | null | o evento abaixo é do tipo "enquanto for digitando" | o evento abaixo é do tipo "enquanto for digitando" | private void txtCliPesquisarKeyReleased(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_txtCliPesquisarKeyReleased
// chamar o método pesquisar clientes
pesquisar_cliente();
} | [
"private",
"void",
"txtCliPesquisarKeyReleased",
"(",
"java",
".",
"awt",
".",
"event",
".",
"KeyEvent",
"evt",
")",
"{",
"//GEN-FIRST:event_txtCliPesquisarKeyReleased",
"// chamar o método pesquisar clientes",
"pesquisar_cliente",
"(",
")",
";",
"}"
] | [
399,
4
] | [
402,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Main. | null | Não precisa alterar nada dessa classe | Não precisa alterar nada dessa classe | @Override
public void start(Stage stage) throws Exception {
new ScenePrincipal().criaScenePrincipal(stage);
} | [
"@",
"Override",
"public",
"void",
"start",
"(",
"Stage",
"stage",
")",
"throws",
"Exception",
"{",
"new",
"ScenePrincipal",
"(",
")",
".",
"criaScenePrincipal",
"(",
"stage",
")",
";",
"}"
] | [
14,
4
] | [
17,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
ClienteService. | null | Metodo para atualizar os campos que serão realizado o update. | Metodo para atualizar os campos que serão realizado o update. | private void updateData (ClienteModel newCliente, ClienteModel cliente){
newCliente.setNome(cliente.getNome());
newCliente.setTelefone(cliente.getTelefone());
newCliente.setCpf(cliente.getCpf());
} | [
"private",
"void",
"updateData",
"(",
"ClienteModel",
"newCliente",
",",
"ClienteModel",
"cliente",
")",
"{",
"newCliente",
".",
"setNome",
"(",
"cliente",
".",
"getNome",
"(",
")",
")",
";",
"newCliente",
".",
"setTelefone",
"(",
"cliente",
".",
"getTelefone",
"(",
")",
")",
";",
"newCliente",
".",
"setCpf",
"(",
"cliente",
".",
"getCpf",
"(",
")",
")",
";",
"}"
] | [
67,
4
] | [
71,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
DirectoresRegionais. | null | Gerente de Loja tem salario variavel conforme cumpre ou nao os objectivos de vendas | Gerente de Loja tem salario variavel conforme cumpre ou nao os objectivos de vendas | public void calcularSalario(){
// 1% do lucro mensal
double percentagemLucro = 0.01 * lucroMensal;
// valor fixo igual ao dobro do dos empregados sem especialização, acrescido
//de um prémio que corresponde a 1% do lucro mensal nas lojas da região.
setSalario(1600 + percentagemLucro);
} | [
"public",
"void",
"calcularSalario",
"(",
")",
"{",
"// 1% do lucro mensal",
"double",
"percentagemLucro",
"=",
"0.01",
"*",
"lucroMensal",
";",
"// valor fixo igual ao dobro do dos empregados sem especialização, acrescido",
"//de um prémio que corresponde a 1% do lucro mensal nas lojas da região.",
"setSalario",
"(",
"1600",
"+",
"percentagemLucro",
")",
";",
"}"
] | [
20,
4
] | [
27,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Main. | null | Obs: Existem jogadores sem clube. | Obs: Existem jogadores sem clube. | public int q2() {
return this.jogadores
.stream()
.filter(j -> !j.getClub().isEmpty()) //O grupo de club vazio conta como +1, logo poderia apenas subtrair 1 no final
.collect(Collectors.groupingBy(Jogador::getClub))
.size();
} | [
"public",
"int",
"q2",
"(",
")",
"{",
"return",
"this",
".",
"jogadores",
".",
"stream",
"(",
")",
".",
"filter",
"(",
"j",
"->",
"!",
"j",
".",
"getClub",
"(",
")",
".",
"isEmpty",
"(",
")",
")",
"//O grupo de club vazio conta como +1, logo poderia apenas subtrair 1 no final",
".",
"collect",
"(",
"Collectors",
".",
"groupingBy",
"(",
"Jogador",
"::",
"getClub",
")",
")",
".",
"size",
"(",
")",
";",
"}"
] | [
26,
1
] | [
32,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
GameBuilder. | null | * metodo para carregar informacoes dos objetos a serem criados ** | * metodo para carregar informacoes dos objetos a serem criados ** | private void loadGame() throws InvalidMapGen {
try {
BufferedReader file = new BufferedReader(new FileReader(this.mapSource));
String line;
String[] lineSplit;
boolean exit = false;
/*** ler a primeira linha ***/
line = file.readLine();
if(line == null) {
file.close();
throw new InvalidMapSize("Tamanho do mapa nao fornecido");
}
lineSplit = line.split(",");
setMapHeight(Integer.parseInt(lineSplit[0]));
setMapWidth(Integer.parseInt(lineSplit[1]));
/*** ler a segunda linha ***/
line = file.readLine();
if(line == null) {
file.close();
throw new InvalidEntrance("Coordenadas de entrada nao fornecidas");
}
lineSplit = line.split(",");
setIEntrance(Integer.parseInt(lineSplit[0]));
setJEntrance(Integer.parseInt(lineSplit[1]));
/*** criar matriz mapa vazia ***/
mapText = new String[this.mapHeight][this.mapWidth];
mapCell = new Cell[this.mapHeight][this.mapWidth];
mapEnemy = new Enemy[this.mapHeight][this.mapWidth];
/*** preencher matriz mapa ***/
for(int i=0; i < this.mapHeight; i++) {
line = file.readLine();
if(line == null) {
file.close();
throw new InvalidMapSize("Altura do mapa invalida");
}
lineSplit = line.split(",");
if(lineSplit.length != this.mapWidth) {
file.close();
throw new InvalidMapSize("Largura do mapa invalida");
}
ICellFactory cellFactory = new CellFactory();
IEnemyFactory enemyFactory = new EnemyFactory();
for(int j=0; j < this.mapWidth; j++) {
String objectID = lineSplit[j];
if(objectID.charAt(0) == 'E') exit = true;
mapText[i][j] = objectID;
mapEnemy[i][j] = enemyFactory.getEnemy(objectID, mapGenerated, i, j);
mapCell[i][j] = cellFactory.getCell(objectID, window, mapGenerated, i, j);
}
}
line = file.readLine();
if(line != null && !line.isEmpty()) {
file.close();
throw new InvalidMapSize("Altura do mapa invalida");
}
if(IEntrance < 0 || IEntrance >= mapWidth || JEntrance < 0 || JEntrance >= mapWidth) {
file.close();
throw new InvalidEntrance("Entrada fora do mapa");
}
if(!mapCell[IEntrance][JEntrance].isWalkableBravia()) {
file.close();
throw new InvalidEntrance("Entrada nao andavel");
}
if(!exit) {
file.close();
throw new InvalidExit("Nao ha saida");
}
file.close();
} catch (IOException error) {
error.printStackTrace();
}
} | [
"private",
"void",
"loadGame",
"(",
")",
"throws",
"InvalidMapGen",
"{",
"try",
"{",
"BufferedReader",
"file",
"=",
"new",
"BufferedReader",
"(",
"new",
"FileReader",
"(",
"this",
".",
"mapSource",
")",
")",
";",
"String",
"line",
";",
"String",
"[",
"]",
"lineSplit",
";",
"boolean",
"exit",
"=",
"false",
";",
"/*** ler a primeira linha ***/",
"line",
"=",
"file",
".",
"readLine",
"(",
")",
";",
"if",
"(",
"line",
"==",
"null",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidMapSize",
"(",
"\"Tamanho do mapa nao fornecido\"",
")",
";",
"}",
"lineSplit",
"=",
"line",
".",
"split",
"(",
"\",\"",
")",
";",
"setMapHeight",
"(",
"Integer",
".",
"parseInt",
"(",
"lineSplit",
"[",
"0",
"]",
")",
")",
";",
"setMapWidth",
"(",
"Integer",
".",
"parseInt",
"(",
"lineSplit",
"[",
"1",
"]",
")",
")",
";",
"/*** ler a segunda linha ***/",
"line",
"=",
"file",
".",
"readLine",
"(",
")",
";",
"if",
"(",
"line",
"==",
"null",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidEntrance",
"(",
"\"Coordenadas de entrada nao fornecidas\"",
")",
";",
"}",
"lineSplit",
"=",
"line",
".",
"split",
"(",
"\",\"",
")",
";",
"setIEntrance",
"(",
"Integer",
".",
"parseInt",
"(",
"lineSplit",
"[",
"0",
"]",
")",
")",
";",
"setJEntrance",
"(",
"Integer",
".",
"parseInt",
"(",
"lineSplit",
"[",
"1",
"]",
")",
")",
";",
"/*** criar matriz mapa vazia ***/",
"mapText",
"=",
"new",
"String",
"[",
"this",
".",
"mapHeight",
"]",
"[",
"this",
".",
"mapWidth",
"]",
";",
"mapCell",
"=",
"new",
"Cell",
"[",
"this",
".",
"mapHeight",
"]",
"[",
"this",
".",
"mapWidth",
"]",
";",
"mapEnemy",
"=",
"new",
"Enemy",
"[",
"this",
".",
"mapHeight",
"]",
"[",
"this",
".",
"mapWidth",
"]",
";",
"/*** preencher matriz mapa ***/",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"this",
".",
"mapHeight",
";",
"i",
"++",
")",
"{",
"line",
"=",
"file",
".",
"readLine",
"(",
")",
";",
"if",
"(",
"line",
"==",
"null",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidMapSize",
"(",
"\"Altura do mapa invalida\"",
")",
";",
"}",
"lineSplit",
"=",
"line",
".",
"split",
"(",
"\",\"",
")",
";",
"if",
"(",
"lineSplit",
".",
"length",
"!=",
"this",
".",
"mapWidth",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidMapSize",
"(",
"\"Largura do mapa invalida\"",
")",
";",
"}",
"ICellFactory",
"cellFactory",
"=",
"new",
"CellFactory",
"(",
")",
";",
"IEnemyFactory",
"enemyFactory",
"=",
"new",
"EnemyFactory",
"(",
")",
";",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"this",
".",
"mapWidth",
";",
"j",
"++",
")",
"{",
"String",
"objectID",
"=",
"lineSplit",
"[",
"j",
"]",
";",
"if",
"(",
"objectID",
".",
"charAt",
"(",
"0",
")",
"==",
"'",
"'",
")",
"exit",
"=",
"true",
";",
"mapText",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"objectID",
";",
"mapEnemy",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"enemyFactory",
".",
"getEnemy",
"(",
"objectID",
",",
"mapGenerated",
",",
"i",
",",
"j",
")",
";",
"mapCell",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"cellFactory",
".",
"getCell",
"(",
"objectID",
",",
"window",
",",
"mapGenerated",
",",
"i",
",",
"j",
")",
";",
"}",
"}",
"line",
"=",
"file",
".",
"readLine",
"(",
")",
";",
"if",
"(",
"line",
"!=",
"null",
"&&",
"!",
"line",
".",
"isEmpty",
"(",
")",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidMapSize",
"(",
"\"Altura do mapa invalida\"",
")",
";",
"}",
"if",
"(",
"IEntrance",
"<",
"0",
"||",
"IEntrance",
">=",
"mapWidth",
"||",
"JEntrance",
"<",
"0",
"||",
"JEntrance",
">=",
"mapWidth",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidEntrance",
"(",
"\"Entrada fora do mapa\"",
")",
";",
"}",
"if",
"(",
"!",
"mapCell",
"[",
"IEntrance",
"]",
"[",
"JEntrance",
"]",
".",
"isWalkableBravia",
"(",
")",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidEntrance",
"(",
"\"Entrada nao andavel\"",
")",
";",
"}",
"if",
"(",
"!",
"exit",
")",
"{",
"file",
".",
"close",
"(",
")",
";",
"throw",
"new",
"InvalidExit",
"(",
"\"Nao ha saida\"",
")",
";",
"}",
"file",
".",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"IOException",
"error",
")",
"{",
"error",
".",
"printStackTrace",
"(",
")",
";",
"}",
"}"
] | [
46,
1
] | [
123,
2
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
CadastroUsuarioController. | null | Este método é para editar o usuário. | Este método é para editar o usuário. | @GetMapping("/editar/{id}")
public String iniciarEdicao(@PathVariable("id") Integer idUsuario, ModelMap model) {
model.addAttribute("usuario", usuarioRepository.findById(idUsuario));
return "usuario/cadastro";
} | [
"@",
"GetMapping",
"(",
"\"/editar/{id}\"",
")",
"public",
"String",
"iniciarEdicao",
"(",
"@",
"PathVariable",
"(",
"\"id\"",
")",
"Integer",
"idUsuario",
",",
"ModelMap",
"model",
")",
"{",
"model",
".",
"addAttribute",
"(",
"\"usuario\"",
",",
"usuarioRepository",
".",
"findById",
"(",
"idUsuario",
")",
")",
";",
"return",
"\"usuario/cadastro\"",
";",
"}"
] | [
94,
2
] | [
98,
3
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
|
Person. | null | Imprime o nome completo seguido de idade | Imprime o nome completo seguido de idade | public String toString(){
return "Nome: " + this.getFirstName() + " " + this.getLastName() + " Idade: " + this.getIdade();
} | [
"public",
"String",
"toString",
"(",
")",
"{",
"return",
"\"Nome: \"",
"+",
"this",
".",
"getFirstName",
"(",
")",
"+",
"\" \"",
"+",
"this",
".",
"getLastName",
"(",
")",
"+",
"\" Idade: \"",
"+",
"this",
".",
"getIdade",
"(",
")",
";",
"}"
] | [
49,
4
] | [
51,
5
] | null | java | pt | ['pt', 'pt', 'pt'] | True | true | method_declaration |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.