file_id
stringlengths 5
9
| repo
stringlengths 8
57
| token_length
int64 59
7.96k
| path
stringlengths 8
105
| content
stringlengths 147
30.2k
| original_comment
stringlengths 14
5.13k
| prompt
stringlengths 82
30.2k
| Included
stringclasses 2
values |
|---|---|---|---|---|---|---|---|
3882_0 | ghik/custom-widget | 427 | src/main/java/com/foo/widget/AwesomeRichTextArea.java | package com.foo.widget;
import static com.foo.widget.client.VAwesomeRichTextArea.SELECTED_TEXT_VARIABLE;
import java.util.Map;
import com.foo.widget.client.VAwesomeRichTextArea;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.ui.ClientWidget;
import com.vaadin.ui.RichTextArea;
@ClientWidget(VAwesomeRichTextArea.class)
public class AwesomeRichTextArea extends RichTextArea {
private static final long serialVersionUID = 1L;
private String selectedText;
public String getSelectedText() {
return selectedText;
}
/**
* Metoda, która odbiera od przeglądarki wiadomość, że po stronie klienta
* coś się zmieniło.
*/
@Override
public void changeVariables(Object source, Map<String, Object> variables) {
super.changeVariables(source, variables);
if (variables.containsKey(SELECTED_TEXT_VARIABLE)) {
selectedText = (String) variables.get(SELECTED_TEXT_VARIABLE);
}
}
/**
* Metoda, która wysyła do przeglądarki informacje o zmianach po stronie
* serwera.
*/
@Override
public void paintContent(PaintTarget target) throws PaintException {
super.paintContent(target);
// serwer nie wysyła na razie nic nowego, więc nie trzeba tu nic dodawać
}
}
| /**
* Metoda, która odbiera od przeglądarki wiadomość, że po stronie klienta
* coś się zmieniło.
*/ | package com.foo.widget;
import static com.foo.widget.client.VAwesomeRichTextArea.SELECTED_TEXT_VARIABLE;
import java.util.Map;
import com.foo.widget.client.VAwesomeRichTextArea;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.ui.ClientWidget;
import com.vaadin.ui.RichTextArea;
@ClientWidget(VAwesomeRichTextArea.class)
public class AwesomeRichTextArea extends RichTextArea {
private static final long serialVersionUID = 1L;
private String selectedText;
public String getSelectedText() {
return selectedText;
}
/**
* Metoda, która odbiera <SUF>*/
@Override
public void changeVariables(Object source, Map<String, Object> variables) {
super.changeVariables(source, variables);
if (variables.containsKey(SELECTED_TEXT_VARIABLE)) {
selectedText = (String) variables.get(SELECTED_TEXT_VARIABLE);
}
}
/**
* Metoda, która wysyła do przeglądarki informacje o zmianach po stronie
* serwera.
*/
@Override
public void paintContent(PaintTarget target) throws PaintException {
super.paintContent(target);
// serwer nie wysyła na razie nic nowego, więc nie trzeba tu nic dodawać
}
}
| t |
8336_12 | golabkowy/core-java-sandbox | 709 | src/main/java/threads/Threads.java | package threads;
public class Threads {
private static void threadFlow(String threadName) throws InterruptedException {
while (true) {
System.out.println(threadName);
// of course its better to wait for notification than sleep until some condition is fulfilled
// for education purposes only ;)
Thread.sleep(2000L);
}
}
public static void main(String[] args) {
// Things to implement
// co to volatile
// barer
// ThreadPool
// Executors
// metody run i start
// metoda signal()
// sleepy i czekania az sie skonczy
// sleepy są też przeladowane do przyjmowania nanosekund jednak tak naprawdę czas sleepa zależy od tego jak system ubsługuje pod spodem
// czas sleepa() może się różnić na różnych systemach
// sleep po interrupcie wątku będzie rzucał InterruptedException
// join - metoda sluży do czekania danego wątku aż inny zakończy swoje działanie
// synchronizacja wątków
// simple implementation of runnable
Runnable runnable_thread = new Runnable() {
@Override
public void run() {
try {
threadFlow("new Runnable works!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//bez start() nie startujemy nowego wątku tylko się odpala ten runnable
// runnable_thread.run();
// dlatego powinniśmy owrapować ten runnable w thread
// Thread thread = new Thread(runnable_thread);
// i dopiero odpalić
// thread.start();
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
threadFlow("new Thread(new Runnable works!)");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread lambdaThread = new Thread(() -> {
try {
threadFlow("LAMBDA Thread");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
// co ciekawe jako, że Runnable stał się interfejsem funkcyjnym to można teraz użyć lambdy aby zaimplementowac metodę defaultową run() z tego właśnie interfejsu funkcyjnego
lambdaThread.start();
thread.start();
// Main Program thread
try {
threadFlow("MAIN THREAD WORKS");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
| // dlatego powinniśmy owrapować ten runnable w thread | package threads;
public class Threads {
private static void threadFlow(String threadName) throws InterruptedException {
while (true) {
System.out.println(threadName);
// of course its better to wait for notification than sleep until some condition is fulfilled
// for education purposes only ;)
Thread.sleep(2000L);
}
}
public static void main(String[] args) {
// Things to implement
// co to volatile
// barer
// ThreadPool
// Executors
// metody run i start
// metoda signal()
// sleepy i czekania az sie skonczy
// sleepy są też przeladowane do przyjmowania nanosekund jednak tak naprawdę czas sleepa zależy od tego jak system ubsługuje pod spodem
// czas sleepa() może się różnić na różnych systemach
// sleep po interrupcie wątku będzie rzucał InterruptedException
// join - metoda sluży do czekania danego wątku aż inny zakończy swoje działanie
// synchronizacja wątków
// simple implementation of runnable
Runnable runnable_thread = new Runnable() {
@Override
public void run() {
try {
threadFlow("new Runnable works!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//bez start() nie startujemy nowego wątku tylko się odpala ten runnable
// runnable_thread.run();
// dlatego powinniśmy <SUF>
// Thread thread = new Thread(runnable_thread);
// i dopiero odpalić
// thread.start();
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
threadFlow("new Thread(new Runnable works!)");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread lambdaThread = new Thread(() -> {
try {
threadFlow("LAMBDA Thread");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
// co ciekawe jako, że Runnable stał się interfejsem funkcyjnym to można teraz użyć lambdy aby zaimplementowac metodę defaultową run() z tego właśnie interfejsu funkcyjnego
lambdaThread.start();
thread.start();
// Main Program thread
try {
threadFlow("MAIN THREAD WORKS");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
| t |
7109_30 | gotoco/AlgorithmsChallanges | 3,138 | java/src/graphs/Graph.java | package graph;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
/**
* Author: Maciej Grochowski
* Contact: mgrochowski@ubirds.eu
* Date: 11/8/13
* Time: 3:28 PM
* <p/>
* This code is a uBirds company property.
*/
/**
* @param <V> vertex class
* @param <E> edge class
*/
public class Graph <V, E> {
public Graph(int n){
g = new ArrayList<Ve>();
for(int i=0; i<n; i++) {
g.add(new Ve());
}
}
//Wektor wierzchołków w grafie
private List<Ve> g;
/**
* Funkcja dodająca do grafu nową krawędź nieskierowaną, łączącą wierzchołki b i e oraz zawierająca dodatkowe
* informację przekazywane przez zmienną d.
* Krawędź nieskierowana jest reprezentowana przez dwie krawędzie skierowane - jedną prowadzącą z wierzchołka b do e
* oraz drugą z e do b.
* @param b
* @param e
* @param d
*/
public void EdgeU(int b, int e, E d){
//System.out.println("@Debug: tworze krawedz b, e: " + b + " " + e);
Ed eg = new Ed(d, e);
int be = 0;
if(b == e) be = 1;
eg.setRev(g.get(e).getEdVector().size()+be);
Ve newVe = g.get(b);
List<Ed> newListEd = newVe.getEdVector();
newListEd.add(eg);
newVe.setVector(newListEd);
g.set(b, newVe);
Ed eg2 = new Ed(d, b);
eg2.setRev(g.get(b).getEdVector().size()-1);
newVe = g.get(e);
newListEd = newVe.getEdVector();
newListEd.add(eg2);
newVe.setVector(newListEd);
g.set(e, newVe);
}
/**
* Funkcja dodająca do grafu nową krawędź skierowaną z wierzchołka b do e,
* zawierającą dodatkowe informacje określone przez zmienną d.
*/
public void EdgeD(int b, int e, E d) {
Ve test = g.get(b);
test.getEdVector().add(new Ed(d, e));
}
public void write(){
for(int x=0; x<g.size(); x++){
System.out.print(x+ ": ") ;
List<Ed> edgesFromX = g.get(x).getEdVector();
for(Ed ed : edgesFromX){
System.out.print(ed.getV() + " ") ;
}
System.out.println(" ");
}
}
public void bfs(int s) {
// Dla kazdego wierzcholka w grafie ustawiana jest poczatkowa wartosc zmiennych
// t oraz s na -1. zrodlo wyszukiwania ma czas rowny 0
for(Ve vertex : g){
vertex.setS(-1);
vertex.setT(-1);
}
Ve vs = g.get(s);
vs.setT(0);
g.set(s, vs);
// Algorytm BFS jest realizowany przy uzyciu kolejki FIFO, do ktorej wstawiane
// sa kolejne wierzcholki oczekujace na przetworzenie
int qu[] = new int[g.size()];
int b = 0, e = 0;
// Do kolejki wstawione zostaje zrodlo
qu[0] = s;
// Dopoki w kolejce sa jakies wierzcholki...
while(b<=e) {
s=qu[b++];
// Dla kazdej krawedzi wychodzacej z aktualnie przetwarzanego wierzcholka,
// jesli wierzcholek, do ktorego ona prowadzi, nie byl jeszcze wstawiony do
// kolejki, wstaw go i wyznacz wartosci zmiennych int t i int s
for(Ed edgesFromGs : g.get(s).getEdVector()){
if(g.get(edgesFromGs.getV()).getT() == -1){
qu[++e]=edgesFromGs.getV();
Ve clipboard = g.get(qu[e]);
clipboard.setT(g.get(s).getT()+1);
clipboard.setS(s);
g.set(qu[e], clipboard);
}
}
}
}
public void writeBfs(){
//Wypisz wynik bfs
int index = 0;
for(Ve vertex : g){
System.out.print("Wierzcholek " + index + " : czas = " + vertex.getT() + " , ojciec w drzewie BFS = " + vertex.getS());
System.out.println(" ");
index++;
}
}
/**
* Przeszukiwanie grafu w głąb:
* Aktualizuje dany graf o czas wejścia czas wyjścia i numer ojca w lesie dsf
*
* @param e numer wierzchołka od którego rozpoczynamy algorytm dsf
*/
public void dsf(Integer e){
List<Integer> st = new ArrayList<Integer>(g.size());
for(int i=0; i<g.size(); i++){
st.add(0);
}
int t = -1 , i = 0, b = 0;
if(e == null || e < 0){
e = g.size() - 1;
} else {
b = e;
}
for(Ve ve : g){
ve.d = ve.f = ve.s = -1;
}
// Dla wszystkich wierzcholkow z przedzialu [b..e], jesli wierzcholek nie byl
// jeszcze odwiedzony...
for(int s = b; s <= (e); ++s){
// Wstaw wierzcholek na stos i ustaw dla niego odpowiedni czas wejscia.
// Zmienna f wierzcholka sluzy tymczasowo jako licznik nieprzetworzonych
// krawedzi wychodzacych z wierzcholka
//System.out.print("##s = " + s + " i = " + i + " g.size() = " + g.size() + " st.size() = " + st.size());
st.set(i++, s);
g.get(s).d = ++t;
g.get(s).f = g.get(s).getEdVector().size();
// Dopoki stos jest niepusty...
while(i > 0){
System.out.print( "##st print size=" + st.size() );
// for (Integer item : st)
// System.out.print("##item st = " + item);
System.out.println("##i = " + i);
int ss = st.get(i-1);
// Przetworz kolejna krawedz wychodzaca z biezacego wierzcholka lub usun go
// ze stosu (gdy nie ma juz wiecej krawedzi)
if (g.get(ss).f == 0){
g.get(ss).f = ++t;
--i;
} else {
// Jesli wierzcholek, do ktorego prowadzi krawedz, nie byl jeszcze odwiedzony, to...
//g[s = g[s][--g[s].f].v].d
System.out.println("## ss= " + ss);
int newS = g.get(ss).getEdVector().get(g.get(ss).f - 1).getV();
--g.get(ss).f;
ss = newS;
if (g.get(ss).d == -1) {
// Ustaw numer wierzcholka-ojca w drzewie DFS oraz ustaw liczbe nieprzetworzonych
// krawedzi wychodzacych z wierzcholka
g.get(ss).s = st.get(i-1); //nowy stary :) w sensie ze nowy ojciec w dfs
g.get(ss).f = g.get(ss).getEdVector().size(); //nowa zmienna wyjścia z węzła która okresla ile trzeba nodów przerobic
// Wstaw wierzcholek na stos i ustaw czas wejscia
g.get(ss).d = t;
t++;
st.set(i, ss);
i++;
}
}
}
}
}
public void writeDsf(){
int i = 0;
for(Ve ve : g){
System.out.println("Wierzcholek " + i++ +": czas wejscia = "
+ ve.d + ", czas wyjscia = " + ve.f +", ojciec w lesie DFS = " + ve.s);
}
}
}
/**
* Klasa reprezentująca krawędź wychodzącą z danego wierzchołka.
*/
class Ed {
public Ed(Object E, int w){
e = E;
v = w;
}
private Object e;
private Integer v;
private Integer rev;
Object getE() {
return e;
}
void setE(Object e) {
this.e = e;
}
/**
* @return wierzchołek do którego prowadzi dana krawędź
*/
Integer getV() {
return v;
}
void setV(Integer v) {
this.v = v;
}
Integer getRev() {
return rev;
}
void setRev(Integer rev) {
this.rev = rev;
}
}
/**
* Klasa reprezentująca wierzchołki w grafie.
* Wierzchołek skłąda się z numeru i krawędzi do których można się z niego dostać.
*/
class Ve {
public Ve(){
vector = new ArrayList<Ed>();
}
private Object v;
private List<Ed> vector;
public int s;
private int t;
public int d;
public int f;
Object getV() {
return v;
}
void setV(Object v) {
this.v = v;
}
List<Ed> getEdVector() {
return vector;
}
void setVector(List<Ed> vector) {
this.vector = vector;
}
/**
* @return ojciec w drzewie przeszukiwania
*/
int getS() {
return s;
}
void setS(int s) {
this.s = s;
}
/**
* @return odległość od wierzchołka przeszukiwania.
*/
int getT() {
return t;
}
void setT(int t) {
this.t = t;
}
int getD() {
return d;
}
void setD(int d) {
this.d = d;
}
}
| // krawedzi wychodzacych z wierzcholka | package graph;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
/**
* Author: Maciej Grochowski
* Contact: mgrochowski@ubirds.eu
* Date: 11/8/13
* Time: 3:28 PM
* <p/>
* This code is a uBirds company property.
*/
/**
* @param <V> vertex class
* @param <E> edge class
*/
public class Graph <V, E> {
public Graph(int n){
g = new ArrayList<Ve>();
for(int i=0; i<n; i++) {
g.add(new Ve());
}
}
//Wektor wierzchołków w grafie
private List<Ve> g;
/**
* Funkcja dodająca do grafu nową krawędź nieskierowaną, łączącą wierzchołki b i e oraz zawierająca dodatkowe
* informację przekazywane przez zmienną d.
* Krawędź nieskierowana jest reprezentowana przez dwie krawędzie skierowane - jedną prowadzącą z wierzchołka b do e
* oraz drugą z e do b.
* @param b
* @param e
* @param d
*/
public void EdgeU(int b, int e, E d){
//System.out.println("@Debug: tworze krawedz b, e: " + b + " " + e);
Ed eg = new Ed(d, e);
int be = 0;
if(b == e) be = 1;
eg.setRev(g.get(e).getEdVector().size()+be);
Ve newVe = g.get(b);
List<Ed> newListEd = newVe.getEdVector();
newListEd.add(eg);
newVe.setVector(newListEd);
g.set(b, newVe);
Ed eg2 = new Ed(d, b);
eg2.setRev(g.get(b).getEdVector().size()-1);
newVe = g.get(e);
newListEd = newVe.getEdVector();
newListEd.add(eg2);
newVe.setVector(newListEd);
g.set(e, newVe);
}
/**
* Funkcja dodająca do grafu nową krawędź skierowaną z wierzchołka b do e,
* zawierającą dodatkowe informacje określone przez zmienną d.
*/
public void EdgeD(int b, int e, E d) {
Ve test = g.get(b);
test.getEdVector().add(new Ed(d, e));
}
public void write(){
for(int x=0; x<g.size(); x++){
System.out.print(x+ ": ") ;
List<Ed> edgesFromX = g.get(x).getEdVector();
for(Ed ed : edgesFromX){
System.out.print(ed.getV() + " ") ;
}
System.out.println(" ");
}
}
public void bfs(int s) {
// Dla kazdego wierzcholka w grafie ustawiana jest poczatkowa wartosc zmiennych
// t oraz s na -1. zrodlo wyszukiwania ma czas rowny 0
for(Ve vertex : g){
vertex.setS(-1);
vertex.setT(-1);
}
Ve vs = g.get(s);
vs.setT(0);
g.set(s, vs);
// Algorytm BFS jest realizowany przy uzyciu kolejki FIFO, do ktorej wstawiane
// sa kolejne wierzcholki oczekujace na przetworzenie
int qu[] = new int[g.size()];
int b = 0, e = 0;
// Do kolejki wstawione zostaje zrodlo
qu[0] = s;
// Dopoki w kolejce sa jakies wierzcholki...
while(b<=e) {
s=qu[b++];
// Dla kazdej krawedzi wychodzacej z aktualnie przetwarzanego wierzcholka,
// jesli wierzcholek, do ktorego ona prowadzi, nie byl jeszcze wstawiony do
// kolejki, wstaw go i wyznacz wartosci zmiennych int t i int s
for(Ed edgesFromGs : g.get(s).getEdVector()){
if(g.get(edgesFromGs.getV()).getT() == -1){
qu[++e]=edgesFromGs.getV();
Ve clipboard = g.get(qu[e]);
clipboard.setT(g.get(s).getT()+1);
clipboard.setS(s);
g.set(qu[e], clipboard);
}
}
}
}
public void writeBfs(){
//Wypisz wynik bfs
int index = 0;
for(Ve vertex : g){
System.out.print("Wierzcholek " + index + " : czas = " + vertex.getT() + " , ojciec w drzewie BFS = " + vertex.getS());
System.out.println(" ");
index++;
}
}
/**
* Przeszukiwanie grafu w głąb:
* Aktualizuje dany graf o czas wejścia czas wyjścia i numer ojca w lesie dsf
*
* @param e numer wierzchołka od którego rozpoczynamy algorytm dsf
*/
public void dsf(Integer e){
List<Integer> st = new ArrayList<Integer>(g.size());
for(int i=0; i<g.size(); i++){
st.add(0);
}
int t = -1 , i = 0, b = 0;
if(e == null || e < 0){
e = g.size() - 1;
} else {
b = e;
}
for(Ve ve : g){
ve.d = ve.f = ve.s = -1;
}
// Dla wszystkich wierzcholkow z przedzialu [b..e], jesli wierzcholek nie byl
// jeszcze odwiedzony...
for(int s = b; s <= (e); ++s){
// Wstaw wierzcholek na stos i ustaw dla niego odpowiedni czas wejscia.
// Zmienna f wierzcholka sluzy tymczasowo jako licznik nieprzetworzonych
// krawedzi wychodzacych z wierzcholka
//System.out.print("##s = " + s + " i = " + i + " g.size() = " + g.size() + " st.size() = " + st.size());
st.set(i++, s);
g.get(s).d = ++t;
g.get(s).f = g.get(s).getEdVector().size();
// Dopoki stos jest niepusty...
while(i > 0){
System.out.print( "##st print size=" + st.size() );
// for (Integer item : st)
// System.out.print("##item st = " + item);
System.out.println("##i = " + i);
int ss = st.get(i-1);
// Przetworz kolejna krawedz wychodzaca z biezacego wierzcholka lub usun go
// ze stosu (gdy nie ma juz wiecej krawedzi)
if (g.get(ss).f == 0){
g.get(ss).f = ++t;
--i;
} else {
// Jesli wierzcholek, do ktorego prowadzi krawedz, nie byl jeszcze odwiedzony, to...
//g[s = g[s][--g[s].f].v].d
System.out.println("## ss= " + ss);
int newS = g.get(ss).getEdVector().get(g.get(ss).f - 1).getV();
--g.get(ss).f;
ss = newS;
if (g.get(ss).d == -1) {
// Ustaw numer wierzcholka-ojca w drzewie DFS oraz ustaw liczbe nieprzetworzonych
// krawedzi wychodzacych <SUF>
g.get(ss).s = st.get(i-1); //nowy stary :) w sensie ze nowy ojciec w dfs
g.get(ss).f = g.get(ss).getEdVector().size(); //nowa zmienna wyjścia z węzła która okresla ile trzeba nodów przerobic
// Wstaw wierzcholek na stos i ustaw czas wejscia
g.get(ss).d = t;
t++;
st.set(i, ss);
i++;
}
}
}
}
}
public void writeDsf(){
int i = 0;
for(Ve ve : g){
System.out.println("Wierzcholek " + i++ +": czas wejscia = "
+ ve.d + ", czas wyjscia = " + ve.f +", ojciec w lesie DFS = " + ve.s);
}
}
}
/**
* Klasa reprezentująca krawędź wychodzącą z danego wierzchołka.
*/
class Ed {
public Ed(Object E, int w){
e = E;
v = w;
}
private Object e;
private Integer v;
private Integer rev;
Object getE() {
return e;
}
void setE(Object e) {
this.e = e;
}
/**
* @return wierzchołek do którego prowadzi dana krawędź
*/
Integer getV() {
return v;
}
void setV(Integer v) {
this.v = v;
}
Integer getRev() {
return rev;
}
void setRev(Integer rev) {
this.rev = rev;
}
}
/**
* Klasa reprezentująca wierzchołki w grafie.
* Wierzchołek skłąda się z numeru i krawędzi do których można się z niego dostać.
*/
class Ve {
public Ve(){
vector = new ArrayList<Ed>();
}
private Object v;
private List<Ed> vector;
public int s;
private int t;
public int d;
public int f;
Object getV() {
return v;
}
void setV(Object v) {
this.v = v;
}
List<Ed> getEdVector() {
return vector;
}
void setVector(List<Ed> vector) {
this.vector = vector;
}
/**
* @return ojciec w drzewie przeszukiwania
*/
int getS() {
return s;
}
void setS(int s) {
this.s = s;
}
/**
* @return odległość od wierzchołka przeszukiwania.
*/
int getT() {
return t;
}
void setT(int t) {
this.t = t;
}
int getD() {
return d;
}
void setD(int d) {
this.d = d;
}
}
| t |
9821_2 | grzegorz2047/OpenGuild | 1,198 | src/main/java/pl/grzegorz2047/openguild/hardcore/HardcoreSQLHandler.java | /*
* Copyright 2014
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package pl.grzegorz2047.openguild.hardcore;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.UUID;
import org.bukkit.Bukkit;
import pl.grzegorz2047.openguild.OpenGuild;
import pl.grzegorz2047.openguild.database.SQLHandler;
/**
* @author Grzegorz
*/
public final class HardcoreSQLHandler {
private final SQLHandler sqlHandler;
/* Można zrobić API do dostania się na polaczenie openguilda */
public enum Column {
BAN_TIME,
UUID,
NICK
}
public HardcoreSQLHandler(SQLHandler sqlHandler) {
this.sqlHandler = sqlHandler;
}
private final String TABLENAME = "openguild_bans";
public boolean createTables() {
String query = "CREATE TABLE IF NOT EXISTS `" + TABLENAME + "` (UUID VARCHAR(36) NOT NULL primary key, NICK VARCHAR(16) NOT NULL, BAN_TIME BIGINT NOT NULL)";
OpenGuild.getOGLogger().debug(query);
return sqlHandler.execute(query);
}
public void update(UUID uniqueId, Column column, String value) {
try {
Statement st = sqlHandler.getConnection().createStatement();
String query;
if (playerExists(uniqueId)) {
query = "UPDATE `" + TABLENAME + "` SET " + column.toString() + "='" + value + "' WHERE " + Column.UUID.toString() + "='" + uniqueId + "'";
} else {
query = "INSERT INTO `" + TABLENAME + "` VALUES('" + uniqueId + "', '" + Bukkit.getOfflinePlayer(uniqueId).getName() + "', '" + value + "')";
}
st.execute(query);
st.close();
st.getConnection().close();
} catch (Exception ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
}
}
public long getBan(UUID uniqueId) {
if (playerExists(uniqueId)) {
String query = "SELECT " + Column.BAN_TIME.toString() + " FROM " + TABLENAME + " WHERE " + Column.UUID.toString() + "='" + uniqueId + "'";
try {
Statement st = sqlHandler.getConnection().createStatement();
ResultSet rs = st.executeQuery(query);
rs.next();
long ban_time = (long) rs.getDouble("BAN_TIME");
rs.close();
st.close();
st.getConnection().close();
return ban_time;
} catch (Exception ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
return 0;
}
}
return 0;
}
private boolean playerExists(UUID uniqueId) {
String query = "SELECT COUNT(" + Column.UUID + ") FROM " + TABLENAME + " WHERE " + Column.UUID.toString() + "='" + uniqueId + "'";
ResultSet rs = sqlHandler.executeQuery(query);
int rowCount = -1;
try {
// get the number of rows from the result set
rs.next();
rowCount = rs.getInt(1);
} catch (SQLException ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
} finally {
try {
rs.close();
rs.getStatement().close();
rs.getStatement().getConnection().close();
} catch (SQLException ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
}
}
OpenGuild.getOGLogger().debug("Counting player " + Bukkit.getOfflinePlayer(uniqueId).getName() + " with UUID " + uniqueId + " returns " + rowCount);
return rowCount != 0 && rowCount != -1;
}
}
| /* Można zrobić API do dostania się na polaczenie openguilda */ | /*
* Copyright 2014
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package pl.grzegorz2047.openguild.hardcore;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.UUID;
import org.bukkit.Bukkit;
import pl.grzegorz2047.openguild.OpenGuild;
import pl.grzegorz2047.openguild.database.SQLHandler;
/**
* @author Grzegorz
*/
public final class HardcoreSQLHandler {
private final SQLHandler sqlHandler;
/* Można zrobić API <SUF>*/
public enum Column {
BAN_TIME,
UUID,
NICK
}
public HardcoreSQLHandler(SQLHandler sqlHandler) {
this.sqlHandler = sqlHandler;
}
private final String TABLENAME = "openguild_bans";
public boolean createTables() {
String query = "CREATE TABLE IF NOT EXISTS `" + TABLENAME + "` (UUID VARCHAR(36) NOT NULL primary key, NICK VARCHAR(16) NOT NULL, BAN_TIME BIGINT NOT NULL)";
OpenGuild.getOGLogger().debug(query);
return sqlHandler.execute(query);
}
public void update(UUID uniqueId, Column column, String value) {
try {
Statement st = sqlHandler.getConnection().createStatement();
String query;
if (playerExists(uniqueId)) {
query = "UPDATE `" + TABLENAME + "` SET " + column.toString() + "='" + value + "' WHERE " + Column.UUID.toString() + "='" + uniqueId + "'";
} else {
query = "INSERT INTO `" + TABLENAME + "` VALUES('" + uniqueId + "', '" + Bukkit.getOfflinePlayer(uniqueId).getName() + "', '" + value + "')";
}
st.execute(query);
st.close();
st.getConnection().close();
} catch (Exception ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
}
}
public long getBan(UUID uniqueId) {
if (playerExists(uniqueId)) {
String query = "SELECT " + Column.BAN_TIME.toString() + " FROM " + TABLENAME + " WHERE " + Column.UUID.toString() + "='" + uniqueId + "'";
try {
Statement st = sqlHandler.getConnection().createStatement();
ResultSet rs = st.executeQuery(query);
rs.next();
long ban_time = (long) rs.getDouble("BAN_TIME");
rs.close();
st.close();
st.getConnection().close();
return ban_time;
} catch (Exception ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
return 0;
}
}
return 0;
}
private boolean playerExists(UUID uniqueId) {
String query = "SELECT COUNT(" + Column.UUID + ") FROM " + TABLENAME + " WHERE " + Column.UUID.toString() + "='" + uniqueId + "'";
ResultSet rs = sqlHandler.executeQuery(query);
int rowCount = -1;
try {
// get the number of rows from the result set
rs.next();
rowCount = rs.getInt(1);
} catch (SQLException ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
} finally {
try {
rs.close();
rs.getStatement().close();
rs.getStatement().getConnection().close();
} catch (SQLException ex) {
OpenGuild.getOGLogger().exceptionThrown(ex);
}
}
OpenGuild.getOGLogger().debug("Counting player " + Bukkit.getOfflinePlayer(uniqueId).getName() + " with UUID " + uniqueId + " returns " + rowCount);
return rowCount != 0 && rowCount != -1;
}
}
| t |
8369_0 | grzegorzcyran/Generali-SDA | 110 | src/edu/grcy/solid/isp/fix/ReadableLogger.java | package edu.grcy.solid.isp.fix;
import java.util.Collection;
//@FunctionalInterface
public interface ReadableLogger extends Logger {
Collection<String> readMessages();
/**
* Readable logger rozszerza Logger więc ma tak naprawdę
* dwie metody abstrakcyjne i nie może być
* oznaczony anotacją FunctionalInterface
*/
}
| /**
* Readable logger rozszerza Logger więc ma tak naprawdę
* dwie metody abstrakcyjne i nie może być
* oznaczony anotacją FunctionalInterface
*/ | package edu.grcy.solid.isp.fix;
import java.util.Collection;
//@FunctionalInterface
public interface ReadableLogger extends Logger {
Collection<String> readMessages();
/**
* Readable logger rozszerza <SUF>*/
}
| t |
9349_4 | grzegorzcyran/JavaBasics | 655 | src/edu/gc/basics/Person.java | package edu.gc.basics;
/**
* Klasy i obiekty w Javie
* Klasa to szablon, wzór, schemat, z którego tworzymy obiekty.
* Obiekt to instancja klasy czyli zbiór danych powiązanych.
*
*/
public class Person {
private String name;
protected String surname;
public int age;
String gender; // domyślnie jest pakietową, czyli dostępną tylko w pakiecie
// konstruktor domyślny - jeśli nie ma żadnego konstruktora, to kompilator automatycznie go dodaje
//czasami jest wymagane dodanie go nawet jeśli są inne konstruktory bo wymaga tego jakaś biblioteka
public Person() {
System.out.println("Konstruktor domyślny");
this.name = "Unknown";
this.surname = "Unknown";
this.age = 0;
this.gender = "Unknown";
}
//konstruktor to specjalna metoda, która ma taką samą nazwę jak klasa, nie ma typu zwracanego, może mieć argumenty
//konstruktor jest wywoływany w momencie tworzenia obiektu
public Person(String name, String surname, int age, String gender) {
System.out.println("Konstruktor z argumentami");
//this to słowo kluczowe, które oznacza obiekt, na którym wywołujemy metodę
//czyli this.name oznacza pole name obiektu, na którym wywołujemy metodę
//a name to argument metody, itd z kolejnymi polami i argumentami
this.name = name;
this.surname = surname;
this.age = age;
this.gender = gender;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public String getSurname() {
return surname;
}
public void setSurname(String surname) {
this.surname = surname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
| //konstruktor to specjalna metoda, która ma taką samą nazwę jak klasa, nie ma typu zwracanego, może mieć argumenty | package edu.gc.basics;
/**
* Klasy i obiekty w Javie
* Klasa to szablon, wzór, schemat, z którego tworzymy obiekty.
* Obiekt to instancja klasy czyli zbiór danych powiązanych.
*
*/
public class Person {
private String name;
protected String surname;
public int age;
String gender; // domyślnie jest pakietową, czyli dostępną tylko w pakiecie
// konstruktor domyślny - jeśli nie ma żadnego konstruktora, to kompilator automatycznie go dodaje
//czasami jest wymagane dodanie go nawet jeśli są inne konstruktory bo wymaga tego jakaś biblioteka
public Person() {
System.out.println("Konstruktor domyślny");
this.name = "Unknown";
this.surname = "Unknown";
this.age = 0;
this.gender = "Unknown";
}
//konstruktor to <SUF>
//konstruktor jest wywoływany w momencie tworzenia obiektu
public Person(String name, String surname, int age, String gender) {
System.out.println("Konstruktor z argumentami");
//this to słowo kluczowe, które oznacza obiekt, na którym wywołujemy metodę
//czyli this.name oznacza pole name obiektu, na którym wywołujemy metodę
//a name to argument metody, itd z kolejnymi polami i argumentami
this.name = name;
this.surname = surname;
this.age = age;
this.gender = gender;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public String getSurname() {
return surname;
}
public void setSurname(String surname) {
this.surname = surname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
| t |
205_7 | gynvael/zrozumiec-programowanie | 678 | 013-Czesc_III-Rozdzial_8-Watki/PoolTest.java | import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
class PoolTest {
public static void main(String args[]) {
// Stworzenie nowej puli wątków.
ExecutorService pool = Executors.newFixedThreadPool(4);
// Zadanie 100 zadań puli. Tylko 4 zadania na raz będą aktywne. Metoda
// submit zwraca obiekt implementujący interfejs Future, który można
// odpytać czy dane zadanie zostało już wykonane.
// Alternatywnie możnaby użyć prostszej metody execute.
Future[] tasks = new Future[80];
for (int i = 0; i < 80; i++) {
tasks[i] = pool.submit(new MyThread(i));
}
// Zamknij przyjmowanie nowy zadań do puli i usuń pulę po zakończeniu
// wszystkich zadań.
pool.shutdown();
// Odpytaj po kolej każde zadanie czy już się zakończyło, aż wszystkie
// się nie zakończą.
while (!pool.isTerminated()) {
// Sprawdz i wyswietl stan wszystkich zadań.
String s = "";
for (int i = 0; i < 80; i++) {
s += tasks[i].isDone() ? "D" : ".";
}
System.out.println(s);
// Poczekaj 50ms przed kontynuowaniem.
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// W tym programie żaden wątek nie przerywa innego, więc to się
// nigdy nie wykona.
}
}
System.out.println("All done!");
}
}
class MyThread implements Runnable{
private int data;
MyThread(int data) {
this.data = data;
}
public void run() {
try {
// Poczekaj pewną ilość czasu przed zakończeniem zadania.
Thread.sleep(25 * (this.data % 7));
} catch (InterruptedException e) {
// W tym programie żaden wątek nie przerywa innego, więc to się
// nigdy nie wykona.
}
}
}
| // się nie zakończą.
| import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
class PoolTest {
public static void main(String args[]) {
// Stworzenie nowej puli wątków.
ExecutorService pool = Executors.newFixedThreadPool(4);
// Zadanie 100 zadań puli. Tylko 4 zadania na raz będą aktywne. Metoda
// submit zwraca obiekt implementujący interfejs Future, który można
// odpytać czy dane zadanie zostało już wykonane.
// Alternatywnie możnaby użyć prostszej metody execute.
Future[] tasks = new Future[80];
for (int i = 0; i < 80; i++) {
tasks[i] = pool.submit(new MyThread(i));
}
// Zamknij przyjmowanie nowy zadań do puli i usuń pulę po zakończeniu
// wszystkich zadań.
pool.shutdown();
// Odpytaj po kolej każde zadanie czy już się zakończyło, aż wszystkie
// się nie <SUF>
while (!pool.isTerminated()) {
// Sprawdz i wyswietl stan wszystkich zadań.
String s = "";
for (int i = 0; i < 80; i++) {
s += tasks[i].isDone() ? "D" : ".";
}
System.out.println(s);
// Poczekaj 50ms przed kontynuowaniem.
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// W tym programie żaden wątek nie przerywa innego, więc to się
// nigdy nie wykona.
}
}
System.out.println("All done!");
}
}
class MyThread implements Runnable{
private int data;
MyThread(int data) {
this.data = data;
}
public void run() {
try {
// Poczekaj pewną ilość czasu przed zakończeniem zadania.
Thread.sleep(25 * (this.data % 7));
} catch (InterruptedException e) {
// W tym programie żaden wątek nie przerywa innego, więc to się
// nigdy nie wykona.
}
}
}
| t |
4017_6 | gynvael/zrozumiec-programowanie-cwiczenia | 1,142 | SYNC-make-all-mistakes/artur-augustyniak/ProgSumTest.java | import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class ProgSumTest {
private static final int N_TH = 9;
private static final int CYCLES = 200;
private static final int ROUNDS = 500;
/**
* czesto mozna sie spotkac z twierdzeniem ze volatile
* pomoze, w Javie w przypadku int zapis do takiej zmiennej
* powinien byc atomowy ale to juz implementation dep.
* postinkrementacja to:
* read
* increment
* assign
*/
private volatile int value = 0;
/**
* synchronized bo o ile dobrze pamietam
* w Javie synchronizacja jest tez bariera pamieci
*/
public synchronized void reset() {
this.value = 0;
}
/**
* zwraca unikalna wartosc?
*/
public synchronized int getNextSync() {
return value++;
}
/**
* zwraca unikalna wartosc?
*/
public int getNext() {
return value++;
}
private void runTest(int expectedRes, boolean useLock) {
/**
* w 'tescie' uzywam atomica zeby wyeliminowac
* bledy pochodzace z samego testu
*/
final AtomicInteger actual = new AtomicInteger(0);
final ExecutorService exec = Executors.newFixedThreadPool(N_TH);
for (int i = 0; i < N_TH; i++) {
Runnable task = new Runnable() {
@Override
public void run() {
for (int j = 0; j < CYCLES; j++) {
/**
* Niestety overlading albo obecnosc w metodzie
* warunkowo wrzuconego bloku synchronized prowadzi do
* poprawnej(niejszej?) synchronizacji
* openjdk version "1.8.0_151"
* OpenJDK Runtime Environment (build 1.8.0_151-b12)
* OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)
*/
int n;
if (useLock) {
n = getNextSync();
} else {
n = getNext();
}
Thread.yield();
actual.addAndGet(n);
}
}
};
exec.execute(task);
}
exec.shutdown();
/**
* czekam az wszystkie watki skonczą
*/
try {
exec.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (this.getClass().desiredAssertionStatus()) {
try {
assert actual.get() == expectedRes;
System.out.print("[+] OK!\t\t");
} catch (AssertionError e) {
System.out.print("[!] ERR!\t");
}
}
System.out.format("%s:\texpected: %d - actual: %d%n",
useLock ? "SYNC" : "UNSYNC",
expectedRes,
actual.get());
if (useLock) {
assert actual.get() == expectedRes;
}
}
/**
* kompilacja i uruchomienie:
* javac ProgSumTest.java && java -enableassertions ProgSumTest
*
* @param args
*/
public static void main(String[] args) {
ProgSumTest ups = new ProgSumTest();
/**
* Oczekujemy sumy skonczonego ciagu
*/
int expected = ((N_TH * CYCLES) * (0 + (N_TH * CYCLES) - 1)) / 2;
for (int k = 0; k < ROUNDS; k++) {
ups.runTest(expected, false);
ups.reset();
ups.runTest(expected, true);
}
}
} | /**
* czekam az wszystkie watki skonczą
*/ | import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class ProgSumTest {
private static final int N_TH = 9;
private static final int CYCLES = 200;
private static final int ROUNDS = 500;
/**
* czesto mozna sie spotkac z twierdzeniem ze volatile
* pomoze, w Javie w przypadku int zapis do takiej zmiennej
* powinien byc atomowy ale to juz implementation dep.
* postinkrementacja to:
* read
* increment
* assign
*/
private volatile int value = 0;
/**
* synchronized bo o ile dobrze pamietam
* w Javie synchronizacja jest tez bariera pamieci
*/
public synchronized void reset() {
this.value = 0;
}
/**
* zwraca unikalna wartosc?
*/
public synchronized int getNextSync() {
return value++;
}
/**
* zwraca unikalna wartosc?
*/
public int getNext() {
return value++;
}
private void runTest(int expectedRes, boolean useLock) {
/**
* w 'tescie' uzywam atomica zeby wyeliminowac
* bledy pochodzace z samego testu
*/
final AtomicInteger actual = new AtomicInteger(0);
final ExecutorService exec = Executors.newFixedThreadPool(N_TH);
for (int i = 0; i < N_TH; i++) {
Runnable task = new Runnable() {
@Override
public void run() {
for (int j = 0; j < CYCLES; j++) {
/**
* Niestety overlading albo obecnosc w metodzie
* warunkowo wrzuconego bloku synchronized prowadzi do
* poprawnej(niejszej?) synchronizacji
* openjdk version "1.8.0_151"
* OpenJDK Runtime Environment (build 1.8.0_151-b12)
* OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)
*/
int n;
if (useLock) {
n = getNextSync();
} else {
n = getNext();
}
Thread.yield();
actual.addAndGet(n);
}
}
};
exec.execute(task);
}
exec.shutdown();
/**
* czekam az wszystkie <SUF>*/
try {
exec.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (this.getClass().desiredAssertionStatus()) {
try {
assert actual.get() == expectedRes;
System.out.print("[+] OK!\t\t");
} catch (AssertionError e) {
System.out.print("[!] ERR!\t");
}
}
System.out.format("%s:\texpected: %d - actual: %d%n",
useLock ? "SYNC" : "UNSYNC",
expectedRes,
actual.get());
if (useLock) {
assert actual.get() == expectedRes;
}
}
/**
* kompilacja i uruchomienie:
* javac ProgSumTest.java && java -enableassertions ProgSumTest
*
* @param args
*/
public static void main(String[] args) {
ProgSumTest ups = new ProgSumTest();
/**
* Oczekujemy sumy skonczonego ciagu
*/
int expected = ((N_TH * CYCLES) * (0 + (N_TH * CYCLES) - 1)) / 2;
for (int k = 0; k < ROUNDS; k++) {
ups.runTest(expected, false);
ups.reset();
ups.runTest(expected, true);
}
}
} | t |
6753_3 | haldiraros/DataAcquisitor | 599 | src/hubLibrary/meteringcomreader/Hubs.java | /*
* Copyright (C) 2015 Juliusz Jezierski
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package hubLibrary.meteringcomreader;
import hubLibrary.meteringcomreader.exceptions.MeteringSessionException;
import java.util.HashMap;
import java.util.Map;
/**
* Reprezentuje kontener koncentratorów.
* @author Juliusz Jezierski
*/
public class Hubs extends HashMap<String, Hub>{
/**
* Konstruuje pusty kontener koncentratorów o początkowej objętości 16.
*/
public Hubs() {
super();
}
/**
* Konstruuje pusty kontener koncentratorów o wskazanej początkowej liczebności.
* @param i początkowa objętość
*/
public Hubs(int i) {
super(i);
}
/**
* Zwraca obiekt koncentratora na postawie jego heksadecymalnego identyfikatora.
* @param hubNo heksadecymalny identyfikator koncentratora
* @return obiekt koncentratora
* @throws MeteringSessionException zgłaszany w przypadku nie znalezienia koncentratora
*/
public Hub getHub(String hubNo) throws MeteringSessionException {
Hub h = super.get(hubNo);
if (h==null) throw new MeteringSessionException("Hub number:"+hubNo+" no found");
return h;
}
}
| /**
* Konstruuje pusty kontener koncentratorów o wskazanej początkowej liczebności.
* @param i początkowa objętość
*/ | /*
* Copyright (C) 2015 Juliusz Jezierski
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package hubLibrary.meteringcomreader;
import hubLibrary.meteringcomreader.exceptions.MeteringSessionException;
import java.util.HashMap;
import java.util.Map;
/**
* Reprezentuje kontener koncentratorów.
* @author Juliusz Jezierski
*/
public class Hubs extends HashMap<String, Hub>{
/**
* Konstruuje pusty kontener koncentratorów o początkowej objętości 16.
*/
public Hubs() {
super();
}
/**
* Konstruuje pusty kontener <SUF>*/
public Hubs(int i) {
super(i);
}
/**
* Zwraca obiekt koncentratora na postawie jego heksadecymalnego identyfikatora.
* @param hubNo heksadecymalny identyfikator koncentratora
* @return obiekt koncentratora
* @throws MeteringSessionException zgłaszany w przypadku nie znalezienia koncentratora
*/
public Hub getHub(String hubNo) throws MeteringSessionException {
Hub h = super.get(hubNo);
if (h==null) throw new MeteringSessionException("Hub number:"+hubNo+" no found");
return h;
}
}
| t |
10022_7 | hanged-dot/PO_2023_CZW1120_GAJEK_SZCZYPKA_PROJEKT | 738 | DarvinWorld/src/main/java/WordMap/TunnelMap.java | package WordMap;
import Presenter.SimulationPresenter;
import Records.AnimalProperties;
import Records.MapProperties;
import WorldElement.Animal;
import java.util.HashMap;
import java.util.Random;
public class TunnelMap extends AbstractMap {
private int tunnelCount;
private HashMap<Vector2d, Vector2d> tunnels;
public TunnelMap(MapProperties mapProperties,
AnimalProperties animalProperties, SimulationPresenter simPresenter) {
super(mapProperties, animalProperties, simPresenter);
this.tunnels = new HashMap<>();
this.tunnelCount = mapProperties.tunnelCount();
while (tunnelCount > 0){
Random random = new Random();
Vector2d firstEnd = createRandomPosition(mapBoundary);
Vector2d secondEnd = createRandomPosition(mapBoundary);
if (!tunnels.containsKey(firstEnd) && !tunnels.containsKey(secondEnd) &&
!firstEnd.equals(secondEnd)){
tunnels.put(firstEnd, secondEnd);
tunnels.put(secondEnd, firstEnd);
--tunnelCount;
}
}
}
// żeby zwierzak nie wpadł w pułapkę, że po wejściu na tunel przemieszcza się tylko
// pomiędzy dwoma końcami tunelu, musimy pzechowywać jakiegoś boola w którym będzie
// przechowywana informacja, czy zwierzak się właśnie przetransportowal przez tunel -
// jeśli tak, to kolejny ruch jest wykonywany "normlanie"
// w tym celu chyba najlepiej będzie do mapy z tunelami mieć inną klasę zwierząt, która
// będzie mieć wszystkie metody takie jak Animal, ale będzie mieć dodatkowy atrybut
// z boolem przechowującym informację, czy zwierzak właśnie się przetransportował
// z tunelu czy normalnie wszedł na dane pole
@Override
protected Vector2d getNextPosition(Animal animal){
if (tunnels.containsKey(animal.getPosition()) && !animal.isTransferedThroughTunnel()){
Vector2d targetPosition = tunnels.get(animal.getPosition());
animal.setTransferredThroughTunnel(true);
return targetPosition;
} else {
animal.setTransferredThroughTunnel(false);
return super.getNextPosition(animal);
}
}
public HashMap<Vector2d, Vector2d> getTunnels(){
return this.tunnels;
}
public Vector2d getTunnelPair(Vector2d key){
return this.tunnels.get(key);
}
}
| // z tunelu czy normalnie wszedł na dane pole | package WordMap;
import Presenter.SimulationPresenter;
import Records.AnimalProperties;
import Records.MapProperties;
import WorldElement.Animal;
import java.util.HashMap;
import java.util.Random;
public class TunnelMap extends AbstractMap {
private int tunnelCount;
private HashMap<Vector2d, Vector2d> tunnels;
public TunnelMap(MapProperties mapProperties,
AnimalProperties animalProperties, SimulationPresenter simPresenter) {
super(mapProperties, animalProperties, simPresenter);
this.tunnels = new HashMap<>();
this.tunnelCount = mapProperties.tunnelCount();
while (tunnelCount > 0){
Random random = new Random();
Vector2d firstEnd = createRandomPosition(mapBoundary);
Vector2d secondEnd = createRandomPosition(mapBoundary);
if (!tunnels.containsKey(firstEnd) && !tunnels.containsKey(secondEnd) &&
!firstEnd.equals(secondEnd)){
tunnels.put(firstEnd, secondEnd);
tunnels.put(secondEnd, firstEnd);
--tunnelCount;
}
}
}
// żeby zwierzak nie wpadł w pułapkę, że po wejściu na tunel przemieszcza się tylko
// pomiędzy dwoma końcami tunelu, musimy pzechowywać jakiegoś boola w którym będzie
// przechowywana informacja, czy zwierzak się właśnie przetransportowal przez tunel -
// jeśli tak, to kolejny ruch jest wykonywany "normlanie"
// w tym celu chyba najlepiej będzie do mapy z tunelami mieć inną klasę zwierząt, która
// będzie mieć wszystkie metody takie jak Animal, ale będzie mieć dodatkowy atrybut
// z boolem przechowującym informację, czy zwierzak właśnie się przetransportował
// z tunelu <SUF>
@Override
protected Vector2d getNextPosition(Animal animal){
if (tunnels.containsKey(animal.getPosition()) && !animal.isTransferedThroughTunnel()){
Vector2d targetPosition = tunnels.get(animal.getPosition());
animal.setTransferredThroughTunnel(true);
return targetPosition;
} else {
animal.setTransferredThroughTunnel(false);
return super.getNextPosition(animal);
}
}
public HashMap<Vector2d, Vector2d> getTunnels(){
return this.tunnels;
}
public Vector2d getTunnelPair(Vector2d key){
return this.tunnels.get(key);
}
}
| t |
4445_4 | honestit/spring-intro | 309 | projects/honestit-2020-10-11/src/main/java/pl/sda/projects/adverts/model/domain/User.java | package pl.sda.projects.adverts.model.domain;
import lombok.*;
import javax.persistence.*;
@Entity
// Spring Boot konfiguruje własny mechanizm nazewniczy
// który domyślnie nazwy tabel tworzy przez stworzenie
// liczby mnogiej z nazwy klasy i wszystko małymi
// literami
@Table(name = "users")
@Getter @Setter @ToString(exclude = "password") @EqualsAndHashCode(of = "id")
@AllArgsConstructor @NoArgsConstructor @Builder
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true)
private String username;
@Column(nullable = false)
private String password;
// Spring Boot konfiguruje własny mechanizm nazewniczy
// który domyślnie zamienia camel case na uderscore
// (_) cale i wszystko z małych liter
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
private Boolean active = true;
}
| // który domyślnie zamienia camel case na uderscore | package pl.sda.projects.adverts.model.domain;
import lombok.*;
import javax.persistence.*;
@Entity
// Spring Boot konfiguruje własny mechanizm nazewniczy
// który domyślnie nazwy tabel tworzy przez stworzenie
// liczby mnogiej z nazwy klasy i wszystko małymi
// literami
@Table(name = "users")
@Getter @Setter @ToString(exclude = "password") @EqualsAndHashCode(of = "id")
@AllArgsConstructor @NoArgsConstructor @Builder
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true)
private String username;
@Column(nullable = false)
private String password;
// Spring Boot konfiguruje własny mechanizm nazewniczy
// który domyślnie <SUF>
// (_) cale i wszystko z małych liter
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
private Boolean active = true;
}
| t |
8258_3 | hsuliz/university | 401 | year-2021/java/assignment-01/DecoderInterface.java |
/**
* Abstrakcyjna klasa definiująca interfejs pozwalający na dekodowanie protokołu
* szeregowego opisanego w zadaniu 01.
*
* @author oramus
*
*/
public abstract class DecoderInterface {
/**
* Metoda pozwala na dostarczanie danych do zdekodowania. Pojedyncze wywołanie
* metody dostarcza jeden bit.
*
* @param bit Argumentem wywołania jest dekodowany bit. Argument może przybrać
* wartości wyłącznie 0 i 1.
*/
public abstract void input(int bit);
/**
* Metoda zwraca odkodowane dane. Metoda nigdy nie zwraca null. Jeśli jeszcze
* żadna liczba nie została odkodowana metoda zwraca "" (pusty ciąg znaków,
* czyli ciąg znaków o długości równej 0).
*
* @return Ciąg znaków reprezentujący sekwencję odkodowanych danych.
*/
public abstract String output();
/**
* Metoda przywraca stan poczÄ…tkowy. Proces odkodowywania danych zaczyna siÄ™ od
* poczÄ…tku.
*/
public abstract void reset();
} | /**
* Metoda przywraca stan poczÄ…tkowy. Proces odkodowywania danych zaczyna siÄ™ od
* poczÄ…tku.
*/ |
/**
* Abstrakcyjna klasa definiująca interfejs pozwalający na dekodowanie protokołu
* szeregowego opisanego w zadaniu 01.
*
* @author oramus
*
*/
public abstract class DecoderInterface {
/**
* Metoda pozwala na dostarczanie danych do zdekodowania. Pojedyncze wywołanie
* metody dostarcza jeden bit.
*
* @param bit Argumentem wywołania jest dekodowany bit. Argument może przybrać
* wartości wyłącznie 0 i 1.
*/
public abstract void input(int bit);
/**
* Metoda zwraca odkodowane dane. Metoda nigdy nie zwraca null. Jeśli jeszcze
* żadna liczba nie została odkodowana metoda zwraca "" (pusty ciąg znaków,
* czyli ciąg znaków o długości równej 0).
*
* @return Ciąg znaków reprezentujący sekwencję odkodowanych danych.
*/
public abstract String output();
/**
* Metoda przywraca stan <SUF>*/
public abstract void reset();
} | t |
232_16 | hypeapps/black-mirror | 3,168 | app/src/main/java/pl/hypeapps/blackmirror/ui/features/home/HomePresenter.java | package pl.hypeapps.blackmirror.ui.features.home;
import android.util.Log;
import java.util.List;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.observers.DisposableSingleObserver;
import io.reactivex.schedulers.Schedulers;
import pl.hypeapps.blackmirror.model.location.TimeZone;
import pl.hypeapps.blackmirror.model.news.News;
import pl.hypeapps.blackmirror.model.weather.WeatherResponse;
import pl.hypeapps.blackmirror.network.LocationRepository;
import pl.hypeapps.blackmirror.network.NewsRepository;
import pl.hypeapps.blackmirror.network.WeatherRepository;
import pl.hypeapps.blackmirror.network.api.location.LocationDataSource;
import pl.hypeapps.blackmirror.network.api.weather.WeatherDataSource;
import pl.hypeapps.blackmirror.network.rss.news.NewsDataSource;
import pl.hypeapps.blackmirror.speechrecognition.TextCommandInterpreter;
import pl.hypeapps.blackmirror.ui.presenter.Presenter;
/**
* Klasa, której zadaniem jest manipulowanie widokiem, oraz zarządzanie warstwą
* dostępu do danych.
*/
public class HomePresenter extends Presenter<HomeView> implements TextCommandInterpreter.Listener {
private static final String TAG = "HomePresenter";
private final WeatherRepository weatherDataSource = new WeatherDataSource();
private final LocationRepository locationDataSource = new LocationDataSource();
private final NewsRepository newsDataSource = new NewsDataSource();
private TextCommandInterpreter textCommandInterpreter = new TextCommandInterpreter(this);
private CompositeDisposable disposables = new CompositeDisposable();
/**
* Zdarzenie wykonywane kiedy dojdzie do rozpoznania mowy.
* Parametr wykorzystywany jest do interpretacji komendy.
*
* @param result rezultat rozpoznawania mowy.
*/
void onSpeechRecognized(String result) {
textCommandInterpreter.interpret(result);
}
/**
* Metoda wykonywana kiedy tworzymy widok.
*/
@Override
protected void onAttachView(HomeView view) {
super.onAttachView(view);
this.view.startSplashScreen();
}
/**
* Metoda wykonywana kiedy niszczymy widok.
*/
@Override
protected void onDetachView() {
super.onDetachView();
if (!disposables.isDisposed()) {
disposables.dispose();
}
}
/**
* Metoda wywoływana kiedy rozpoznawanie komendy zakończy się niepowodzeniem.
* Pokazuje komunikat o błędzie.
*/
@Override
public void onFailureCommandRecognizing() {
Log.e(TAG, "Text command interpreter failed to recognize command");
this.view.showError("Niepoprawna komenda");
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania pogody.
* Pokazuje widżet.
*/
@Override
public void onShowWeatherCommandRecognized(String location) {
Log.i(TAG, "Text command interpreter recognized weather command for location: " + location);
disposables.add(weatherDataSource.getWeatherByCityName(location, "metric", "pl")
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new WeatherResponseObserver()));
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia pogody.
* Ukrywa widżet.
*/
@Override
public void onHideWeatherCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide weather widget command.");
this.view.hideWeatherWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania zegara.
* Rejestruje obserwatora żądania REST.
* @param location lokalizacja dla, której ma zostać pokazany czas.
*/
@Override
public void onShowTimeCommandRecognized(String location) {
Log.i(TAG, "Text command interpreter recognized time command for location: " + location);
disposables.add(locationDataSource.getTimeZoneByLocationName(location)
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new TimeZoneObserver()));
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia zegara.
* Ukrywa widżet.
*/
@Override
public void onHideTimeCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide time widget command.");
this.view.hideTimeWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania kalendarza.
* Pokazuje kalendarz.
*/
@Override
public void onShowCalendarCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show calendar command.");
this.view.showCalendarWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia kalendarza.
* Ukrywa kalendarz.
*/
@Override
public void onHideCalendarCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide calendar command.");
this.view.hideCalendarWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania kolejnego miesiąca.
* Zmienia aktualny miesiąć kalendarza na kolejny.
*/
@Override
public void onNextMonthCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized calendar next month command.");
this.view.setCalendarNextMonth();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania poprzedniego miesiąca.
* Zmienia aktualny miesiąć kalendarza na poprzedni.
*/
@Override
public void onPreviousMonthRecognized() {
Log.i(TAG, "Text command interpreter recognized calendar previous month command.");
this.view.setCalendarPreviousMonth();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania widżetu wiadomości.
* Pokazuje widżet.
*/
@Override
public void onShowNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show all news command.");
callPolsatNews();
callTvnNews();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia widżetu wiadomości.
* Ukrywa widżet.
*/
@Override
public void onHideNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide all news command.");
this.view.hideAllNewsWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania widżetu wiadomości kanału tvn.
* Pokazuje widżet z kanałem tvn.
*/
@Override
public void onShowTvnNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show tvn news command.");
callTvnNews();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania widżetu wiadomości kanału polsat.
* Pokazuje widżet z kanałem polsat.
*/
@Override
public void onShowPolsatNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show polsat news command.");
callPolsatNews();
}
private void callTvnNews() {
Log.i(TAG, "Text command interpreter recognized news command for tvn news, polsat hide if visible");
disposables.add(newsDataSource.getTvnNews()
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new TvnNewsObserver()));
}
private void callPolsatNews() {
Log.i(TAG, "Text command interpreter recognized news command for polsat news, tvn24 hide if visible");
disposables.add(newsDataSource.getPolsatNews()
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new PolsatNewsObserver()));
}
/**
* Obserwuje status wykonanego żądania restowego pogody.
*/
private class WeatherResponseObserver extends DisposableSingleObserver<WeatherResponse> {
@Override
public void onSuccess(@NonNull WeatherResponse weatherResponse) {
Log.i(TAG, "WeatherResponseObserver: onSuccess");
HomePresenter.this.view.showWeatherWidget(weatherResponse);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "WeatherResponseObserver: onError - " + e.getCause());
HomePresenter.this.view.showError("Nie znaleziono pogody");
}
}
/**
* Obserwuje status wykonanego żądania restowego czasu.
*/
private class TimeZoneObserver extends DisposableSingleObserver<TimeZone> {
@Override
public void onSuccess(@NonNull TimeZone timeZone) {
Log.i(TAG, "TimeZoneObserver: onSuccess");
HomePresenter.this.view.showTimeWidget(timeZone.timeZone);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "TimeZoneObserver: onError - " + e.getCause());
HomePresenter.this.view.showError("Nie znaleziono czasu dla podanej strefy");
}
}
/**
* Obserwuje status wykonanego żądania rss wiadomości ze świata.
*/
private class TvnNewsObserver extends DisposableSingleObserver<List<News>> {
@Override
public void onSuccess(List<News> news) {
Log.i(TAG, "TvnNewsObserver: onSuccess");
HomePresenter.this.view.showTvnNewsWidget(news);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "TvnNewsObserver: onError - " + e.getCause());
HomePresenter.this.view.showError("Nie udało się pobrać wiadomości");
}
}
/**
* Obserwuje status wykonanego żądania rss wiadomości ze świata.
*/
private class PolsatNewsObserver extends DisposableSingleObserver<List<News>> {
@Override
public void onSuccess(List<News> news) {
Log.i(TAG, "PolsatNewsObserver: onSuccess");
HomePresenter.this.view.showPolsatNewsWidget(news);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "PolsatNewsObserver: onError - " + e.getCause());
e.printStackTrace();
HomePresenter.this.view.showError("Nie udało się pobrać wiadomości");
}
}
}
| /**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania widżetu wiadomości kanału polsat.
* Pokazuje widżet z kanałem polsat.
*/ | package pl.hypeapps.blackmirror.ui.features.home;
import android.util.Log;
import java.util.List;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.observers.DisposableSingleObserver;
import io.reactivex.schedulers.Schedulers;
import pl.hypeapps.blackmirror.model.location.TimeZone;
import pl.hypeapps.blackmirror.model.news.News;
import pl.hypeapps.blackmirror.model.weather.WeatherResponse;
import pl.hypeapps.blackmirror.network.LocationRepository;
import pl.hypeapps.blackmirror.network.NewsRepository;
import pl.hypeapps.blackmirror.network.WeatherRepository;
import pl.hypeapps.blackmirror.network.api.location.LocationDataSource;
import pl.hypeapps.blackmirror.network.api.weather.WeatherDataSource;
import pl.hypeapps.blackmirror.network.rss.news.NewsDataSource;
import pl.hypeapps.blackmirror.speechrecognition.TextCommandInterpreter;
import pl.hypeapps.blackmirror.ui.presenter.Presenter;
/**
* Klasa, której zadaniem jest manipulowanie widokiem, oraz zarządzanie warstwą
* dostępu do danych.
*/
public class HomePresenter extends Presenter<HomeView> implements TextCommandInterpreter.Listener {
private static final String TAG = "HomePresenter";
private final WeatherRepository weatherDataSource = new WeatherDataSource();
private final LocationRepository locationDataSource = new LocationDataSource();
private final NewsRepository newsDataSource = new NewsDataSource();
private TextCommandInterpreter textCommandInterpreter = new TextCommandInterpreter(this);
private CompositeDisposable disposables = new CompositeDisposable();
/**
* Zdarzenie wykonywane kiedy dojdzie do rozpoznania mowy.
* Parametr wykorzystywany jest do interpretacji komendy.
*
* @param result rezultat rozpoznawania mowy.
*/
void onSpeechRecognized(String result) {
textCommandInterpreter.interpret(result);
}
/**
* Metoda wykonywana kiedy tworzymy widok.
*/
@Override
protected void onAttachView(HomeView view) {
super.onAttachView(view);
this.view.startSplashScreen();
}
/**
* Metoda wykonywana kiedy niszczymy widok.
*/
@Override
protected void onDetachView() {
super.onDetachView();
if (!disposables.isDisposed()) {
disposables.dispose();
}
}
/**
* Metoda wywoływana kiedy rozpoznawanie komendy zakończy się niepowodzeniem.
* Pokazuje komunikat o błędzie.
*/
@Override
public void onFailureCommandRecognizing() {
Log.e(TAG, "Text command interpreter failed to recognize command");
this.view.showError("Niepoprawna komenda");
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania pogody.
* Pokazuje widżet.
*/
@Override
public void onShowWeatherCommandRecognized(String location) {
Log.i(TAG, "Text command interpreter recognized weather command for location: " + location);
disposables.add(weatherDataSource.getWeatherByCityName(location, "metric", "pl")
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new WeatherResponseObserver()));
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia pogody.
* Ukrywa widżet.
*/
@Override
public void onHideWeatherCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide weather widget command.");
this.view.hideWeatherWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania zegara.
* Rejestruje obserwatora żądania REST.
* @param location lokalizacja dla, której ma zostać pokazany czas.
*/
@Override
public void onShowTimeCommandRecognized(String location) {
Log.i(TAG, "Text command interpreter recognized time command for location: " + location);
disposables.add(locationDataSource.getTimeZoneByLocationName(location)
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new TimeZoneObserver()));
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia zegara.
* Ukrywa widżet.
*/
@Override
public void onHideTimeCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide time widget command.");
this.view.hideTimeWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania kalendarza.
* Pokazuje kalendarz.
*/
@Override
public void onShowCalendarCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show calendar command.");
this.view.showCalendarWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia kalendarza.
* Ukrywa kalendarz.
*/
@Override
public void onHideCalendarCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide calendar command.");
this.view.hideCalendarWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania kolejnego miesiąca.
* Zmienia aktualny miesiąć kalendarza na kolejny.
*/
@Override
public void onNextMonthCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized calendar next month command.");
this.view.setCalendarNextMonth();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania poprzedniego miesiąca.
* Zmienia aktualny miesiąć kalendarza na poprzedni.
*/
@Override
public void onPreviousMonthRecognized() {
Log.i(TAG, "Text command interpreter recognized calendar previous month command.");
this.view.setCalendarPreviousMonth();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania widżetu wiadomości.
* Pokazuje widżet.
*/
@Override
public void onShowNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show all news command.");
callPolsatNews();
callTvnNews();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda ukrycia widżetu wiadomości.
* Ukrywa widżet.
*/
@Override
public void onHideNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized hide all news command.");
this.view.hideAllNewsWidget();
}
/**
* Metoda wywoływana kiedy rozpoznana zostanie komenda pokazania widżetu wiadomości kanału tvn.
* Pokazuje widżet z kanałem tvn.
*/
@Override
public void onShowTvnNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show tvn news command.");
callTvnNews();
}
/**
* Metoda wywoływana kiedy <SUF>*/
@Override
public void onShowPolsatNewsCommandRecognized() {
Log.i(TAG, "Text command interpreter recognized show polsat news command.");
callPolsatNews();
}
private void callTvnNews() {
Log.i(TAG, "Text command interpreter recognized news command for tvn news, polsat hide if visible");
disposables.add(newsDataSource.getTvnNews()
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new TvnNewsObserver()));
}
private void callPolsatNews() {
Log.i(TAG, "Text command interpreter recognized news command for polsat news, tvn24 hide if visible");
disposables.add(newsDataSource.getPolsatNews()
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new PolsatNewsObserver()));
}
/**
* Obserwuje status wykonanego żądania restowego pogody.
*/
private class WeatherResponseObserver extends DisposableSingleObserver<WeatherResponse> {
@Override
public void onSuccess(@NonNull WeatherResponse weatherResponse) {
Log.i(TAG, "WeatherResponseObserver: onSuccess");
HomePresenter.this.view.showWeatherWidget(weatherResponse);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "WeatherResponseObserver: onError - " + e.getCause());
HomePresenter.this.view.showError("Nie znaleziono pogody");
}
}
/**
* Obserwuje status wykonanego żądania restowego czasu.
*/
private class TimeZoneObserver extends DisposableSingleObserver<TimeZone> {
@Override
public void onSuccess(@NonNull TimeZone timeZone) {
Log.i(TAG, "TimeZoneObserver: onSuccess");
HomePresenter.this.view.showTimeWidget(timeZone.timeZone);
}
@Override
public void onError(@NonNull Throwable e) {
Log.e(TAG, "TimeZoneObserver: onError - " + e.getCause());
HomePresenter.this.view.showError("Nie znaleziono czasu dla podanej strefy");
}
}
/**
* Obserwuje status wykonanego żądania rss wiadomości ze świata.
*/
private class TvnNewsObserver extends DisposableSingleObserver<List<News>> {
@Override
public void onSuccess(List<News> news) {
Log.i(TAG, "TvnNewsObserver: onSuccess");
HomePresenter.this.view.showTvnNewsWidget(news);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "TvnNewsObserver: onError - " + e.getCause());
HomePresenter.this.view.showError("Nie udało się pobrać wiadomości");
}
}
/**
* Obserwuje status wykonanego żądania rss wiadomości ze świata.
*/
private class PolsatNewsObserver extends DisposableSingleObserver<List<News>> {
@Override
public void onSuccess(List<News> news) {
Log.i(TAG, "PolsatNewsObserver: onSuccess");
HomePresenter.this.view.showPolsatNewsWidget(news);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "PolsatNewsObserver: onError - " + e.getCause());
e.printStackTrace();
HomePresenter.this.view.showError("Nie udało się pobrać wiadomości");
}
}
}
| t |
217_0 | icplayer/icplayer | 588 | src/main/java/com/lorepo/icplayer/client/model/asset/BasicAsset.java | package com.lorepo.icplayer.client.model.asset;
import com.lorepo.icf.utils.StringUtils;
import com.lorepo.icplayer.client.model.IAsset;
/**
* Model reprezentujący zasób prezentacji.
* Na razie wersja uproszczona, ale na pewno się rozwinie
*
* @author Krzysztof Langner
*
*/
public class BasicAsset implements IAsset{
private String type;
private String href;
private String title = "";
private String fileName = "";
private String contentType = "";
private int OrderNumber;
public BasicAsset(String type, String url){
this.type = type;
this.href = url;
}
@Override
public String getHref() {
return href;
}
@Override
public String getType() {
return type;
}
@Override
public String toXML() {
String titleEscaped = StringUtils.escapeXML(title);
String fileNameEscaped = StringUtils.escapeXML(fileName);
String xml = "<asset type='" + type + "' href='" + href + "' title='" +
titleEscaped + "' fileName='" + fileNameEscaped + "' contentType='" + contentType + "'/>";
return xml;
}
@Override
public String getTitle() {
return title;
}
@Override
public String getFileName() {
return fileName;
}
@Override
public String getContentType() {
return contentType;
}
@Override
public void setTitle(String title) {
this.title = title;
}
@Override
public void setFileName(String name) {
this.fileName = name;
}
@Override
public void setContentType(String type) {
this.contentType = type;
}
@Override
public void setOrderNumber(int number) {
this.OrderNumber = number;
}
@Override
public int getOrderNumber() {
return this.OrderNumber;
}
}
| /**
* Model reprezentujący zasób prezentacji.
* Na razie wersja uproszczona, ale na pewno się rozwinie
*
* @author Krzysztof Langner
*
*/ | package com.lorepo.icplayer.client.model.asset;
import com.lorepo.icf.utils.StringUtils;
import com.lorepo.icplayer.client.model.IAsset;
/**
* Model reprezentujący zasób <SUF>*/
public class BasicAsset implements IAsset{
private String type;
private String href;
private String title = "";
private String fileName = "";
private String contentType = "";
private int OrderNumber;
public BasicAsset(String type, String url){
this.type = type;
this.href = url;
}
@Override
public String getHref() {
return href;
}
@Override
public String getType() {
return type;
}
@Override
public String toXML() {
String titleEscaped = StringUtils.escapeXML(title);
String fileNameEscaped = StringUtils.escapeXML(fileName);
String xml = "<asset type='" + type + "' href='" + href + "' title='" +
titleEscaped + "' fileName='" + fileNameEscaped + "' contentType='" + contentType + "'/>";
return xml;
}
@Override
public String getTitle() {
return title;
}
@Override
public String getFileName() {
return fileName;
}
@Override
public String getContentType() {
return contentType;
}
@Override
public void setTitle(String title) {
this.title = title;
}
@Override
public void setFileName(String name) {
this.fileName = name;
}
@Override
public void setContentType(String type) {
this.contentType = type;
}
@Override
public void setOrderNumber(int number) {
this.OrderNumber = number;
}
@Override
public int getOrderNumber() {
return this.OrderNumber;
}
}
| t |
6185_0 | idkhtn/Shirobon | 807 | BomberMan/src/objects/Bomb.java | package objects;
import java.awt.Color;
import java.awt.Graphics2D;
import java.util.Random;
import game.Game;
/**
* Klasa postawionej bomby - zawiera w sobie pośrednio eksplozję.
*/
public class Bomb
{
private long start;
private long hideTime;
private Explosion[] explosion = new Explosion[10];
private Game game;
private int x;
private int y;
private boolean visible = true;
public Bomb(Game game, int x, int y, long startTime) {
this.game = game;
this.x = x;
this.y = y;
this.start = startTime;
if(Game.multi)
this.hideTime = start+3000;
else
this.hideTime = start+2000+new Random().nextInt(2001);
explosion[Game.currentExplosions] = new Explosion(game,x,y,hideTime);
}
public Explosion getExplosion()
{
return this.explosion[Game.currentExplosions];
}
public void update()
{
if(System.currentTimeMillis() > hideTime)
{
this.visible = false;
}
}
public void draw(Graphics2D g2d)
{
if(System.currentTimeMillis() < hideTime)
{
g2d.setColor(Color.RED);
g2d.fillOval(this.x-AbstCharacter.getMargin(), this.y-AbstCharacter.getMargin(), Game.TILE_SIZE-AbstCharacter.getMargin(), Game.TILE_SIZE-AbstCharacter.getMargin());
}
else
{
if(System.currentTimeMillis() < hideTime + Game.EXPLOSION_TIME)
{
explosion[Game.currentExplosions].setVisible(true);
explosion[Game.currentExplosions].draw(g2d);
}
else
explosion[Game.currentExplosions].setVisible(false);
}
}
public boolean isVisible() {
return visible;
}
public long getHideTime() {
return hideTime;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void setStart(long start) {
this.start = start;
}
public void setHideTime(long hideTime) {
this.hideTime = hideTime;
}
public void setExplosion(Explosion[] explosion) {
this.explosion = explosion;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public void setVisible(boolean visible) {
this.visible = visible;
}
}
| /**
* Klasa postawionej bomby - zawiera w sobie pośrednio eksplozję.
*/ | package objects;
import java.awt.Color;
import java.awt.Graphics2D;
import java.util.Random;
import game.Game;
/**
* Klasa postawionej bomby <SUF>*/
public class Bomb
{
private long start;
private long hideTime;
private Explosion[] explosion = new Explosion[10];
private Game game;
private int x;
private int y;
private boolean visible = true;
public Bomb(Game game, int x, int y, long startTime) {
this.game = game;
this.x = x;
this.y = y;
this.start = startTime;
if(Game.multi)
this.hideTime = start+3000;
else
this.hideTime = start+2000+new Random().nextInt(2001);
explosion[Game.currentExplosions] = new Explosion(game,x,y,hideTime);
}
public Explosion getExplosion()
{
return this.explosion[Game.currentExplosions];
}
public void update()
{
if(System.currentTimeMillis() > hideTime)
{
this.visible = false;
}
}
public void draw(Graphics2D g2d)
{
if(System.currentTimeMillis() < hideTime)
{
g2d.setColor(Color.RED);
g2d.fillOval(this.x-AbstCharacter.getMargin(), this.y-AbstCharacter.getMargin(), Game.TILE_SIZE-AbstCharacter.getMargin(), Game.TILE_SIZE-AbstCharacter.getMargin());
}
else
{
if(System.currentTimeMillis() < hideTime + Game.EXPLOSION_TIME)
{
explosion[Game.currentExplosions].setVisible(true);
explosion[Game.currentExplosions].draw(g2d);
}
else
explosion[Game.currentExplosions].setVisible(false);
}
}
public boolean isVisible() {
return visible;
}
public long getHideTime() {
return hideTime;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void setStart(long start) {
this.start = start;
}
public void setHideTime(long hideTime) {
this.hideTime = hideTime;
}
public void setExplosion(Explosion[] explosion) {
this.explosion = explosion;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public void setVisible(boolean visible) {
this.visible = visible;
}
}
| t |
3686_37 | igrek51/coop-pathfinder | 2,577 | coop-pathfinder/src/main/java/igrek/robopath/pathfinder/astar/Astar2DPathFinder.java | package igrek.robopath.pathfinder.astar;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import igrek.robopath.common.TileMap;
public class Astar2DPathFinder {
private Logger logger = LoggerFactory.getLogger(this.getClass());
private List<Node> closed = new ArrayList<>();
private PriorityQueue<Node> open = new PriorityQueue<>();
private Node[][] nodes;
private TileMap map;
public Astar2DPathFinder(TileMap map) {
this.map = map;
}
private int width() {
return map.getWidthInTiles();
}
private int height() {
return map.getHeightInTiles();
}
public Path findPath(int sx, int sy, int tx, int ty) {
// initial state for A*. The closed group is empty. Only the starting
// tile is in the open list and it'e're already there
closed.clear();
open.clear();
nodes = new Node[width()][height()];
for (int x = 0; x < width(); x++) {
for (int y = 0; y < height(); y++) {
nodes[x][y] = new Node(x, y);
nodes[x][y].setCost(Float.MAX_VALUE);
}
}
nodes[sx][sy].setCost(0);
nodes[sx][sy].setHeuristic(getHeuristicCost(sx, sy, tx, ty));
//Dodajemy pole startowe (lub węzeł) do Listy Otwartych.
open.add(nodes[sx][sy]);
// first check, if the destination is blocked, we can't get there
if (map.blocked(tx, ty))
return null;
//jeśli punkt docelowy jest punktem startowym - brak ścieżki
if (sx == tx && sy == ty)
return null;
//dopóki lista otwartych nie jest pusta
while (!open.isEmpty()) {
// pull out the first node in our open list, this is determined to
// be the most likely to be the next step based on our heuristic
//Szukamy pola o najniższej wartości F na Liście Otwartych. Czynimy je aktualnym polem
Node current = open.peek();
//jeśli current jest węzłem docelowym
if (current.getX() == tx && current.getY() == ty) {
// At this point we've definitely found a path so we can uses the parent
// references of the nodes to find out way from the target location back
// to the start recording the nodes on the way.
//Zapisujemy ścieżkę. Krocząc w kierunku od pola docelowego do startowego, przeskakujemy z kolejnych pól na im przypisane pola rodziców, aż do osiągnięcia pola startowego.
Path path = new Path();
Node node = nodes[tx][ty];
while (node != nodes[sx][sy]) {
path.prependStep(node.getX(), node.getY());
node = node.getParent();
if (node == null) {
logger.error("node (parent) = null");
}
}
path.prependStep(sx, sy);
return path;
}
//Aktualne pole przesuwamy do Listy Zamkniętych.
open.remove(current);
closed.add(current);
// search through all the neighbours of the current node evaluating
// them as next steps
//Dla każdego z wybranych przyległych pól (sasiad) do pola aktualnego
List<Node> neighbours = availableNeighbours(current);
for (Node neighbour : neighbours) {
//jeśli NIE-MOŻNA go przejść, ignorujemy je.
if (!isValidLocation(sx, sy, neighbour.getX(), neighbour.getY()))
continue;
if (!isValidMove(current.getX(), current.getY(), neighbour.getX(), neighbour.getY()))
continue;
// the cost to get to this node is cost the current plus the movement
// cost to reach this node. Note that the heursitic value is only used
// in the sorted open list
float newCost = current.getCost() + getMovementCost(current.getX(), current.getY(), neighbour
.getX(), neighbour.getY());
// if the new cost we've determined for this node is lower than
// it has been previously makes sure the node hasn'e've
// determined that there might have been a better path to get to
// this node so it needs to be re-evaluated
if (newCost < neighbour.getCost()) {
if (open.contains(neighbour))
open.remove(neighbour);
if (closed.contains(neighbour))
closed.remove(neighbour);
}
// if the node hasn't already been processed and discarded then
// reset it's cost to our current cost and add it as a next possible
// step (i.e. to the open list)
if (!open.contains(neighbour) && !closed.contains(neighbour)) {
neighbour.setCost(newCost);
neighbour.setHeuristic(getHeuristicCost(neighbour.getX(), neighbour.getY(), tx, ty));
neighbour.setParent(current);
open.add(neighbour);
}
}
}
// since we'e've run out of search there was no path
return null;
}
protected boolean isValidLocation(int sx, int sy, int x, int y) {
if (x < 0 || y < 0 || x >= width() || y >= height())
return false;
if (map.blocked(x, y))
return false;
return true;
}
protected boolean isValidMove(int sx, int sy, int x, int y) {
if (!isValidLocation(sx, sy, x, y)) {
return false;
}
// diagonal move not possible when one cell is blocked
int dx = abs(sx - x);
int dy = abs(sy - y);
// diagonal move
if (dx == 1 && dy == 1) {
if (map.blocked(x, y) || map.blocked(sx, sy) || map.blocked(sx, y) || map.blocked(x, sy)) {
return false;
}
}
return true;
}
private int abs(int x) {
return x >= 0 ? x : -x;
}
protected float getMovementCost(int x, int y, int tx, int ty) {
// return Math.max(Math.abs(tx - x), Math.abs(ty - y));
// return (float) Math.abs(tx - x) + Math.abs(ty - y);
return (float) Math.hypot(tx - x, ty - y);
}
protected float getHeuristicCost(int x, int y, int tx, int ty) {
// return (float) Math.max(Math.abs(tx - x), Math.abs(ty - y));
// return (float) Math.abs(tx - x) + Math.abs(ty - y);
return (float) Math.hypot(tx - x, ty - y);
}
private List<Node> availableNeighbours(Node current) {
List<Node> neighbours = new LinkedList<>();
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
if (dx == 0 && dy == 0)
continue;
// determine the location of the neighbour and evaluate it
int xp = current.getX() + dx;
int yp = current.getY() + dy;
// validate out of bounds
if ((xp < 0) || (yp < 0) || (xp >= width()) || (yp >= height()))
continue;
neighbours.add(nodes[xp][yp]);
}
}
// możliwe czekanie w tym samym miejscu - jako ostatnia propozycja
neighbours.add(nodes[current.getX()][current.getY()]);
return neighbours;
}
}
| // możliwe czekanie w tym samym miejscu - jako ostatnia propozycja | package igrek.robopath.pathfinder.astar;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import igrek.robopath.common.TileMap;
public class Astar2DPathFinder {
private Logger logger = LoggerFactory.getLogger(this.getClass());
private List<Node> closed = new ArrayList<>();
private PriorityQueue<Node> open = new PriorityQueue<>();
private Node[][] nodes;
private TileMap map;
public Astar2DPathFinder(TileMap map) {
this.map = map;
}
private int width() {
return map.getWidthInTiles();
}
private int height() {
return map.getHeightInTiles();
}
public Path findPath(int sx, int sy, int tx, int ty) {
// initial state for A*. The closed group is empty. Only the starting
// tile is in the open list and it'e're already there
closed.clear();
open.clear();
nodes = new Node[width()][height()];
for (int x = 0; x < width(); x++) {
for (int y = 0; y < height(); y++) {
nodes[x][y] = new Node(x, y);
nodes[x][y].setCost(Float.MAX_VALUE);
}
}
nodes[sx][sy].setCost(0);
nodes[sx][sy].setHeuristic(getHeuristicCost(sx, sy, tx, ty));
//Dodajemy pole startowe (lub węzeł) do Listy Otwartych.
open.add(nodes[sx][sy]);
// first check, if the destination is blocked, we can't get there
if (map.blocked(tx, ty))
return null;
//jeśli punkt docelowy jest punktem startowym - brak ścieżki
if (sx == tx && sy == ty)
return null;
//dopóki lista otwartych nie jest pusta
while (!open.isEmpty()) {
// pull out the first node in our open list, this is determined to
// be the most likely to be the next step based on our heuristic
//Szukamy pola o najniższej wartości F na Liście Otwartych. Czynimy je aktualnym polem
Node current = open.peek();
//jeśli current jest węzłem docelowym
if (current.getX() == tx && current.getY() == ty) {
// At this point we've definitely found a path so we can uses the parent
// references of the nodes to find out way from the target location back
// to the start recording the nodes on the way.
//Zapisujemy ścieżkę. Krocząc w kierunku od pola docelowego do startowego, przeskakujemy z kolejnych pól na im przypisane pola rodziców, aż do osiągnięcia pola startowego.
Path path = new Path();
Node node = nodes[tx][ty];
while (node != nodes[sx][sy]) {
path.prependStep(node.getX(), node.getY());
node = node.getParent();
if (node == null) {
logger.error("node (parent) = null");
}
}
path.prependStep(sx, sy);
return path;
}
//Aktualne pole przesuwamy do Listy Zamkniętych.
open.remove(current);
closed.add(current);
// search through all the neighbours of the current node evaluating
// them as next steps
//Dla każdego z wybranych przyległych pól (sasiad) do pola aktualnego
List<Node> neighbours = availableNeighbours(current);
for (Node neighbour : neighbours) {
//jeśli NIE-MOŻNA go przejść, ignorujemy je.
if (!isValidLocation(sx, sy, neighbour.getX(), neighbour.getY()))
continue;
if (!isValidMove(current.getX(), current.getY(), neighbour.getX(), neighbour.getY()))
continue;
// the cost to get to this node is cost the current plus the movement
// cost to reach this node. Note that the heursitic value is only used
// in the sorted open list
float newCost = current.getCost() + getMovementCost(current.getX(), current.getY(), neighbour
.getX(), neighbour.getY());
// if the new cost we've determined for this node is lower than
// it has been previously makes sure the node hasn'e've
// determined that there might have been a better path to get to
// this node so it needs to be re-evaluated
if (newCost < neighbour.getCost()) {
if (open.contains(neighbour))
open.remove(neighbour);
if (closed.contains(neighbour))
closed.remove(neighbour);
}
// if the node hasn't already been processed and discarded then
// reset it's cost to our current cost and add it as a next possible
// step (i.e. to the open list)
if (!open.contains(neighbour) && !closed.contains(neighbour)) {
neighbour.setCost(newCost);
neighbour.setHeuristic(getHeuristicCost(neighbour.getX(), neighbour.getY(), tx, ty));
neighbour.setParent(current);
open.add(neighbour);
}
}
}
// since we'e've run out of search there was no path
return null;
}
protected boolean isValidLocation(int sx, int sy, int x, int y) {
if (x < 0 || y < 0 || x >= width() || y >= height())
return false;
if (map.blocked(x, y))
return false;
return true;
}
protected boolean isValidMove(int sx, int sy, int x, int y) {
if (!isValidLocation(sx, sy, x, y)) {
return false;
}
// diagonal move not possible when one cell is blocked
int dx = abs(sx - x);
int dy = abs(sy - y);
// diagonal move
if (dx == 1 && dy == 1) {
if (map.blocked(x, y) || map.blocked(sx, sy) || map.blocked(sx, y) || map.blocked(x, sy)) {
return false;
}
}
return true;
}
private int abs(int x) {
return x >= 0 ? x : -x;
}
protected float getMovementCost(int x, int y, int tx, int ty) {
// return Math.max(Math.abs(tx - x), Math.abs(ty - y));
// return (float) Math.abs(tx - x) + Math.abs(ty - y);
return (float) Math.hypot(tx - x, ty - y);
}
protected float getHeuristicCost(int x, int y, int tx, int ty) {
// return (float) Math.max(Math.abs(tx - x), Math.abs(ty - y));
// return (float) Math.abs(tx - x) + Math.abs(ty - y);
return (float) Math.hypot(tx - x, ty - y);
}
private List<Node> availableNeighbours(Node current) {
List<Node> neighbours = new LinkedList<>();
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
if (dx == 0 && dy == 0)
continue;
// determine the location of the neighbour and evaluate it
int xp = current.getX() + dx;
int yp = current.getY() + dy;
// validate out of bounds
if ((xp < 0) || (yp < 0) || (xp >= width()) || (yp >= height()))
continue;
neighbours.add(nodes[xp][yp]);
}
}
// możliwe czekanie <SUF>
neighbours.add(nodes[current.getX()][current.getY()]);
return neighbours;
}
}
| t |
10061_0 | iknuwb/mobiUwB-android | 887 | app/src/main/java/pl/edu/uwb/mobiuwb/view/settings/adapter/items/Item.java | package pl.edu.uwb.mobiuwb.view.settings.adapter.items;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ExpandableListView;
import pl.edu.uwb.mobiuwb.R;
import pl.edu.uwb.mobiuwb.view.settings.adapter.SettingsAdapter;
/**
* Jest to abstrakcyjna reprezentacja kontrolki na liście kontrolek w
* ekranie Opcji/Ustawień.
*/
public abstract class Item<TItemModel extends ItemModel>
{
/**
* Model tej kontrolki.
*/
public TItemModel model;
/**
* Nadaje zmienne.
* @param model Model tej kontrolki.
*/
protected Item(TItemModel model)
{
this.model = model;
}
/**
* Wywoływane gdy kontrolka listy żąda utworzenia jej elementów.
* Wywołuje metodę, która jest implementowana przez podklasy a polega
* ona na skonfigurowaniu nowo generowanego elementu.
* Wykorzystuje ona ID definicji widoku pobrane z modelu elementu.
* @param groupPosition Pozycja grupy.
* @param convertView Widok.
* @param parent Rodzic kontrolki.
* @return Utworzona kontrolka.
*/
public View getGroupView(int groupPosition, View convertView, ViewGroup parent)
{
if (convertView == null)
{
convertView = LayoutInflater.from(
parent.getContext()).inflate(
model.getLayout(), parent, false);
}
configureGroupView(groupPosition, convertView, parent);
return convertView;
}
/**
* Wywoływane gdy kontrolka listy żąda utworzenia jej elementu dziecka.
* Dzieckiem jest tutaj grupa kontrolek, zagnieżdżonych rekurencyjnie.
* Reprezentacją tych kontrolek jest właśnie ta klasa.
* @param convertView Widok.
* @param parent Rodzic kontrolki.
* @return Utworzona kontrolka.
*/
public View getChildView(View convertView, ViewGroup parent)
{
if (convertView == null)
{
convertView = LayoutInflater.from(
parent.getContext()).inflate(
R.layout.settings_listview_child, parent, false);
ExpandableListView viewExpandableListView =
(ExpandableListView) convertView.findViewById(R.id.ChildListView);
SettingsAdapter settingsAdapter = new SettingsAdapter(model);
//viewExpandableListView.setPadding(UnitConverter.toDpi(30), 0, 0, 0);
viewExpandableListView.setAdapter(settingsAdapter);
}
return convertView;
}
/**
* Metoda ta polega na skonfigurowaniu nowo generowanego elementu
* widoku.
* @param groupPosition Pozycja grupy.
* @param convertView Widok.
* @param parent Rodzic kontrolki.
*/
protected abstract void configureGroupView(int groupPosition, View convertView,
ViewGroup parent);
}
| /**
* Jest to abstrakcyjna reprezentacja kontrolki na liście kontrolek w
* ekranie Opcji/Ustawień.
*/ | package pl.edu.uwb.mobiuwb.view.settings.adapter.items;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ExpandableListView;
import pl.edu.uwb.mobiuwb.R;
import pl.edu.uwb.mobiuwb.view.settings.adapter.SettingsAdapter;
/**
* Jest to abstrakcyjna <SUF>*/
public abstract class Item<TItemModel extends ItemModel>
{
/**
* Model tej kontrolki.
*/
public TItemModel model;
/**
* Nadaje zmienne.
* @param model Model tej kontrolki.
*/
protected Item(TItemModel model)
{
this.model = model;
}
/**
* Wywoływane gdy kontrolka listy żąda utworzenia jej elementów.
* Wywołuje metodę, która jest implementowana przez podklasy a polega
* ona na skonfigurowaniu nowo generowanego elementu.
* Wykorzystuje ona ID definicji widoku pobrane z modelu elementu.
* @param groupPosition Pozycja grupy.
* @param convertView Widok.
* @param parent Rodzic kontrolki.
* @return Utworzona kontrolka.
*/
public View getGroupView(int groupPosition, View convertView, ViewGroup parent)
{
if (convertView == null)
{
convertView = LayoutInflater.from(
parent.getContext()).inflate(
model.getLayout(), parent, false);
}
configureGroupView(groupPosition, convertView, parent);
return convertView;
}
/**
* Wywoływane gdy kontrolka listy żąda utworzenia jej elementu dziecka.
* Dzieckiem jest tutaj grupa kontrolek, zagnieżdżonych rekurencyjnie.
* Reprezentacją tych kontrolek jest właśnie ta klasa.
* @param convertView Widok.
* @param parent Rodzic kontrolki.
* @return Utworzona kontrolka.
*/
public View getChildView(View convertView, ViewGroup parent)
{
if (convertView == null)
{
convertView = LayoutInflater.from(
parent.getContext()).inflate(
R.layout.settings_listview_child, parent, false);
ExpandableListView viewExpandableListView =
(ExpandableListView) convertView.findViewById(R.id.ChildListView);
SettingsAdapter settingsAdapter = new SettingsAdapter(model);
//viewExpandableListView.setPadding(UnitConverter.toDpi(30), 0, 0, 0);
viewExpandableListView.setAdapter(settingsAdapter);
}
return convertView;
}
/**
* Metoda ta polega na skonfigurowaniu nowo generowanego elementu
* widoku.
* @param groupPosition Pozycja grupy.
* @param convertView Widok.
* @param parent Rodzic kontrolki.
*/
protected abstract void configureGroupView(int groupPosition, View convertView,
ViewGroup parent);
}
| t |
6535_2 | ikurek/PWr-App | 318 | app/src/main/java/com/ikurek/pwr/ParsedWebData.java | package com.ikurek.pwr;
import java.util.Date;
/**
* Created by Igor on 03.09.2016.
*/
//Klasa zawiera informacje przekazane przez parser
//Zrobiłem to , żeby łatwo można było przechwytywać całe zestawy danych ze strony
public class ParsedWebData {
String title;
String url;
String description;
String source;
//date zawiera datę w formacie UNIXa
//dateString zawiera datę w użytkowym formacie jako string
Date date;
String dateString;
public ParsedWebData() {
}
public String getTitle() {
return title;
}
public String getUrl() {
return url;
}
public String getDescription() {
return description;
}
public Date getDate() {
return date;
}
public String getDateString() {
return dateString;
}
public String getSource() {
return source;
}
}
| //Zrobiłem to , żeby łatwo można było przechwytywać całe zestawy danych ze strony
| package com.ikurek.pwr;
import java.util.Date;
/**
* Created by Igor on 03.09.2016.
*/
//Klasa zawiera informacje przekazane przez parser
//Zrobiłem to <SUF>
public class ParsedWebData {
String title;
String url;
String description;
String source;
//date zawiera datę w formacie UNIXa
//dateString zawiera datę w użytkowym formacie jako string
Date date;
String dateString;
public ParsedWebData() {
}
public String getTitle() {
return title;
}
public String getUrl() {
return url;
}
public String getDescription() {
return description;
}
public Date getDate() {
return date;
}
public String getDateString() {
return dateString;
}
public String getSource() {
return source;
}
}
| t |
6746_2 | infokomes/smart-forklift | 414 | src/sample/Genetic/FitnessCalc.java | package sample.Genetic;
public class FitnessCalc {
static byte[] solution = new byte[11];
// Ustaw rozwiązanie
public static void setSolution(byte[] newSolution) {
solution = newSolution;
}
public static byte[] getSolution() {
return solution;
}
// Ustaw rozwiązanie ze stringa zer i jedynek.
static void setSolution(String newSolution) {
solution = new byte[newSolution.length()];
// Loop through each character of our string and save it in our byte
// array
for (int i = 0; i < newSolution.length(); i++) {
String character = newSolution.substring(i, i + 1);
if (character.contains("0") || character.contains("1")) {
solution[i] = Byte.parseByte(character);
} else {
solution[i] = 0;
}
}
}
// Dla danego osobnika sprawdź jego przystosowanie w stosunku do rozwiązania
static int getFitness(Individual individual) {
int fitness = 0;
for (int i = 0; i < individual.size() && i < solution.length; i++) {
if (individual.getGene(i) == solution[i]) {
fitness++;
}
}
return fitness;
}
// Zwróć max dopasowanie
static int getMaxFitness() {
int maxFitness = solution.length;
return maxFitness;
}
} | // Dla danego osobnika sprawdź jego przystosowanie w stosunku do rozwiązania | package sample.Genetic;
public class FitnessCalc {
static byte[] solution = new byte[11];
// Ustaw rozwiązanie
public static void setSolution(byte[] newSolution) {
solution = newSolution;
}
public static byte[] getSolution() {
return solution;
}
// Ustaw rozwiązanie ze stringa zer i jedynek.
static void setSolution(String newSolution) {
solution = new byte[newSolution.length()];
// Loop through each character of our string and save it in our byte
// array
for (int i = 0; i < newSolution.length(); i++) {
String character = newSolution.substring(i, i + 1);
if (character.contains("0") || character.contains("1")) {
solution[i] = Byte.parseByte(character);
} else {
solution[i] = 0;
}
}
}
// Dla danego <SUF>
static int getFitness(Individual individual) {
int fitness = 0;
for (int i = 0; i < individual.size() && i < solution.length; i++) {
if (individual.getGene(i) == solution[i]) {
fitness++;
}
}
return fitness;
}
// Zwróć max dopasowanie
static int getMaxFitness() {
int maxFitness = solution.length;
return maxFitness;
}
} | t |
7699_0 | infoshareacademy/jjdz-autoparts | 641 | App/src/main/java/javatar/web/BrandsChoosingServlet.java | package javatar.web;
import javatar.model.CarsBrands;
import javatar.model.FormData;
import javatar.model.FormPartCategories;
import org.slf4j.LoggerFactory;
import javax.ejb.EJB;
import javax.inject.Inject;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collection;
@WebServlet(urlPatterns = "/Brands")
public class BrandsChoosingServlet extends HttpServlet {
private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(BrandsChoosingServlet.class);
@EJB
BrandsJsonCache cache;
@Inject
SessionData sessionData;
@Inject
FormData formData;
@Inject
FormPartCategories formPartCategories;
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
Collection<CarsBrands> carsBrandsCollection = cache.returnBrandsCollection();
/*
* odkomentowac, żeby pokazać, że działa obsługa błędów
* carsBrandsCollection = null;
*/
formData = new FormData();
formPartCategories.setPartCategories(null);
sessionData.setErrorMessage(null);
sessionData.setWarningMessage(null);
if (carsBrandsCollection == null || carsBrandsCollection.isEmpty()) {
sessionData.setErrorMessage("BŁĄD! Brak marek samochodowych do wyświetlenia!");
LOGGER.error(sessionData.getErrorMessage());
}
req.setAttribute("errorMessage", sessionData.getErrorMessage());
req.setAttribute("warningMessage", sessionData.getWarningMessage());
req.setAttribute("brands", carsBrandsCollection);
//zakomentować loggera, przed pokazywaniem obslugi bledow
LOGGER.info("carsBransdCollection has size: {}", carsBrandsCollection.size());
RequestDispatcher dispatcher = req.getRequestDispatcher("CarBranchChoosingForm.jsp");
dispatcher.forward(req, resp);
}
}
| /*
* odkomentowac, żeby pokazać, że działa obsługa błędów
* carsBrandsCollection = null;
*/ | package javatar.web;
import javatar.model.CarsBrands;
import javatar.model.FormData;
import javatar.model.FormPartCategories;
import org.slf4j.LoggerFactory;
import javax.ejb.EJB;
import javax.inject.Inject;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collection;
@WebServlet(urlPatterns = "/Brands")
public class BrandsChoosingServlet extends HttpServlet {
private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(BrandsChoosingServlet.class);
@EJB
BrandsJsonCache cache;
@Inject
SessionData sessionData;
@Inject
FormData formData;
@Inject
FormPartCategories formPartCategories;
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
Collection<CarsBrands> carsBrandsCollection = cache.returnBrandsCollection();
/*
* odkomentowac, żeby pokazać, <SUF>*/
formData = new FormData();
formPartCategories.setPartCategories(null);
sessionData.setErrorMessage(null);
sessionData.setWarningMessage(null);
if (carsBrandsCollection == null || carsBrandsCollection.isEmpty()) {
sessionData.setErrorMessage("BŁĄD! Brak marek samochodowych do wyświetlenia!");
LOGGER.error(sessionData.getErrorMessage());
}
req.setAttribute("errorMessage", sessionData.getErrorMessage());
req.setAttribute("warningMessage", sessionData.getWarningMessage());
req.setAttribute("brands", carsBrandsCollection);
//zakomentować loggera, przed pokazywaniem obslugi bledow
LOGGER.info("carsBransdCollection has size: {}", carsBrandsCollection.size());
RequestDispatcher dispatcher = req.getRequestDispatcher("CarBranchChoosingForm.jsp");
dispatcher.forward(req, resp);
}
}
| t |
7643_1 | infoshareacademy/jjdz5-cm3 | 729 | console-app/src/main/java/com/isa/cm3/menu/MenuDelegation.java | package com.isa.cm3.menu;
import com.isa.cm3.console.ConsoleClearScreen;
import com.isa.cm3.console.ConsolePrinter;
import com.isa.cm3.delegations.DelegationAdd;
import com.isa.cm3.delegations.DelegationChangeStatus;
import com.isa.cm3.delegations.DelegationPreview;
public class MenuDelegation extends Menu {
private ConsolePrinter consolePrinter = new ConsolePrinter();
private DelegationAdd addDelegationService = new DelegationAdd();
private DelegationChangeStatus delegationChangeStatus = new DelegationChangeStatus();
private DelegationPreview previewDelegation = new DelegationPreview();
private ConsoleClearScreen consoleClearScreen = new ConsoleClearScreen();
/*
* Dodaj poniżej kolejny punkt menu dodając kolejną linię i odpowiedni kolejny numer
*
* !!!! Pamiętaj aby ddoać wpis w metodzie goMenu
*
* */
public MenuDelegation() {
}
@Override
public void showMenu() {
consolePrinter.printLine("================================");
consolePrinter.printLine("= MENU DELEGACJE =");
consolePrinter.printLine("================================");
consolePrinter.printLine("Wybierz liczbę żeby wejść w:");
consolePrinter.printLine("| 1. Dodaj delegację" );
consolePrinter.printLine("| 2. Wyświetl delegacje ");
consolePrinter.printLine("| 3. Zaakceptuj lub odrzuć delegację");
consolePrinter.printLine("| 9. Powrót do głównego Menu");
consolePrinter.printLine("| 0. wyjście z programu");
goMenu(isChoiceNumber());
}
/*metoda sprawdza jak liczba z menu została wybrana i tworzy odpowiedni obiekt w zależności od wyboru */
@Override
public void goMenu(int userChoice) {
while (userChoice != 1 && userChoice != 2 && userChoice != 3 && userChoice != 0 && userChoice != 9) {
consolePrinter.printLine("| Wybór spoza zakresu. Wybierz jeszcze raz");
userChoice = isChoiceNumber();
}
switch (userChoice) {
case 1:
addDelegationService.delegationAdd();
break;
case 2:
previewDelegation.delegationPreview(1);
break;
case 3:
delegationChangeStatus.delegationChangeStatus();
break;
default:
outOfProgramAndMainMenu(userChoice);
break;
}
showMenu();
}
}
| /*metoda sprawdza jak liczba z menu została wybrana i tworzy odpowiedni obiekt w zależności od wyboru */ | package com.isa.cm3.menu;
import com.isa.cm3.console.ConsoleClearScreen;
import com.isa.cm3.console.ConsolePrinter;
import com.isa.cm3.delegations.DelegationAdd;
import com.isa.cm3.delegations.DelegationChangeStatus;
import com.isa.cm3.delegations.DelegationPreview;
public class MenuDelegation extends Menu {
private ConsolePrinter consolePrinter = new ConsolePrinter();
private DelegationAdd addDelegationService = new DelegationAdd();
private DelegationChangeStatus delegationChangeStatus = new DelegationChangeStatus();
private DelegationPreview previewDelegation = new DelegationPreview();
private ConsoleClearScreen consoleClearScreen = new ConsoleClearScreen();
/*
* Dodaj poniżej kolejny punkt menu dodając kolejną linię i odpowiedni kolejny numer
*
* !!!! Pamiętaj aby ddoać wpis w metodzie goMenu
*
* */
public MenuDelegation() {
}
@Override
public void showMenu() {
consolePrinter.printLine("================================");
consolePrinter.printLine("= MENU DELEGACJE =");
consolePrinter.printLine("================================");
consolePrinter.printLine("Wybierz liczbę żeby wejść w:");
consolePrinter.printLine("| 1. Dodaj delegację" );
consolePrinter.printLine("| 2. Wyświetl delegacje ");
consolePrinter.printLine("| 3. Zaakceptuj lub odrzuć delegację");
consolePrinter.printLine("| 9. Powrót do głównego Menu");
consolePrinter.printLine("| 0. wyjście z programu");
goMenu(isChoiceNumber());
}
/*metoda sprawdza jak <SUF>*/
@Override
public void goMenu(int userChoice) {
while (userChoice != 1 && userChoice != 2 && userChoice != 3 && userChoice != 0 && userChoice != 9) {
consolePrinter.printLine("| Wybór spoza zakresu. Wybierz jeszcze raz");
userChoice = isChoiceNumber();
}
switch (userChoice) {
case 1:
addDelegationService.delegationAdd();
break;
case 2:
previewDelegation.delegationPreview(1);
break;
case 3:
delegationChangeStatus.delegationChangeStatus();
break;
default:
outOfProgramAndMainMenu(userChoice);
break;
}
showMenu();
}
}
| t |
3806_6 | infoshareacademy/jjdzr14-Bankersi2k24 | 1,122 | Bankesi2k24/src/main/java/pl/isa/view/WelcomeScreen.java | package pl.isa.view;
import java.util.Scanner;
//jira task: https://jira.is-academy.pl/browse/JJDZR14BA-3
public class WelcomeScreen {
private String login;
private String password;
private String name;
private String lastName;
private String regLogin;
private String regPassword;
public String getRegLogin() {
return regLogin;
}
public void setRegLogin(String regLogin) {
this.regLogin = regLogin;
}
public String getRegPassword() {
return regPassword;
}
public void setRegPassword(String regPassword) {
this.regPassword = regPassword;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public void loginScreen() {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter your login..");
setLogin(scanner.next());
System.out.println("Enter your password..");
setPassword(scanner.next());
if (checkloginScreen(getRegLogin(), getRegPassword())) {
System.out.println("Login success");
} else {
System.out.println("Invalid login or password");
return;
}
System.out.println("Welcome!!! " + getLogin());
} // Zaloguj -> podaj login, haslo z zawartą metodą checkloginScreen
public void registrationScreen() {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter your name...");
setName(scanner.next());
System.out.println("Enter your last name...");
setLastName(scanner.next());
// if (getName().length() == 0 || getLastName().length() == 0) {
// System.out.println("Why empty phrases? Please, try again");
// } NIE WIEM DLACZEGO ALE TO NIE DZIAŁA;/
if (specialCharacters(getName()) || badNumbers(getName()) || specialCharacters(getLastName()) || badNumbers(getLastName())) {
System.out.println("Invalid input. Please enter only letters.");
return;
}
System.out.println("Enter your new login...");
setRegLogin(scanner.next());
System.out.println("Enter your new password...");
setRegPassword(scanner.next());
System.out.println("New user:" + getName().toUpperCase() + " " + getLastName().toUpperCase());
} // Zarejestuj -> Imie, nazwisko, login, hasło. Tutaj mam problem z IF.
public boolean specialCharacters(String special) {
String specialCharacters = "!@#$%^&*()_+-=[]{}|;':,.<>?";
for (char s : special.toCharArray()) {
if (specialCharacters.contains(String.valueOf(s))) {
return true;
}
}
return false;
} // Walidacja danych logowania -> Unikanie znaków specjalnych dla imienia i nazwisko,
public boolean badNumbers(String numbers) {
for (char n : numbers.toCharArray()) {
if (Character.isDigit(n)) {
return true;
}
}
return false;
} // Walidacja danych logowania -> Unikanie cyfr dla imienia i nazwisko, imię i nazwisko nie może być puste
public boolean checkloginScreen(String regLogin, String regPassword) {
if (regLogin.equals(getLogin()) && regPassword.equals(getPassword())) {
return true;
} else {
return false;
}
} // metoda porównuje gety loginu i hasła przy rejestracji z logowaniem
}
| // Walidacja danych logowania -> Unikanie znaków specjalnych dla imienia i nazwisko, | package pl.isa.view;
import java.util.Scanner;
//jira task: https://jira.is-academy.pl/browse/JJDZR14BA-3
public class WelcomeScreen {
private String login;
private String password;
private String name;
private String lastName;
private String regLogin;
private String regPassword;
public String getRegLogin() {
return regLogin;
}
public void setRegLogin(String regLogin) {
this.regLogin = regLogin;
}
public String getRegPassword() {
return regPassword;
}
public void setRegPassword(String regPassword) {
this.regPassword = regPassword;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public void loginScreen() {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter your login..");
setLogin(scanner.next());
System.out.println("Enter your password..");
setPassword(scanner.next());
if (checkloginScreen(getRegLogin(), getRegPassword())) {
System.out.println("Login success");
} else {
System.out.println("Invalid login or password");
return;
}
System.out.println("Welcome!!! " + getLogin());
} // Zaloguj -> podaj login, haslo z zawartą metodą checkloginScreen
public void registrationScreen() {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter your name...");
setName(scanner.next());
System.out.println("Enter your last name...");
setLastName(scanner.next());
// if (getName().length() == 0 || getLastName().length() == 0) {
// System.out.println("Why empty phrases? Please, try again");
// } NIE WIEM DLACZEGO ALE TO NIE DZIAŁA;/
if (specialCharacters(getName()) || badNumbers(getName()) || specialCharacters(getLastName()) || badNumbers(getLastName())) {
System.out.println("Invalid input. Please enter only letters.");
return;
}
System.out.println("Enter your new login...");
setRegLogin(scanner.next());
System.out.println("Enter your new password...");
setRegPassword(scanner.next());
System.out.println("New user:" + getName().toUpperCase() + " " + getLastName().toUpperCase());
} // Zarejestuj -> Imie, nazwisko, login, hasło. Tutaj mam problem z IF.
public boolean specialCharacters(String special) {
String specialCharacters = "!@#$%^&*()_+-=[]{}|;':,.<>?";
for (char s : special.toCharArray()) {
if (specialCharacters.contains(String.valueOf(s))) {
return true;
}
}
return false;
} // Walidacja danych <SUF>
public boolean badNumbers(String numbers) {
for (char n : numbers.toCharArray()) {
if (Character.isDigit(n)) {
return true;
}
}
return false;
} // Walidacja danych logowania -> Unikanie cyfr dla imienia i nazwisko, imię i nazwisko nie może być puste
public boolean checkloginScreen(String regLogin, String regPassword) {
if (regLogin.equals(getLogin()) && regPassword.equals(getPassword())) {
return true;
} else {
return false;
}
} // metoda porównuje gety loginu i hasła przy rejestracji z logowaniem
}
| t |
10310_9 | iruszpel/projekt_wireworld | 1,489 | GUI/SettingsController.java | package GUI;
import WireWorld.Map;
import WireWorld.ReadFromFile;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Slider;
import javafx.scene.control.TextField;
import javafx.scene.image.ImageView;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.AnchorPane;
import java.io.IOException;
public class SettingsController implements GUIController {
private Scene scene;
public static String fileFormat = "ser"; //Default file format
public SettingsController(Scene scene) {
this.scene = scene;
}
@Override
public void enableListeners() {
/*
*Ustawienia wewnątrz okna ustawień
*/
AnchorPane settingsPanel = (AnchorPane) scene.lookup("#settingsBox");
ImageView settingsButton = (ImageView) scene.lookup("#settingsButton");
TextField widthField = (TextField) scene.lookup("#widthField");
TextField heightField = (TextField) scene.lookup("#heightField");
ComboBox fileFormatBox = (ComboBox) scene.lookup("#fileFormatBox");
fileFormatBox.getItems().add("Stan mapy (*.ser)");
fileFormatBox.getItems().add("Obraz (*.png)");
settingsButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
//Init height and width values
widthField.setText(String.valueOf(Main.w));
heightField.setText(String.valueOf(Main.h));
//Init file format
fileFormatBox.getSelectionModel().select(fileFormat == "ser" ? 0 : 1);
settingsPanel.setVisible(true);
event.consume();
});
ImageView settingsCloseButton = (ImageView) scene.lookup("#settingsClose");
settingsCloseButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
settingsPanel.setVisible(false);
event.consume();
});
Button applyButton = (Button) scene.lookup("#applyButton");
applyButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
fileFormat = fileFormatBox.getSelectionModel().getSelectedIndex() == 0 ? "ser" : "png"; //Lepsza mapa jakby więcej formatów było
int selectedHeight = Integer.parseInt(heightField.getText());
int selectedWidth = Integer.parseInt(widthField.getText());
if (Main.h != selectedHeight || Main.w != selectedWidth) {
Map.height = Main.h = selectedHeight;
Map.width = Main.w = selectedWidth;
try {
if (Main.currentFilePath == null){ //Była pusta mapa
IOButtonsController.clearMap();
return;
}
Map.maps.clear();
Map.iteration = -1;
ReadFromFile.read(Main.currentFilePath);
} catch(Exception e) {
System.out.println("Nastąpił błąd przy ponownym wczytywaniu pliku. Sprawdź czy plik wciąż istnieje");
return;
}
Main.generateIterations(Main.howManyIterations);
Main.canvasDrawer.drawIteration(0);
}
settingsPanel.setVisible(false);
event.consume();
});
/*
*Ustawienia poza oknem ustawień
*/
TextField iterationsField = (TextField) scene.lookup("#iterField");
TextField animationSpeedField = (TextField) scene.lookup("#animSpeedField");
//Słuchacze pól tekstowych
iterationsField.focusedProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal) { //Unfocused
int newIterations = iterationsField.getText().equals("") ? 0 : Integer.parseInt(iterationsField.getText());
if (Map.maps.size() - 1 < newIterations){
Main.generateIterations(newIterations - Main.howManyIterations);
}
Main.howManyIterations = newIterations;
Main.currentIteration = 0;
//Update slider
Slider iterSlider = (Slider) scene.lookup("#iterSlider");
iterSlider.setMax(Main.howManyIterations);
iterSlider.setValue(0);
iterSlider.setMajorTickUnit(Main.howManyIterations/5);
//Reset current iterations
Main.canvasDrawer.drawIteration(0);
}
});
animationSpeedField.focusedProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal) { //Unfocused
Main.animationSpeed = animationSpeedField.getText().equals("") ? 1 : Integer.parseInt(animationSpeedField.getText());
}
});
//Ograniczenie tylko do wpisywania liczb w obu polach (można też zrobić klase NumberField która by rozszerzała TextField i przyjmowała tylko liczby):
iterationsField.textProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal.matches("\\d*")) {
iterationsField.setText(newVal.replaceAll("[^\\d]", ""));
}
});
animationSpeedField.textProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal.matches("\\d*")) {
animationSpeedField.setText(newVal.replaceAll("[^\\d]", ""));
}
});
//Wpisanie w nie domyślnych ustawień
iterationsField.setText(Integer.toString(Main.howManyIterations));
animationSpeedField.setText(Integer.toString(Main.animationSpeed));
}
}
| //Ograniczenie tylko do wpisywania liczb w obu polach (można też zrobić klase NumberField która by rozszerzała TextField i przyjmowała tylko liczby): | package GUI;
import WireWorld.Map;
import WireWorld.ReadFromFile;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Slider;
import javafx.scene.control.TextField;
import javafx.scene.image.ImageView;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.AnchorPane;
import java.io.IOException;
public class SettingsController implements GUIController {
private Scene scene;
public static String fileFormat = "ser"; //Default file format
public SettingsController(Scene scene) {
this.scene = scene;
}
@Override
public void enableListeners() {
/*
*Ustawienia wewnątrz okna ustawień
*/
AnchorPane settingsPanel = (AnchorPane) scene.lookup("#settingsBox");
ImageView settingsButton = (ImageView) scene.lookup("#settingsButton");
TextField widthField = (TextField) scene.lookup("#widthField");
TextField heightField = (TextField) scene.lookup("#heightField");
ComboBox fileFormatBox = (ComboBox) scene.lookup("#fileFormatBox");
fileFormatBox.getItems().add("Stan mapy (*.ser)");
fileFormatBox.getItems().add("Obraz (*.png)");
settingsButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
//Init height and width values
widthField.setText(String.valueOf(Main.w));
heightField.setText(String.valueOf(Main.h));
//Init file format
fileFormatBox.getSelectionModel().select(fileFormat == "ser" ? 0 : 1);
settingsPanel.setVisible(true);
event.consume();
});
ImageView settingsCloseButton = (ImageView) scene.lookup("#settingsClose");
settingsCloseButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
settingsPanel.setVisible(false);
event.consume();
});
Button applyButton = (Button) scene.lookup("#applyButton");
applyButton.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
fileFormat = fileFormatBox.getSelectionModel().getSelectedIndex() == 0 ? "ser" : "png"; //Lepsza mapa jakby więcej formatów było
int selectedHeight = Integer.parseInt(heightField.getText());
int selectedWidth = Integer.parseInt(widthField.getText());
if (Main.h != selectedHeight || Main.w != selectedWidth) {
Map.height = Main.h = selectedHeight;
Map.width = Main.w = selectedWidth;
try {
if (Main.currentFilePath == null){ //Była pusta mapa
IOButtonsController.clearMap();
return;
}
Map.maps.clear();
Map.iteration = -1;
ReadFromFile.read(Main.currentFilePath);
} catch(Exception e) {
System.out.println("Nastąpił błąd przy ponownym wczytywaniu pliku. Sprawdź czy plik wciąż istnieje");
return;
}
Main.generateIterations(Main.howManyIterations);
Main.canvasDrawer.drawIteration(0);
}
settingsPanel.setVisible(false);
event.consume();
});
/*
*Ustawienia poza oknem ustawień
*/
TextField iterationsField = (TextField) scene.lookup("#iterField");
TextField animationSpeedField = (TextField) scene.lookup("#animSpeedField");
//Słuchacze pól tekstowych
iterationsField.focusedProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal) { //Unfocused
int newIterations = iterationsField.getText().equals("") ? 0 : Integer.parseInt(iterationsField.getText());
if (Map.maps.size() - 1 < newIterations){
Main.generateIterations(newIterations - Main.howManyIterations);
}
Main.howManyIterations = newIterations;
Main.currentIteration = 0;
//Update slider
Slider iterSlider = (Slider) scene.lookup("#iterSlider");
iterSlider.setMax(Main.howManyIterations);
iterSlider.setValue(0);
iterSlider.setMajorTickUnit(Main.howManyIterations/5);
//Reset current iterations
Main.canvasDrawer.drawIteration(0);
}
});
animationSpeedField.focusedProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal) { //Unfocused
Main.animationSpeed = animationSpeedField.getText().equals("") ? 1 : Integer.parseInt(animationSpeedField.getText());
}
});
//Ograniczenie tylko <SUF>
iterationsField.textProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal.matches("\\d*")) {
iterationsField.setText(newVal.replaceAll("[^\\d]", ""));
}
});
animationSpeedField.textProperty().addListener((obs, oldVal, newVal) -> {
if (!newVal.matches("\\d*")) {
animationSpeedField.setText(newVal.replaceAll("[^\\d]", ""));
}
});
//Wpisanie w nie domyślnych ustawień
iterationsField.setText(Integer.toString(Main.howManyIterations));
animationSpeedField.setText(Integer.toString(Main.animationSpeed));
}
}
| t |
3929_0 | itischrisd/itis-ASD | 941 | src/Sort/Selection.java | package Sort;
public class Selection {
public static void sort(int[] arr, int len) {
int i = 0; // 1
while (i < len) { // n
int min = indexOfMin(arr, i, len); // n
swap(arr, i, min); // n
i++; // n
}
}
private static int indexOfMin(int[] arr, int i, int len) {
int min = i; // 1
while (i < len) { // n
if (arr[min] > arr[i]) // n
min = i; // n
i++; // n
}
return min; // 1
}
private static void swap(int[] arr, int i1, int i2) {
int temp = arr[i1]; // 1
arr[i1] = arr[i2]; // 1
arr[i2] = temp; // 1
}
}
/*
ZŁOŻONOŚĆ
O.D.: porównanie dwóch elementów ciągu
R.D.: długość ciągu arr
W(n) = O(n^2)
A(n) = O(n^2)
S(n) = O(1)
POPRAWNOŚĆ
Właśność stopu: algorytm zatrzyma się, gdy i == len, i w każdej iteracji zwiększane jest o 1, len jest skończoną,
stałą liczbą naturalną. Stąd wartość len zostanie osiągnięta przez i w skończonej liczbie iteracji.
Poprawność częściowa:
Niezmiennik pętli: Po i-tej iteracji pętli zewnętrznej, najmniejsze i elementów tablicy znajduje się w posortowanym
podciągu arr[0:i].
1. Krok bazowy.
Przed pierwszą iteracją pętli zewnętrznej, i = 0. Na tym etapie tablica nie jest jeszcze posortowana, więc w
arr[0:0] znajduje się 0 najmniejszych elementów.
2. Założenie indukcyjne.
Załóżmy, że po k-tej iteracji pętli zewnętrznej, najmniejsze k elementów tablicy znajduje się na pozycjach arr[0] do
arr[k-1] w kolejności niemalejącej.
3. Krok indukcyjny.
Teza indukcyjna:
Po (k+1)-ej iteracji pętli zewnętrznej, najmniejsze k+1 elementów tablicy znajduje się na pozycjach arr[0] do
arr[k] w kolejności niemalejącej.
Dowód indukcyjny:
Po (k+1)-ej iteracji pętli zewnętrznej, należy znaleźć najmniejszy element spośród arr[k+1:len) elementów. Wykonując
operację swap(arr, i, min), znaleziony element zostanie przeniesiony na pozycję arr[i], a element na pozycji arr[i]
zostanie przeniesiony na pozycję min. Zgodnie z założeniem indukcyjnym, najmniejsze k elementów znajduje się na
pozycjach arr[0] do arr[k-1], więc również najmniejsze k+1 elementów znajdzie się na odpowiednich pozycjach. Dowodzi
to poprawności częściowej algorytmu.
*/ | /*
ZŁOŻONOŚĆ
O.D.: porównanie dwóch elementów ciągu
R.D.: długość ciągu arr
W(n) = O(n^2)
A(n) = O(n^2)
S(n) = O(1)
POPRAWNOŚĆ
Właśność stopu: algorytm zatrzyma się, gdy i == len, i w każdej iteracji zwiększane jest o 1, len jest skończoną,
stałą liczbą naturalną. Stąd wartość len zostanie osiągnięta przez i w skończonej liczbie iteracji.
Poprawność częściowa:
Niezmiennik pętli: Po i-tej iteracji pętli zewnętrznej, najmniejsze i elementów tablicy znajduje się w posortowanym
podciągu arr[0:i].
1. Krok bazowy.
Przed pierwszą iteracją pętli zewnętrznej, i = 0. Na tym etapie tablica nie jest jeszcze posortowana, więc w
arr[0:0] znajduje się 0 najmniejszych elementów.
2. Założenie indukcyjne.
Załóżmy, że po k-tej iteracji pętli zewnętrznej, najmniejsze k elementów tablicy znajduje się na pozycjach arr[0] do
arr[k-1] w kolejności niemalejącej.
3. Krok indukcyjny.
Teza indukcyjna:
Po (k+1)-ej iteracji pętli zewnętrznej, najmniejsze k+1 elementów tablicy znajduje się na pozycjach arr[0] do
arr[k] w kolejności niemalejącej.
Dowód indukcyjny:
Po (k+1)-ej iteracji pętli zewnętrznej, należy znaleźć najmniejszy element spośród arr[k+1:len) elementów. Wykonując
operację swap(arr, i, min), znaleziony element zostanie przeniesiony na pozycję arr[i], a element na pozycji arr[i]
zostanie przeniesiony na pozycję min. Zgodnie z założeniem indukcyjnym, najmniejsze k elementów znajduje się na
pozycjach arr[0] do arr[k-1], więc również najmniejsze k+1 elementów znajdzie się na odpowiednich pozycjach. Dowodzi
to poprawności częściowej algorytmu.
*/ | package Sort;
public class Selection {
public static void sort(int[] arr, int len) {
int i = 0; // 1
while (i < len) { // n
int min = indexOfMin(arr, i, len); // n
swap(arr, i, min); // n
i++; // n
}
}
private static int indexOfMin(int[] arr, int i, int len) {
int min = i; // 1
while (i < len) { // n
if (arr[min] > arr[i]) // n
min = i; // n
i++; // n
}
return min; // 1
}
private static void swap(int[] arr, int i1, int i2) {
int temp = arr[i1]; // 1
arr[i1] = arr[i2]; // 1
arr[i2] = temp; // 1
}
}
/*
ZŁOŻONOŚĆ
<SUF>*/ | t |
6895_18 | itischrisd/itis-UTP | 1,341 | SDKP03/src/zad3/Main.java | /**
*
* @author Dudek Krzysztof S25692
*
*/
package zad3;
import java.util.*;
// Plik Main.java może być dowolnie modyfikowany,
// ale punkty uzyskuje się za właściwe dzialanie poszczególnych pokazanych tu metod klasy XList.
// Jeżeli nie oprogramujemy wszystkich metod, to z klasy Main nalezy usunąć te fragmenty,
// które powodują błędy w kompilacji - w przeciwnym razie nie uzyskamy punktów.
public class Main {
public static void main(String[] args) {
// Pewne dodatkowe zestawy danych
Integer[] ints = { 100, 200, 300 };
Set<Integer> set = new HashSet<>(Arrays.asList(3, 4, 5));
// Sposoby tworzenia
XList<Integer> list1 = new XList<>(1, 3, 9, 11);
XList<Integer> list2 = XList.of(5, 6, 9);
XList<Integer> list3 = new XList(ints);
XList<Integer> list4 = XList.of(ints);
XList<Integer> list5 = new XList(set);
XList<Integer> list6 = XList.of(set);
System.out.println(list1);
System.out.println(list2);
System.out.println(list3);
System.out.println(list4);
System.out.println(list5);
System.out.println(list6);
// --- i pomocnicze metody do tworzenia z napisów
XList<String> slist1 = XList.charsOf("ala ma kota");
XList<String> slist2 = XList.tokensOf("ala ma kota");
XList<String> slist3 = XList.tokensOf("A-B-C", "-");
System.out.println(slist1);
System.out.println(slist2);
System.out.println(slist3);
// Metoda union - suma elementów
List<Integer> m1 = list1.union(list2); // oczywiście, można podstawiać na List
System.out.println(m1);
// można wykonywać wszystkie operacje z interfejsu List, np:
m1.add(11);
System.out.println(m1);
XList<Integer> m2 = (XList<Integer>) m1;
XList<Integer> m3 = m2.union(ints).union(XList.of(4, 4));
System.out.println(m2); // m2 się nie zmienia
System.out.println(m3); // wynik jest w m3
m3 = m3.union(set);
System.out.println(m3);
// Widzieliśmy metode union
// Teraz metoda diff(dowolna kolekcja)
System.out.println(m3.diff(set)); // wszystko z m3, co nie jest w set
System.out.println(XList.of(set).diff(m3)); // co jest w set, czego nie ma w m3
// Metoda unique -zwraca nową Xlist bez duplikatow
XList<Integer> uniq = m3.unique(); // lista, nie Set
System.out.println(uniq);
// kombinacje (kolejność jest istotna)
List<String> sa = Arrays.asList( "a", "b");
List<String> sb = Arrays.asList( "X", "Y", "Z" );
XList<String> sc = XList.charsOf( "12" );
XList toCombine = XList.of(sa, sb, sc);
System.out.println(toCombine);
XList<XList<String>> cres = toCombine.combine();
System.out.println(cres);
// collect i join
XList<String> j1 = cres.collect( list -> list.join());
System.out.println(j1.join(" "));
XList<String> j2 =cres.collect( list -> list.join("-"));
System.out.println(j2.join(" "));
// forEachWithIndex
XList<Integer> lmod = XList.of(1,2,8, 10, 11, 30, 3, 4);
lmod.forEachWithIndex( (e, i) -> lmod.set(i, e*2));
System.out.println(lmod);
lmod.forEachWithIndex( (e, i) -> { if (i % 2 == 0) lmod.remove(e); } );
System.out.println(lmod);
lmod.forEachWithIndex( (e, i) -> { if (i % 2 == 0) lmod.remove(i); } );
System.out.println(lmod); // Pytanie: dlaczego mamy taki efekt?
}
}
| // kombinacje (kolejność jest istotna) | /**
*
* @author Dudek Krzysztof S25692
*
*/
package zad3;
import java.util.*;
// Plik Main.java może być dowolnie modyfikowany,
// ale punkty uzyskuje się za właściwe dzialanie poszczególnych pokazanych tu metod klasy XList.
// Jeżeli nie oprogramujemy wszystkich metod, to z klasy Main nalezy usunąć te fragmenty,
// które powodują błędy w kompilacji - w przeciwnym razie nie uzyskamy punktów.
public class Main {
public static void main(String[] args) {
// Pewne dodatkowe zestawy danych
Integer[] ints = { 100, 200, 300 };
Set<Integer> set = new HashSet<>(Arrays.asList(3, 4, 5));
// Sposoby tworzenia
XList<Integer> list1 = new XList<>(1, 3, 9, 11);
XList<Integer> list2 = XList.of(5, 6, 9);
XList<Integer> list3 = new XList(ints);
XList<Integer> list4 = XList.of(ints);
XList<Integer> list5 = new XList(set);
XList<Integer> list6 = XList.of(set);
System.out.println(list1);
System.out.println(list2);
System.out.println(list3);
System.out.println(list4);
System.out.println(list5);
System.out.println(list6);
// --- i pomocnicze metody do tworzenia z napisów
XList<String> slist1 = XList.charsOf("ala ma kota");
XList<String> slist2 = XList.tokensOf("ala ma kota");
XList<String> slist3 = XList.tokensOf("A-B-C", "-");
System.out.println(slist1);
System.out.println(slist2);
System.out.println(slist3);
// Metoda union - suma elementów
List<Integer> m1 = list1.union(list2); // oczywiście, można podstawiać na List
System.out.println(m1);
// można wykonywać wszystkie operacje z interfejsu List, np:
m1.add(11);
System.out.println(m1);
XList<Integer> m2 = (XList<Integer>) m1;
XList<Integer> m3 = m2.union(ints).union(XList.of(4, 4));
System.out.println(m2); // m2 się nie zmienia
System.out.println(m3); // wynik jest w m3
m3 = m3.union(set);
System.out.println(m3);
// Widzieliśmy metode union
// Teraz metoda diff(dowolna kolekcja)
System.out.println(m3.diff(set)); // wszystko z m3, co nie jest w set
System.out.println(XList.of(set).diff(m3)); // co jest w set, czego nie ma w m3
// Metoda unique -zwraca nową Xlist bez duplikatow
XList<Integer> uniq = m3.unique(); // lista, nie Set
System.out.println(uniq);
// kombinacje (kolejność <SUF>
List<String> sa = Arrays.asList( "a", "b");
List<String> sb = Arrays.asList( "X", "Y", "Z" );
XList<String> sc = XList.charsOf( "12" );
XList toCombine = XList.of(sa, sb, sc);
System.out.println(toCombine);
XList<XList<String>> cres = toCombine.combine();
System.out.println(cres);
// collect i join
XList<String> j1 = cres.collect( list -> list.join());
System.out.println(j1.join(" "));
XList<String> j2 =cres.collect( list -> list.join("-"));
System.out.println(j2.join(" "));
// forEachWithIndex
XList<Integer> lmod = XList.of(1,2,8, 10, 11, 30, 3, 4);
lmod.forEachWithIndex( (e, i) -> lmod.set(i, e*2));
System.out.println(lmod);
lmod.forEachWithIndex( (e, i) -> { if (i % 2 == 0) lmod.remove(e); } );
System.out.println(lmod);
lmod.forEachWithIndex( (e, i) -> { if (i % 2 == 0) lmod.remove(i); } );
System.out.println(lmod); // Pytanie: dlaczego mamy taki efekt?
}
}
| t |
8502_1 | j-markiewicz/java | 1,437 | J2/src/Eksperymentator.java | import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Interfejs eksperymentatora, który będzie przeprowadzać doświadczenia z
* zakresu prawdopodobieństwa. W eksperymentach używana będzie kostka. Kostka do
* gry może działać w sposób niestandardowy i szanse na wyrzucenie określonej
* liczby oczek niekoniecznie muszą wynosić po 1/6.
*/
public interface Eksperymentator {
/**
* Eksperymentatorowi przekazujemy kostkę do gry. Wszystkie eksperymenty należy
* przeprowadzić z zastosowaniem powierzonej tu kostki. Kostki nie wolno używać
* do innych celów niż wykonanie eksperymentów (wszystkie rzuty kostką muszą
* zostać uwzględnione w wyliczonych prawdopodobieństwach).
*
* @param kostka kostka do gry
*/
public void użyjKostki(KostkaDoGry kostka);
/**
* Ustalenie całkowitego czasu trwania eksperymentu w milisekundach.
* Prawdopodobieństwa mają być szacowane przez eksperymentatora jako iloraz
* liczby prób zakończonych sukcesem do liczby wszystkich prób. Na wykonanie
* wszystkich prób eksperymentator ma czasEksperymentu. W okresie
* czasEksperymentu należy wykonać możliwie dużo prób.
*
* @param czasEksperymentu całkowity czas na wykonanie eksperymentu
*/
public void czasJednegoEksperymentu(long czasEksperymentu);
/**
* Metoda zwraca prawdopodobieństwo wyrzucenia określonej, sumarycznej liczby
* oczek przy rzucie pewną liczbaKostek. W tym eksperymencie przez
* czasEksperymentu rzucamy liczbaKostek. Metoda stara się oszacować szansę na
* wyrzucenie określonej sumy oczek, zliczamy więc wylosowane liczby oczek.
* Znając liczbę wszystkich rzutów (każdy to rzut liczbaKostek kostek) i ile
* razy wylosowała się określona suma można wyznaczyć poszukiwane
* prawdopodobieństwa.
*
* @param liczbaKostek liczba kostek używana w jedym rzucie
* @return mapa, w której kluczem jest sumaryczna liczba oczek a wartością
* szansa na wystąpienie tej sumy oczek.
*/
public Map<Integer, Double> szansaNaWyrzucenieOczek(int liczbaKostek);
/**
* Metoda sprawdza szansę na wyrzucenie określonej sekwencji oczek. Zadaną
* sekwencją może być np. 1, 2 i 4. Jeśli w kolejnych rzutach kostką otrzymamy
* przykładowo:
*
* <pre>
* 1 2 5
* 3 4 1 <- w tej i kolejnej linijce mamy łącznie 1 2 i 4, ale tu nie zliczamy trafienia
* 2 4 1
* <b>1 2 4</b>
* </pre>
* to szansa na wyrzucenie tej sekwencji to: 1/5 czyli 0.2.
*
* @param sekwencja lista kolejnych liczb oczek jakie mają zostać wyrzucone
* @return szansa na wyrzucenie wskazanej sekwencji.
*/
public double szansaNaWyrzucenieKolejno(List<Integer> sekwencja);
/**
* Metoda sprawdza szansę na wyrzucenie określonych liczb oczek w dowolnej
* kolejności. Zadanym zbiorem może być np. 1, 2 i 4. Jeśli w kolejnych rzutach
* kostką otrzymamy przykładowo:
*
* <pre>
* <b>2 1 4</b>
* 3 4 1 <- w tej i kolejnej linijce mamy łącznie 1 2 i 4, ale tu nie zliczamy trafienia
* 2 4 5
* <b>1 2 4</b>
* </pre>
* to szansa na wyrzucenie tej sekwencji to: 2/5 czyli 0.4.
*
* @param oczka liczba oczek jakie mają zostać wyrzucone
* @return szansa na wyrzucenie wskazanych liczb oczek
*/
public double szansaNaWyrzucenieWDowolnejKolejności(Set<Integer> oczka);
}
| /**
* Eksperymentatorowi przekazujemy kostkę do gry. Wszystkie eksperymenty należy
* przeprowadzić z zastosowaniem powierzonej tu kostki. Kostki nie wolno używać
* do innych celów niż wykonanie eksperymentów (wszystkie rzuty kostką muszą
* zostać uwzględnione w wyliczonych prawdopodobieństwach).
*
* @param kostka kostka do gry
*/ | import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Interfejs eksperymentatora, który będzie przeprowadzać doświadczenia z
* zakresu prawdopodobieństwa. W eksperymentach używana będzie kostka. Kostka do
* gry może działać w sposób niestandardowy i szanse na wyrzucenie określonej
* liczby oczek niekoniecznie muszą wynosić po 1/6.
*/
public interface Eksperymentator {
/**
* Eksperymentatorowi przekazujemy kostkę <SUF>*/
public void użyjKostki(KostkaDoGry kostka);
/**
* Ustalenie całkowitego czasu trwania eksperymentu w milisekundach.
* Prawdopodobieństwa mają być szacowane przez eksperymentatora jako iloraz
* liczby prób zakończonych sukcesem do liczby wszystkich prób. Na wykonanie
* wszystkich prób eksperymentator ma czasEksperymentu. W okresie
* czasEksperymentu należy wykonać możliwie dużo prób.
*
* @param czasEksperymentu całkowity czas na wykonanie eksperymentu
*/
public void czasJednegoEksperymentu(long czasEksperymentu);
/**
* Metoda zwraca prawdopodobieństwo wyrzucenia określonej, sumarycznej liczby
* oczek przy rzucie pewną liczbaKostek. W tym eksperymencie przez
* czasEksperymentu rzucamy liczbaKostek. Metoda stara się oszacować szansę na
* wyrzucenie określonej sumy oczek, zliczamy więc wylosowane liczby oczek.
* Znając liczbę wszystkich rzutów (każdy to rzut liczbaKostek kostek) i ile
* razy wylosowała się określona suma można wyznaczyć poszukiwane
* prawdopodobieństwa.
*
* @param liczbaKostek liczba kostek używana w jedym rzucie
* @return mapa, w której kluczem jest sumaryczna liczba oczek a wartością
* szansa na wystąpienie tej sumy oczek.
*/
public Map<Integer, Double> szansaNaWyrzucenieOczek(int liczbaKostek);
/**
* Metoda sprawdza szansę na wyrzucenie określonej sekwencji oczek. Zadaną
* sekwencją może być np. 1, 2 i 4. Jeśli w kolejnych rzutach kostką otrzymamy
* przykładowo:
*
* <pre>
* 1 2 5
* 3 4 1 <- w tej i kolejnej linijce mamy łącznie 1 2 i 4, ale tu nie zliczamy trafienia
* 2 4 1
* <b>1 2 4</b>
* </pre>
* to szansa na wyrzucenie tej sekwencji to: 1/5 czyli 0.2.
*
* @param sekwencja lista kolejnych liczb oczek jakie mają zostać wyrzucone
* @return szansa na wyrzucenie wskazanej sekwencji.
*/
public double szansaNaWyrzucenieKolejno(List<Integer> sekwencja);
/**
* Metoda sprawdza szansę na wyrzucenie określonych liczb oczek w dowolnej
* kolejności. Zadanym zbiorem może być np. 1, 2 i 4. Jeśli w kolejnych rzutach
* kostką otrzymamy przykładowo:
*
* <pre>
* <b>2 1 4</b>
* 3 4 1 <- w tej i kolejnej linijce mamy łącznie 1 2 i 4, ale tu nie zliczamy trafienia
* 2 4 5
* <b>1 2 4</b>
* </pre>
* to szansa na wyrzucenie tej sekwencji to: 2/5 czyli 0.4.
*
* @param oczka liczba oczek jakie mają zostać wyrzucone
* @return szansa na wyrzucenie wskazanych liczb oczek
*/
public double szansaNaWyrzucenieWDowolnejKolejności(Set<Integer> oczka);
}
| t |
243_4 | j-partyka/coloring-graph | 2,615 | Parent.java | import java.util.AbstractMap;
import java.util.Map;
import java.util.Random;
import java.util.Vector;
//parents
public class Parent {
public Map.Entry<Integer,Integer> random(Vector<Vertex> chromosom1)
{
int ilosc1=0;
int ilosc2=0;
Random generator = new Random();
int random1=generator.nextInt(100);
int random2=generator.nextInt(100);
while(chromosom1.get(random1).id==150)
{
random1=generator.nextInt(100);
}
while(chromosom1.get(random2).id==150 || chromosom1.get(random2).id==random1 )
{
random2=generator.nextInt(100);
}
//teraz z dwóch rodziców musimy wybraæ lepszego(?)
//przejœæ po wszystkich s¹siadach i naliczaæ ile ma "dobry" kolor
//jeÂżeli tyle samo dla random1 i random2 to wybieramy random1
for (int d =0;d<chromosom1.get(random1).sasiedzi.size();d++)
{
//chromosom.get(random1).sasiedzi.get(d)
if(chromosom1.get(chromosom1.get(random1).sasiedzi.get(d)).kolor!=chromosom1.get(random1).kolor) ilosc1++;
//System.out.println(chromosom1.get(random1).sasiedzi.get(d));
//System.out.println(chromosom1.get(d).kolor);
}
//dla drugiego to samo
for (int d =0;d<chromosom1.get(random2).sasiedzi.size();d++)
{
if(chromosom1.get(chromosom1.get(random2).sasiedzi.get(d)).kolor!=chromosom1.get(random2).kolor) ilosc2++;
}
int parent1id=0;
int parent2id=0;
if(ilosc1>=ilosc2) parent1id=random1;
if(ilosc1<ilosc2) parent1id=random2;
random1=generator.nextInt(100);
random2=generator.nextInt(100);
while(chromosom1.get(random1).id==150 && chromosom1.get(random2).id==parent1id)
{
random1=generator.nextInt(100);
}
while(chromosom1.get(random2).id==150 && chromosom1.get(random2).id==random1&& chromosom1.get(random2).id==parent1id)
{
random2=generator.nextInt(100);
}
for (int d =0;d<chromosom1.get(random1).sasiedzi.size();d++)
{
if(chromosom1.get(chromosom1.get(random1).sasiedzi.get(d)).kolor!=chromosom1.get(random1).kolor) ilosc1++;
}
//dla drugiego to samo
for (int d =0;d<chromosom1.get(random2).sasiedzi.size();d++)
{
if(chromosom1.get(chromosom1.get(random2).sasiedzi.get(d)).kolor!=chromosom1.get(random2).kolor) ilosc2++;
}
if(ilosc1>=ilosc2) parent2id=random1;
if(ilosc1<ilosc2) parent2id=random2;
Map.Entry<Integer,Integer> entry = new AbstractMap.SimpleEntry< Integer, Integer>(parent1id, parent2id);
return entry;
}
public Map.Entry<Integer,Integer> bestparent(Vector<Vertex> chromosom)
{
Random generator = new Random();
int random1=generator.nextInt(100);
int random2=generator.nextInt(100);
//wybieramy randomowych rodziców na początek
while(chromosom.get(random1).id==150)
{
random1=generator.nextInt(100);
}
while(chromosom.get(random2).id==150)
{
random2=generator.nextInt(100);
}
int parent1id=random1;
int parent2id=random2;
//liczba dobrych sąsiadów dla każdego wierzchołka-rodzica
int goodneighbour1=0;
int goodneighbour2=0;
int amount=0;
//naliczamy sąśiadów
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) amount++;
}
if (amount>goodneighbour1)
{
goodneighbour1=amount;
parent1id=j;
}
}
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) amount++;
}
if ((amount>goodneighbour2)&& j!=parent1id)
{
goodneighbour2=amount;
parent2id=j;
}
}
Map.Entry<Integer,Integer> entry = new AbstractMap.SimpleEntry< Integer, Integer>(parent1id, parent2id);
return entry;
}
//roulette
public Map.Entry<Integer,Integer> fitparent(Vector<Vertex> chromosom)
{
Random generator = new Random();
int parent1id=0;
int parent2id=0;
int sumfitness=0;
//przeiterować po kazdym i zsumować ich fitness (liczbę dobrych sąsiadów)
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) sumfitness++;
}
}
//jeżeli sumfitness=0 to nie możemy dzielić!
if (sumfitness==0)
{
parent1id=generator.nextInt(100);
parent2id=generator.nextInt(100);
while(chromosom.get(parent1id).id==150)
{
parent1id=generator.nextInt(100);
}
while(chromosom.get(parent2id).id==150 || parent2id==parent1id )
{
parent2id=generator.nextInt(100);
}
}
//jezeli !=0
else
{
//TODO
//dwa razy: wybieram losową liczbę z sumfitness, iteruję dodając znowu sąsiadów i jak dojdę
//do tej liczby to wybieram to ID
parent1id=generator.nextInt(sumfitness);
parent2id=generator.nextInt(sumfitness);
if (parent1id==0) parent1id++;
if (parent2id==0) parent1id++;
sumfitness=0;
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) sumfitness++;
if(parent1id==sumfitness) parent1id=j;
if(parent2id==sumfitness) parent2id=j;
}
}
}
Map.Entry<Integer,Integer> entry = new AbstractMap.SimpleEntry< Integer, Integer>(parent1id, parent2id);
return entry;
}
}
| //dla drugiego to samo | import java.util.AbstractMap;
import java.util.Map;
import java.util.Random;
import java.util.Vector;
//parents
public class Parent {
public Map.Entry<Integer,Integer> random(Vector<Vertex> chromosom1)
{
int ilosc1=0;
int ilosc2=0;
Random generator = new Random();
int random1=generator.nextInt(100);
int random2=generator.nextInt(100);
while(chromosom1.get(random1).id==150)
{
random1=generator.nextInt(100);
}
while(chromosom1.get(random2).id==150 || chromosom1.get(random2).id==random1 )
{
random2=generator.nextInt(100);
}
//teraz z dwóch rodziców musimy wybraæ lepszego(?)
//przejœæ po wszystkich s¹siadach i naliczaæ ile ma "dobry" kolor
//jeÂżeli tyle samo dla random1 i random2 to wybieramy random1
for (int d =0;d<chromosom1.get(random1).sasiedzi.size();d++)
{
//chromosom.get(random1).sasiedzi.get(d)
if(chromosom1.get(chromosom1.get(random1).sasiedzi.get(d)).kolor!=chromosom1.get(random1).kolor) ilosc1++;
//System.out.println(chromosom1.get(random1).sasiedzi.get(d));
//System.out.println(chromosom1.get(d).kolor);
}
//dla drugiego to samo
for (int d =0;d<chromosom1.get(random2).sasiedzi.size();d++)
{
if(chromosom1.get(chromosom1.get(random2).sasiedzi.get(d)).kolor!=chromosom1.get(random2).kolor) ilosc2++;
}
int parent1id=0;
int parent2id=0;
if(ilosc1>=ilosc2) parent1id=random1;
if(ilosc1<ilosc2) parent1id=random2;
random1=generator.nextInt(100);
random2=generator.nextInt(100);
while(chromosom1.get(random1).id==150 && chromosom1.get(random2).id==parent1id)
{
random1=generator.nextInt(100);
}
while(chromosom1.get(random2).id==150 && chromosom1.get(random2).id==random1&& chromosom1.get(random2).id==parent1id)
{
random2=generator.nextInt(100);
}
for (int d =0;d<chromosom1.get(random1).sasiedzi.size();d++)
{
if(chromosom1.get(chromosom1.get(random1).sasiedzi.get(d)).kolor!=chromosom1.get(random1).kolor) ilosc1++;
}
//dla drugiego <SUF>
for (int d =0;d<chromosom1.get(random2).sasiedzi.size();d++)
{
if(chromosom1.get(chromosom1.get(random2).sasiedzi.get(d)).kolor!=chromosom1.get(random2).kolor) ilosc2++;
}
if(ilosc1>=ilosc2) parent2id=random1;
if(ilosc1<ilosc2) parent2id=random2;
Map.Entry<Integer,Integer> entry = new AbstractMap.SimpleEntry< Integer, Integer>(parent1id, parent2id);
return entry;
}
public Map.Entry<Integer,Integer> bestparent(Vector<Vertex> chromosom)
{
Random generator = new Random();
int random1=generator.nextInt(100);
int random2=generator.nextInt(100);
//wybieramy randomowych rodziców na początek
while(chromosom.get(random1).id==150)
{
random1=generator.nextInt(100);
}
while(chromosom.get(random2).id==150)
{
random2=generator.nextInt(100);
}
int parent1id=random1;
int parent2id=random2;
//liczba dobrych sąsiadów dla każdego wierzchołka-rodzica
int goodneighbour1=0;
int goodneighbour2=0;
int amount=0;
//naliczamy sąśiadów
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) amount++;
}
if (amount>goodneighbour1)
{
goodneighbour1=amount;
parent1id=j;
}
}
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) amount++;
}
if ((amount>goodneighbour2)&& j!=parent1id)
{
goodneighbour2=amount;
parent2id=j;
}
}
Map.Entry<Integer,Integer> entry = new AbstractMap.SimpleEntry< Integer, Integer>(parent1id, parent2id);
return entry;
}
//roulette
public Map.Entry<Integer,Integer> fitparent(Vector<Vertex> chromosom)
{
Random generator = new Random();
int parent1id=0;
int parent2id=0;
int sumfitness=0;
//przeiterować po kazdym i zsumować ich fitness (liczbę dobrych sąsiadów)
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) sumfitness++;
}
}
//jeżeli sumfitness=0 to nie możemy dzielić!
if (sumfitness==0)
{
parent1id=generator.nextInt(100);
parent2id=generator.nextInt(100);
while(chromosom.get(parent1id).id==150)
{
parent1id=generator.nextInt(100);
}
while(chromosom.get(parent2id).id==150 || parent2id==parent1id )
{
parent2id=generator.nextInt(100);
}
}
//jezeli !=0
else
{
//TODO
//dwa razy: wybieram losową liczbę z sumfitness, iteruję dodając znowu sąsiadów i jak dojdę
//do tej liczby to wybieram to ID
parent1id=generator.nextInt(sumfitness);
parent2id=generator.nextInt(sumfitness);
if (parent1id==0) parent1id++;
if (parent2id==0) parent1id++;
sumfitness=0;
for(int j=0; j<chromosom.size();j++)
{
for (int d =0;d<chromosom.get(j).sasiedzi.size();d++)
{
if(chromosom.get(chromosom.get(j).sasiedzi.get(d)).kolor!=chromosom.get(j).kolor) sumfitness++;
if(parent1id==sumfitness) parent1id=j;
if(parent2id==sumfitness) parent2id=j;
}
}
}
Map.Entry<Integer,Integer> entry = new AbstractMap.SimpleEntry< Integer, Integer>(parent1id, parent2id);
return entry;
}
}
| t |
10333_1 | j4sysiak/Preparation | 535 | Dziedziczenie/src/com/company/model/BankAccount.java | package com.company.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.math.BigDecimal;
import java.util.Optional;
@Builder
@AllArgsConstructor
public class BankAccount {
private BigDecimal balance;
public static BankAccount create(BigDecimal balance) {
return BankAccount.builder()
.balance(balance)
.build();
}
public BigDecimal getBalance() {
return balance;
}
public void setBalance(BigDecimal amount) {
BigDecimal c = Optional.ofNullable(amount) // 1. sprawdzam, czy null
.map(this::runIfAmountNotNull) // 2. jeżeli nie null
.orElseGet(this::runIfEmpty); // 3. jeżeli null
this.balance = c;
}
private BigDecimal runIfEmpty() {
return BigDecimal.ZERO;
}
private BigDecimal runIfAmountNotNull(BigDecimal amount) {
return Optional.of(amount.compareTo(BigDecimal.ZERO) >= 0)// 4. sprawdzam, czy true
.filter(Boolean::booleanValue) // 4. będę sprawdzał Booleana
.map(bool -> ifTrue(amount)) // 5. Jeżeli true
.orElseGet(() -> ifNotTrue()); // 6. jeżeli false
}
private BigDecimal ifNotTrue() {
try {
throw new Exception("Amount less then zero!!!");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private BigDecimal ifTrue(BigDecimal amount) {
return amount;
}
public BigDecimal makeDeposit(BigDecimal amount) {
return balance = balance.add(runIfAmountNotNull(amount));
}
public BigDecimal makeWithdrawal(BigDecimal amount) {
return balance = balance.add(BigDecimal.valueOf(-1).multiply(runIfAmountNotNull(amount)));
}
}
| // 2. jeżeli nie null | package com.company.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.math.BigDecimal;
import java.util.Optional;
@Builder
@AllArgsConstructor
public class BankAccount {
private BigDecimal balance;
public static BankAccount create(BigDecimal balance) {
return BankAccount.builder()
.balance(balance)
.build();
}
public BigDecimal getBalance() {
return balance;
}
public void setBalance(BigDecimal amount) {
BigDecimal c = Optional.ofNullable(amount) // 1. sprawdzam, czy null
.map(this::runIfAmountNotNull) // 2. jeżeli <SUF>
.orElseGet(this::runIfEmpty); // 3. jeżeli null
this.balance = c;
}
private BigDecimal runIfEmpty() {
return BigDecimal.ZERO;
}
private BigDecimal runIfAmountNotNull(BigDecimal amount) {
return Optional.of(amount.compareTo(BigDecimal.ZERO) >= 0)// 4. sprawdzam, czy true
.filter(Boolean::booleanValue) // 4. będę sprawdzał Booleana
.map(bool -> ifTrue(amount)) // 5. Jeżeli true
.orElseGet(() -> ifNotTrue()); // 6. jeżeli false
}
private BigDecimal ifNotTrue() {
try {
throw new Exception("Amount less then zero!!!");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private BigDecimal ifTrue(BigDecimal amount) {
return amount;
}
public BigDecimal makeDeposit(BigDecimal amount) {
return balance = balance.add(runIfAmountNotNull(amount));
}
public BigDecimal makeWithdrawal(BigDecimal amount) {
return balance = balance.add(BigDecimal.valueOf(-1).multiply(runIfAmountNotNull(amount)));
}
}
| t |
7302_4 | jablko359/Queues | 3,416 | src/queue/bees/BeeAlgorithm.java | package queue.bees;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import queue.ClosedNetwork;
import queue.QueueNetwork;
import queue.exceptions.IncorrectUtilizationException;
import queue.exceptions.QueueException;
import queue.systems.FifoSystem;
import queue.systems.QueueSystem;
/**
* Created by Standy on 2017-01-07.
*/
public class BeeAlgorithm {
public static int MIN_CHANNEL = 1;
public static int MAX_CHANNEL = 20;
public static int TTL = 10;
// ilosc iteracji algorytmu
public static int ITERATIONS_NUMBER = 200;
public static double AVERAGE_TIME_COEFFICIENT = 100;
public static double NUMBER_OF_CHANNELS_COEFFICIENT = 30;
//siec
private QueueNetwork network;
// najlepsza wartosc w danym kroku
private Double bestValue;
// lista najlepszych pszczol - dodajemy tu najlepsza z danego kroku, aby moc zobaczyc jak sie zmienia funkcja celu
private LinkedList<Bee> calculatedBees;
// liczba najlepszych rozwiazan
private Integer bestSolutionsNumber;
// liczba elitarnych rozwiązan
private Integer exclusiveSolutionsNumber;
// liczba wszystkich rozwiazan
private Integer totalSolutionsNumber;
// wielkosc sasiedztwa dla najlepszych rozwiazan
private Integer bestSolutionsNeighberhoodNumber;
// wielkosc sasiedztwa dla rozwiazan elitarnych
private Integer exclusiveSolutionsNeighberhoodNumber;
// lista aktualnych pszczol
private List<Bee> bees;
// list najlepszych pszczol
private List<Bee> bestBees;
// lista elitarnych pszczol
private List<Bee> exclusiveBees;
private List<Bee> globalBestBees;
public List<Bee> getGlobalBestBees() {
return globalBestBees;
}
public BeeAlgorithm(QueueNetwork network, Integer bestSolutionsNumber, Integer exclusiveSolutionsNumber, Integer totalSolutionsNumber, Integer bestSolutionsNeighberhoodNumber, Integer exclusiveSolutionsNeighberhoodNumber) {
this.network = network;
this.bestSolutionsNumber = bestSolutionsNumber;
this.exclusiveSolutionsNumber = exclusiveSolutionsNumber;
this.totalSolutionsNumber = totalSolutionsNumber;
this.bestSolutionsNeighberhoodNumber = bestSolutionsNeighberhoodNumber;
this.exclusiveSolutionsNeighberhoodNumber = exclusiveSolutionsNeighberhoodNumber;
}
public void createBees(int numberOfBees) {
//utworz wspolrzedne z min i max iloscia kanalow
for (int i = 0; i < numberOfBees; i++) {
Map<DziekanatNodeType, Integer> coordinates = new HashMap<>();
coordinates.put(DziekanatNodeType.DZIENNE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.ZAOCZNE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.DOKTORANCKIE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.SOCJALNE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.DZIEKAN, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
Bee bee = new Bee(TTL, coordinates);
if (!updateM(bee)) {
i = i -1;
continue;
}
bee.setQuality(calculateQuality(bee));
bees.add(bee);
}
}
//metoda initialize utworzy nam listy najlepszych, elitarnych oraz wszystkich pszczol
public void initialize() {
bees = new ArrayList<>();
createBees(totalSolutionsNumber);
//sort array
Collections.sort(bees);
exclusiveBees = new ArrayList<>(bees.subList(0, exclusiveSolutionsNumber));
bestBees = new ArrayList<>(bees.subList(exclusiveSolutionsNumber, exclusiveSolutionsNumber + bestSolutionsNumber));
}
//tutaj właściwe obliczenia algorytmu
public void calculate() {
int iterationIndex = 0;
globalBestBees = new ArrayList<>();
//Najlepsza z pszczółek początkowych
globalBestBees.add(exclusiveBees.get(0));
System.out.println(iterationIndex + ". " + bees.get(0) + "\n");
while (ITERATIONS_NUMBER > iterationIndex) {
// System.out.println("Iteracja:" + (iterationIndex + 1));
updateExclusiveAndBest();
List<Bee> newExclusiveBees = generateNewBestBee(2, exclusiveBees);
List<Bee> newBestBees = generateNewBestBee(1, bestBees);
//Tworzymy nową listę pszczółek do kolejnego kroku algorytmu
bees.removeAll(exclusiveBees);
bees.removeAll(bestBees);
//Decrease TTL
decreaseTTL();
bees.addAll(newExclusiveBees);
bees.addAll(newBestBees);
Collections.sort(bees);
iterationIndex++;
//Jeśli znaleziono lepsze rozwiązanie od najelpszego to dodajemy do listy
//Index listy odpowiada iteracji algorytmu dlatego w przypadku braku poprawy przepisujemy najlepszą starą wartość
if (newExclusiveBees.get(0).getQuality() < globalBestBees.get(globalBestBees.size() - 1).getQuality()) {
globalBestBees.add(newExclusiveBees.get(0));
System.out.println(iterationIndex + ". " + newExclusiveBees.get(0) + "\n");
} else {
globalBestBees.add(globalBestBees.get(globalBestBees.size() - 1));
}
}
}
private List<Bee> generateNewBestBee(int importanceFactor, List<Bee> beeList) {
List<Bee> newBestBees = new ArrayList<>();
for (Bee bee : beeList) {
List<Bee> newOrdinaryBees = new ArrayList<>();
while (newOrdinaryBees.size() != bee.getCoordinates().size() * importanceFactor) {
for (Map.Entry entry : bee.getCoordinates().entrySet()) {
Bee newBee = new Bee(bee);
newBee.getCoordinates().put((DziekanatNodeType) entry.getKey(), BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL, (Integer) entry.getValue()));
if (!newOrdinaryBees.stream().anyMatch(b -> b.getCoordinates().get(entry.getKey()).equals(newBee.getCoordinates().get(entry.getKey())))) {
if (updateM(newBee)) {
newBee.setTimeToLive(TTL);
newBee.setQuality(calculateQuality(newBee));
newOrdinaryBees.add(newBee);
}
}
if (newOrdinaryBees.size() == bee.getCoordinates().size() * importanceFactor) {
break;
}
}
}
Collections.sort(newOrdinaryBees);
newBestBees.add(newOrdinaryBees.get(0));
}
Collections.sort(newBestBees);
//zwracamy nowe pszczółki niezależnie od tego czy dają ona lepsze rozwiązania od pszczółek bazowych
return newBestBees;
}
private double calculateQuality(Bee bee) {
//średni czas oczekiwania w kolejce
Double averageTime = 0.0;
int numberOfChannels = 0;
if (network.isOpen()) {
for (String customer : network.getActiveCustomerTypes()) {
averageTime += network.getLambdaT(DziekanatNodeType.DZIENNE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.ZAOCZNE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.SOCJALNE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.DOKTORANCKIE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.DZIEKAN.toString().toLowerCase(), customer);
}
} else {
int counter = 0;
for (int i = 0; i < ((ClosedNetwork) network).getResidenceTime().getRowDimension(); i++) {
for (int j = 0; j < ((ClosedNetwork) network).getResidenceTime().getColumnDimension(); j++) {
if (((ClosedNetwork) network).getResidenceTime().getEntry(i,j) > 0 ) {
averageTime += ((ClosedNetwork) network).getResidenceTime().getEntry(i,j);
counter++;
}
}
}
averageTime = (averageTime / counter) * 10;
}
for (Map.Entry entry : bee.getCoordinates().entrySet()) {
numberOfChannels += (int) entry.getValue();
}
//TODO Funkcja celu
return averageTime * AVERAGE_TIME_COEFFICIENT + numberOfChannels * NUMBER_OF_CHANNELS_COEFFICIENT;
}
private boolean updateM(Bee bee) {
Map<String, QueueSystem> systems = network.getSystemsMap();
(systems.get(DziekanatNodeType.DZIENNE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.DZIENNE));
(systems.get(DziekanatNodeType.ZAOCZNE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.ZAOCZNE));
(systems.get(DziekanatNodeType.SOCJALNE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.SOCJALNE));
(systems.get(DziekanatNodeType.DZIEKAN.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.DZIEKAN));
(systems.get(DziekanatNodeType.DOKTORANCKIE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.DOKTORANCKIE));
try {
network.calculateParameters(false);
} catch (IncorrectUtilizationException iue) {
return false;
} catch (QueueException e) {
e.printStackTrace();
}
return true;
}
private void decreaseTTL() {
List<Bee> beesToRemove = new ArrayList<>();
for (Bee bee : bees) {
bee.setTimeToLive(bee.getTimeToLive() - 1);
if (bee.getTimeToLive().equals(0)) {
beesToRemove.add(bee);
}
}
bees.removeAll(beesToRemove);
createBees(beesToRemove.size());
}
private void updateExclusiveAndBest() {
exclusiveBees = new ArrayList<>(bees.subList(0, exclusiveSolutionsNumber));
bestBees = new ArrayList<>(bees.subList(exclusiveSolutionsNumber, exclusiveSolutionsNumber + bestSolutionsNumber));
}
public QueueNetwork getQueueNetwork() {
return network;
}
}
| // liczba najlepszych rozwiazan | package queue.bees;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import queue.ClosedNetwork;
import queue.QueueNetwork;
import queue.exceptions.IncorrectUtilizationException;
import queue.exceptions.QueueException;
import queue.systems.FifoSystem;
import queue.systems.QueueSystem;
/**
* Created by Standy on 2017-01-07.
*/
public class BeeAlgorithm {
public static int MIN_CHANNEL = 1;
public static int MAX_CHANNEL = 20;
public static int TTL = 10;
// ilosc iteracji algorytmu
public static int ITERATIONS_NUMBER = 200;
public static double AVERAGE_TIME_COEFFICIENT = 100;
public static double NUMBER_OF_CHANNELS_COEFFICIENT = 30;
//siec
private QueueNetwork network;
// najlepsza wartosc w danym kroku
private Double bestValue;
// lista najlepszych pszczol - dodajemy tu najlepsza z danego kroku, aby moc zobaczyc jak sie zmienia funkcja celu
private LinkedList<Bee> calculatedBees;
// liczba najlepszych <SUF>
private Integer bestSolutionsNumber;
// liczba elitarnych rozwiązan
private Integer exclusiveSolutionsNumber;
// liczba wszystkich rozwiazan
private Integer totalSolutionsNumber;
// wielkosc sasiedztwa dla najlepszych rozwiazan
private Integer bestSolutionsNeighberhoodNumber;
// wielkosc sasiedztwa dla rozwiazan elitarnych
private Integer exclusiveSolutionsNeighberhoodNumber;
// lista aktualnych pszczol
private List<Bee> bees;
// list najlepszych pszczol
private List<Bee> bestBees;
// lista elitarnych pszczol
private List<Bee> exclusiveBees;
private List<Bee> globalBestBees;
public List<Bee> getGlobalBestBees() {
return globalBestBees;
}
public BeeAlgorithm(QueueNetwork network, Integer bestSolutionsNumber, Integer exclusiveSolutionsNumber, Integer totalSolutionsNumber, Integer bestSolutionsNeighberhoodNumber, Integer exclusiveSolutionsNeighberhoodNumber) {
this.network = network;
this.bestSolutionsNumber = bestSolutionsNumber;
this.exclusiveSolutionsNumber = exclusiveSolutionsNumber;
this.totalSolutionsNumber = totalSolutionsNumber;
this.bestSolutionsNeighberhoodNumber = bestSolutionsNeighberhoodNumber;
this.exclusiveSolutionsNeighberhoodNumber = exclusiveSolutionsNeighberhoodNumber;
}
public void createBees(int numberOfBees) {
//utworz wspolrzedne z min i max iloscia kanalow
for (int i = 0; i < numberOfBees; i++) {
Map<DziekanatNodeType, Integer> coordinates = new HashMap<>();
coordinates.put(DziekanatNodeType.DZIENNE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.ZAOCZNE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.DOKTORANCKIE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.SOCJALNE, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
coordinates.put(DziekanatNodeType.DZIEKAN, BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL));
Bee bee = new Bee(TTL, coordinates);
if (!updateM(bee)) {
i = i -1;
continue;
}
bee.setQuality(calculateQuality(bee));
bees.add(bee);
}
}
//metoda initialize utworzy nam listy najlepszych, elitarnych oraz wszystkich pszczol
public void initialize() {
bees = new ArrayList<>();
createBees(totalSolutionsNumber);
//sort array
Collections.sort(bees);
exclusiveBees = new ArrayList<>(bees.subList(0, exclusiveSolutionsNumber));
bestBees = new ArrayList<>(bees.subList(exclusiveSolutionsNumber, exclusiveSolutionsNumber + bestSolutionsNumber));
}
//tutaj właściwe obliczenia algorytmu
public void calculate() {
int iterationIndex = 0;
globalBestBees = new ArrayList<>();
//Najlepsza z pszczółek początkowych
globalBestBees.add(exclusiveBees.get(0));
System.out.println(iterationIndex + ". " + bees.get(0) + "\n");
while (ITERATIONS_NUMBER > iterationIndex) {
// System.out.println("Iteracja:" + (iterationIndex + 1));
updateExclusiveAndBest();
List<Bee> newExclusiveBees = generateNewBestBee(2, exclusiveBees);
List<Bee> newBestBees = generateNewBestBee(1, bestBees);
//Tworzymy nową listę pszczółek do kolejnego kroku algorytmu
bees.removeAll(exclusiveBees);
bees.removeAll(bestBees);
//Decrease TTL
decreaseTTL();
bees.addAll(newExclusiveBees);
bees.addAll(newBestBees);
Collections.sort(bees);
iterationIndex++;
//Jeśli znaleziono lepsze rozwiązanie od najelpszego to dodajemy do listy
//Index listy odpowiada iteracji algorytmu dlatego w przypadku braku poprawy przepisujemy najlepszą starą wartość
if (newExclusiveBees.get(0).getQuality() < globalBestBees.get(globalBestBees.size() - 1).getQuality()) {
globalBestBees.add(newExclusiveBees.get(0));
System.out.println(iterationIndex + ". " + newExclusiveBees.get(0) + "\n");
} else {
globalBestBees.add(globalBestBees.get(globalBestBees.size() - 1));
}
}
}
private List<Bee> generateNewBestBee(int importanceFactor, List<Bee> beeList) {
List<Bee> newBestBees = new ArrayList<>();
for (Bee bee : beeList) {
List<Bee> newOrdinaryBees = new ArrayList<>();
while (newOrdinaryBees.size() != bee.getCoordinates().size() * importanceFactor) {
for (Map.Entry entry : bee.getCoordinates().entrySet()) {
Bee newBee = new Bee(bee);
newBee.getCoordinates().put((DziekanatNodeType) entry.getKey(), BeeCoordinates.getRandomChannel(MIN_CHANNEL, MAX_CHANNEL, (Integer) entry.getValue()));
if (!newOrdinaryBees.stream().anyMatch(b -> b.getCoordinates().get(entry.getKey()).equals(newBee.getCoordinates().get(entry.getKey())))) {
if (updateM(newBee)) {
newBee.setTimeToLive(TTL);
newBee.setQuality(calculateQuality(newBee));
newOrdinaryBees.add(newBee);
}
}
if (newOrdinaryBees.size() == bee.getCoordinates().size() * importanceFactor) {
break;
}
}
}
Collections.sort(newOrdinaryBees);
newBestBees.add(newOrdinaryBees.get(0));
}
Collections.sort(newBestBees);
//zwracamy nowe pszczółki niezależnie od tego czy dają ona lepsze rozwiązania od pszczółek bazowych
return newBestBees;
}
private double calculateQuality(Bee bee) {
//średni czas oczekiwania w kolejce
Double averageTime = 0.0;
int numberOfChannels = 0;
if (network.isOpen()) {
for (String customer : network.getActiveCustomerTypes()) {
averageTime += network.getLambdaT(DziekanatNodeType.DZIENNE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.ZAOCZNE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.SOCJALNE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.DOKTORANCKIE.toString().toLowerCase(), customer);
averageTime += network.getLambdaT(DziekanatNodeType.DZIEKAN.toString().toLowerCase(), customer);
}
} else {
int counter = 0;
for (int i = 0; i < ((ClosedNetwork) network).getResidenceTime().getRowDimension(); i++) {
for (int j = 0; j < ((ClosedNetwork) network).getResidenceTime().getColumnDimension(); j++) {
if (((ClosedNetwork) network).getResidenceTime().getEntry(i,j) > 0 ) {
averageTime += ((ClosedNetwork) network).getResidenceTime().getEntry(i,j);
counter++;
}
}
}
averageTime = (averageTime / counter) * 10;
}
for (Map.Entry entry : bee.getCoordinates().entrySet()) {
numberOfChannels += (int) entry.getValue();
}
//TODO Funkcja celu
return averageTime * AVERAGE_TIME_COEFFICIENT + numberOfChannels * NUMBER_OF_CHANNELS_COEFFICIENT;
}
private boolean updateM(Bee bee) {
Map<String, QueueSystem> systems = network.getSystemsMap();
(systems.get(DziekanatNodeType.DZIENNE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.DZIENNE));
(systems.get(DziekanatNodeType.ZAOCZNE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.ZAOCZNE));
(systems.get(DziekanatNodeType.SOCJALNE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.SOCJALNE));
(systems.get(DziekanatNodeType.DZIEKAN.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.DZIEKAN));
(systems.get(DziekanatNodeType.DOKTORANCKIE.toString().toLowerCase())).setM(bee.getCoordinates().get(DziekanatNodeType.DOKTORANCKIE));
try {
network.calculateParameters(false);
} catch (IncorrectUtilizationException iue) {
return false;
} catch (QueueException e) {
e.printStackTrace();
}
return true;
}
private void decreaseTTL() {
List<Bee> beesToRemove = new ArrayList<>();
for (Bee bee : bees) {
bee.setTimeToLive(bee.getTimeToLive() - 1);
if (bee.getTimeToLive().equals(0)) {
beesToRemove.add(bee);
}
}
bees.removeAll(beesToRemove);
createBees(beesToRemove.size());
}
private void updateExclusiveAndBest() {
exclusiveBees = new ArrayList<>(bees.subList(0, exclusiveSolutionsNumber));
bestBees = new ArrayList<>(bees.subList(exclusiveSolutionsNumber, exclusiveSolutionsNumber + bestSolutionsNumber));
}
public QueueNetwork getQueueNetwork() {
return network;
}
}
| t |
9993_0 | jakub-olszewski/java16poz | 445 | src/main/java/pl/sdacademy/java16poz/programowanie1/lists/List.java | package pl.sdacademy.java16poz.programowanie1.lists;
/**
* Lista
*
* @author: Jakub Olszewski [http://github.com/jakub-olszewski]
* @date: 17.05.2019 10:36
**/
public interface List<T> {
/**
* Metoda dodaje element do listy
* @param element
*/
void add(T element);
/**
* Metoda zwraca true, lub false, gdy lista jest, lub nie jest pusta - najlepiej wykorzystać metodę size()
* @return true/false
*/
boolean isEmpty();
/**
* Metoda zwraca rozmiar listy
* @return rozmiar
*/
int size();
/**
* Metoda zwraca wartość obiektu z elementu listy o wskazanym indeksie
* @param index
* @return wartość
*/
T get(int index);
/**
* Metoda usuwa element przechowujący obiekt podany jako parametr
* @return prawda gdy zostanie usunięty
*/
boolean delete(int index);// -
/**
* Metoda ustawia obiekt w elemencie o podanej pozycji
* @param index na liście
* @param value ustawiania wartość
*/
void set(int index, T value);
/**
* Metoda czyści listę. W przypadku listy z wartownikiem wystarczy ustawić jego następnik na wartość null.
*/
void clear();
String toString();
}
| /**
* Lista
*
* @author: Jakub Olszewski [http://github.com/jakub-olszewski]
* @date: 17.05.2019 10:36
**/ | package pl.sdacademy.java16poz.programowanie1.lists;
/**
* Lista
* <SUF>*/
public interface List<T> {
/**
* Metoda dodaje element do listy
* @param element
*/
void add(T element);
/**
* Metoda zwraca true, lub false, gdy lista jest, lub nie jest pusta - najlepiej wykorzystać metodę size()
* @return true/false
*/
boolean isEmpty();
/**
* Metoda zwraca rozmiar listy
* @return rozmiar
*/
int size();
/**
* Metoda zwraca wartość obiektu z elementu listy o wskazanym indeksie
* @param index
* @return wartość
*/
T get(int index);
/**
* Metoda usuwa element przechowujący obiekt podany jako parametr
* @return prawda gdy zostanie usunięty
*/
boolean delete(int index);// -
/**
* Metoda ustawia obiekt w elemencie o podanej pozycji
* @param index na liście
* @param value ustawiania wartość
*/
void set(int index, T value);
/**
* Metoda czyści listę. W przypadku listy z wartownikiem wystarczy ustawić jego następnik na wartość null.
*/
void clear();
String toString();
}
| t |
9041_3 | jakubjaron/pwo_to_do_list_project | 501 | todolist-engine/src/main/java/pwo/todolist/engine/SortTodoByCategory.java | /*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
package pwo.todolist.engine;
import java.util.Comparator;
/**
* Klasa sortująca obiekty zadań Todo po nazwie kategorii
* @author dariusz
*/
public class SortTodoByCategory implements Comparator<Todo>{
boolean isReversed = false;
public SortTodoByCategory(){
}
/**
* Konstruktor określający czy wyniki mają zostać zwrócone w postaci alfabetycznej, czy odwrotnie alfabetycznej
* @param isReversed Czy dane mają być zwrócone w postaci odwrotnie alfabetycznej
*/
public SortTodoByCategory(boolean isReversed){
this.isReversed = isReversed;
}
/**
* Funkcja porównująca dwa zadania Todo według nazwy kategorii ignorując wielkość liter.
* @param o1 Pierwsze zadanie Todo
* @param o2 Drugie Zadanie Todo
* @return Zwraca -1 jeżeli o1 jest w porządku alfabetycznym przed o2. Zwraca 0 jeżeli porównywane są te same nazwy kategorii.
* Zwraca 1 jeżeli w porządku alfabetycznym o1 następuje po o2.
*/
@Override
public int compare(Todo o1, Todo o2) {
if(isReversed){
return o2.category.compareToIgnoreCase(o1.category);
}
return o1.category.compareToIgnoreCase(o2.category);
}
}
| /**
* Funkcja porównująca dwa zadania Todo według nazwy kategorii ignorując wielkość liter.
* @param o1 Pierwsze zadanie Todo
* @param o2 Drugie Zadanie Todo
* @return Zwraca -1 jeżeli o1 jest w porządku alfabetycznym przed o2. Zwraca 0 jeżeli porównywane są te same nazwy kategorii.
* Zwraca 1 jeżeli w porządku alfabetycznym o1 następuje po o2.
*/ | /*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
package pwo.todolist.engine;
import java.util.Comparator;
/**
* Klasa sortująca obiekty zadań Todo po nazwie kategorii
* @author dariusz
*/
public class SortTodoByCategory implements Comparator<Todo>{
boolean isReversed = false;
public SortTodoByCategory(){
}
/**
* Konstruktor określający czy wyniki mają zostać zwrócone w postaci alfabetycznej, czy odwrotnie alfabetycznej
* @param isReversed Czy dane mają być zwrócone w postaci odwrotnie alfabetycznej
*/
public SortTodoByCategory(boolean isReversed){
this.isReversed = isReversed;
}
/**
* Funkcja porównująca dwa <SUF>*/
@Override
public int compare(Todo o1, Todo o2) {
if(isReversed){
return o2.category.compareToIgnoreCase(o1.category);
}
return o1.category.compareToIgnoreCase(o2.category);
}
}
| t |
6245_1 | jakubjarzmik/Client-server-calendar-with-Java-Swing | 756 | src/main/java/frames/calendar/UserServices.java | package frames.calendar;
import storageclasses.AllDayEvent;
import storageclasses.Event;
import storageclasses.UnusualHolidayAndNameDay;
import javax.swing.*;
import java.io.*;
import java.util.ArrayList;
import static frames.calendar.CalendarFrame.unusualHolidayAndNameDay;
class UserServices {
CalendarFrame calendarFrame;
private boolean changeNickname;
private final ObjectOutputStream out;
private final ObjectInputStream in;
private String nick;
UserServices(){
calendarFrame = CalendarFrame.getInstance();
nick = calendarFrame.nick;
out = calendarFrame.out;
in = calendarFrame.in;
readNick();
showLoginWindow();
showEvents();
}
/**
* Wczystuje nick użytkownika z pliku jeśli był zapisany
*/
private void readNick(){
try (DataInputStream in = new DataInputStream(new FileInputStream("localfiles/userDetails.dat"))) {
nick = in.readUTF();
}
catch (FileNotFoundException ex) { System.out.println("Brak pliku z nickiem użytkownika"); }
catch(IOException e) { e.printStackTrace(); }
}
/**
* Wyświetla okienko logowania
*/
private void showLoginWindow(){
if(nick.isBlank() || changeNickname) {
nick = JOptionPane.showInputDialog("Podaj swój nickname:");
String[] options = new String[]{"TAK","NIE"};
int result = JOptionPane.showOptionDialog(calendarFrame,"Zapamiętać nazwę użytkownika?","",JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE,
null,options,null);
if(result == 0)
saveNick();
}
changeNickname = false;
}
/**
* Zapisuje nick użytkownika do pliku by nie musiał się kolejny raz logować
*/
private void saveNick(){
try (DataOutputStream out = new DataOutputStream(new FileOutputStream("localfiles/userDetails.dat"))) {
out.writeUTF(nick);
} catch(IOException e) { e.printStackTrace(); }
}
/**
* Pobiera wydarzenia z serwera
*/
private void showEvents(){
try {
calendarFrame.out.writeObject(nick);
UnusualHolidayAndNameDay u = (UnusualHolidayAndNameDay) in.readObject();
unusualHolidayAndNameDay[0] = u.getHolidayName();
unusualHolidayAndNameDay[1] = u.getNameDay();
calendarFrame.eventsPanel.userEvents =(ArrayList<Event>) in.readObject();
calendarFrame.eventsPanel.defaultEvents =(ArrayList<AllDayEvent>) in.readObject();
}catch (Exception e){e.printStackTrace();}
}
}
| /**
* Wyświetla okienko logowania
*/ | package frames.calendar;
import storageclasses.AllDayEvent;
import storageclasses.Event;
import storageclasses.UnusualHolidayAndNameDay;
import javax.swing.*;
import java.io.*;
import java.util.ArrayList;
import static frames.calendar.CalendarFrame.unusualHolidayAndNameDay;
class UserServices {
CalendarFrame calendarFrame;
private boolean changeNickname;
private final ObjectOutputStream out;
private final ObjectInputStream in;
private String nick;
UserServices(){
calendarFrame = CalendarFrame.getInstance();
nick = calendarFrame.nick;
out = calendarFrame.out;
in = calendarFrame.in;
readNick();
showLoginWindow();
showEvents();
}
/**
* Wczystuje nick użytkownika z pliku jeśli był zapisany
*/
private void readNick(){
try (DataInputStream in = new DataInputStream(new FileInputStream("localfiles/userDetails.dat"))) {
nick = in.readUTF();
}
catch (FileNotFoundException ex) { System.out.println("Brak pliku z nickiem użytkownika"); }
catch(IOException e) { e.printStackTrace(); }
}
/**
* Wyświetla okienko logowania <SUF>*/
private void showLoginWindow(){
if(nick.isBlank() || changeNickname) {
nick = JOptionPane.showInputDialog("Podaj swój nickname:");
String[] options = new String[]{"TAK","NIE"};
int result = JOptionPane.showOptionDialog(calendarFrame,"Zapamiętać nazwę użytkownika?","",JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE,
null,options,null);
if(result == 0)
saveNick();
}
changeNickname = false;
}
/**
* Zapisuje nick użytkownika do pliku by nie musiał się kolejny raz logować
*/
private void saveNick(){
try (DataOutputStream out = new DataOutputStream(new FileOutputStream("localfiles/userDetails.dat"))) {
out.writeUTF(nick);
} catch(IOException e) { e.printStackTrace(); }
}
/**
* Pobiera wydarzenia z serwera
*/
private void showEvents(){
try {
calendarFrame.out.writeObject(nick);
UnusualHolidayAndNameDay u = (UnusualHolidayAndNameDay) in.readObject();
unusualHolidayAndNameDay[0] = u.getHolidayName();
unusualHolidayAndNameDay[1] = u.getNameDay();
calendarFrame.eventsPanel.userEvents =(ArrayList<Event>) in.readObject();
calendarFrame.eventsPanel.defaultEvents =(ArrayList<AllDayEvent>) in.readObject();
}catch (Exception e){e.printStackTrace();}
}
}
| t |
4098_6 | jakubmuczyn/Todo-App | 753 | src/main/java/pl/jakubmuczyn/aspect/LogicAspect.java | package pl.jakubmuczyn.aspect;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* Moglibyśmy całą obsługę logiki biznesowej przenieść do aspektów, lecz nie jest
* to zalecane, chociażby dlatego, że zwracamy Objects, które trzeba byłoby
* rzutować na bardziej specyficzne klasy, czy przez inne niewygodne tematy.
*
* Loggery, transakcje, zarządzanie wyjątkami, metryki, itp. - dobrze jest ogrywać
* przy pomocy aspektów, resztę jednak lepiej zostawić w kodzie.
*/
@Aspect // faktyczna obsługa aspektów
@Component // zarejestrowanie w Springu tej klasy
class LogicAspect {
private static final Logger logger = LoggerFactory.getLogger(LogicAspect.class);
private final Timer createGroupByProjectTimer;
public LogicAspect(final MeterRegistry meterRegistry) { // podczas tworzenia tej klasy Sprign wstrzyknie rejestr metryk. MeterRegistry pozwala też tworzyć czasomierze
createGroupByProjectTimer = meterRegistry.timer("logic.project.create.group");
}
@Pointcut("execution(* pl.jakubmuczyn.logic.ProjectService.createGroup(..))") // punkt przecięcia
static void projectServiceCreateGroup() {
}
@Before("projectServiceCreateGroup()")
void logMethodCall(JoinPoint joinPoint) {
logger.info("Before {} with {}", joinPoint.getSignature().getName(), joinPoint.getArgs());
}
// @Around - aspekt
// * - dowolny typ zwracany
// .. - jakieś parametry
@Around("projectServiceCreateGroup()")
Object aroungCreateGroupByProject(ProceedingJoinPoint joinPoint) {
return createGroupByProjectTimer.record(() -> {
try {
return joinPoint.proceed();
} catch (Throwable e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else {
throw new RuntimeException(e); // ręczne owrapowanie wyjątku w RuntimeException
}
}
});
}
}
| // .. - jakieś parametry | package pl.jakubmuczyn.aspect;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* Moglibyśmy całą obsługę logiki biznesowej przenieść do aspektów, lecz nie jest
* to zalecane, chociażby dlatego, że zwracamy Objects, które trzeba byłoby
* rzutować na bardziej specyficzne klasy, czy przez inne niewygodne tematy.
*
* Loggery, transakcje, zarządzanie wyjątkami, metryki, itp. - dobrze jest ogrywać
* przy pomocy aspektów, resztę jednak lepiej zostawić w kodzie.
*/
@Aspect // faktyczna obsługa aspektów
@Component // zarejestrowanie w Springu tej klasy
class LogicAspect {
private static final Logger logger = LoggerFactory.getLogger(LogicAspect.class);
private final Timer createGroupByProjectTimer;
public LogicAspect(final MeterRegistry meterRegistry) { // podczas tworzenia tej klasy Sprign wstrzyknie rejestr metryk. MeterRegistry pozwala też tworzyć czasomierze
createGroupByProjectTimer = meterRegistry.timer("logic.project.create.group");
}
@Pointcut("execution(* pl.jakubmuczyn.logic.ProjectService.createGroup(..))") // punkt przecięcia
static void projectServiceCreateGroup() {
}
@Before("projectServiceCreateGroup()")
void logMethodCall(JoinPoint joinPoint) {
logger.info("Before {} with {}", joinPoint.getSignature().getName(), joinPoint.getArgs());
}
// @Around - aspekt
// * - dowolny typ zwracany
// .. - <SUF>
@Around("projectServiceCreateGroup()")
Object aroungCreateGroupByProject(ProceedingJoinPoint joinPoint) {
return createGroupByProjectTimer.record(() -> {
try {
return joinPoint.proceed();
} catch (Throwable e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else {
throw new RuntimeException(e); // ręczne owrapowanie wyjątku w RuntimeException
}
}
});
}
}
| t |
6730_6 | janek/SO1_AK_JS | 424 | Proces.java | /*
*Zadanie pierwsze kursu Systemy Operacyjne, 2014 PWr
* Aleksander Kolbuszewski, Janek Szynal
*/
package so1_ak_js;
/**
*
* @author Janek
*/
public class Proces {
int nrPorzadkowy = 0;
int dlugoscFazy = 0; //liczba jedn. czasu potrzebnych na przetworzenie procesu
int deltaZgloszenia = 0; //czas, ktory mija od zgloszenia sie poprzedniego procesu
int momentZgloszenia = 0; //moment, w ktotym proces pojawia sie na liscie
int momentWejscia = 0; //moment, w ktorym procesor przyjmuje proces
int czasOczekiwania = 0; //czas, jaki proces musi odczekac do rozpoczecia sie jego przetwarzania
boolean czyWykonany = false; //do SJF
Proces(int nrPorzadkowy, int dlugoscFazy, int deltaZgloszenia){
this.nrPorzadkowy = nrPorzadkowy;
this.dlugoscFazy = dlugoscFazy;
this.deltaZgloszenia = deltaZgloszenia;
}
public void wypisz(){
System.out.println("Proces nr "+nrPorzadkowy+", długość fazy: "+dlugoscFazy+", moment zgłoszenia: "+momentZgloszenia);
}
}
| //czas, jaki proces musi odczekac do rozpoczecia sie jego przetwarzania | /*
*Zadanie pierwsze kursu Systemy Operacyjne, 2014 PWr
* Aleksander Kolbuszewski, Janek Szynal
*/
package so1_ak_js;
/**
*
* @author Janek
*/
public class Proces {
int nrPorzadkowy = 0;
int dlugoscFazy = 0; //liczba jedn. czasu potrzebnych na przetworzenie procesu
int deltaZgloszenia = 0; //czas, ktory mija od zgloszenia sie poprzedniego procesu
int momentZgloszenia = 0; //moment, w ktotym proces pojawia sie na liscie
int momentWejscia = 0; //moment, w ktorym procesor przyjmuje proces
int czasOczekiwania = 0; //czas, jaki <SUF>
boolean czyWykonany = false; //do SJF
Proces(int nrPorzadkowy, int dlugoscFazy, int deltaZgloszenia){
this.nrPorzadkowy = nrPorzadkowy;
this.dlugoscFazy = dlugoscFazy;
this.deltaZgloszenia = deltaZgloszenia;
}
public void wypisz(){
System.out.println("Proces nr "+nrPorzadkowy+", długość fazy: "+dlugoscFazy+", moment zgłoszenia: "+momentZgloszenia);
}
}
| t |
6178_3 | jankabzinski/IMO | 1,420 | lab6/src/main/java/DestroyAndRepair.java | import java.util.*;
public class DestroyAndRepair {
static Main.Cycles destroy_and_repair(double[][] distances, Main.Cycles cycles) {
List<Nearest> nearests = new ArrayList<>();
//utworz listę najbliższych sobie wierzchołków
for (int i = 1; i < cycles.first_cycle.size() - 1; i++) {
var val = cycles.first_cycle.get(i);
for (int x = val + 1; x < Main.size; x++) {
if (cycles.first_cycle.contains(x) || (x == cycles.first_cycle.get(0)) || (x == cycles.second_cycle.get(0))) {
continue;
}
nearests.add(new Nearest(val, x, distances[val][x]));
}
}
for (int i = 1; i < cycles.second_cycle.size() - 1; i++) {
var val = cycles.second_cycle.get(i);
for (int x = val + 1; x < Main.size; x++) {
if (cycles.second_cycle.contains(x) || (x == cycles.first_cycle.get(0)) || (x == cycles.second_cycle.get(0))) {
continue;
}
nearests.add(new Nearest(x, val, distances[val][x]));
}
}
Collections.sort(nearests);
//posortuj, by znaleźć najbliższe sobie
Set<Integer> removed_nodes = new HashSet<>();
//idiotyczna inicjalizacja tablicy pomocnicznej, bo zazwyczaj idzie po referencji zamiast po wartościach XD
Main.Cycles cycles_for_destroy = cycles.clone();
//usun 20 procent najbliższych sobie wierzchołków, które są w osobnych cyklach
for (int i = 0; i < nearests.size() &&
cycles_for_destroy.first_cycle.size() + cycles_for_destroy.second_cycle.size() > Main.size * 0.9; i++) {
cycles_for_destroy.first_cycle.remove((Integer) nearests.get(i).x);
removed_nodes.add(nearests.get(i).x);
cycles_for_destroy.second_cycle.remove((Integer) nearests.get(i).y);
removed_nodes.add(nearests.get(i).y);
}
//usun losowe 6 procent wierzchołków
Random rand = new Random();
for (int i = 0; i < 0.08 * Main.size; i++) {
int id_1 = rand.nextInt(cycles_for_destroy.first_cycle.size() - 2) + 1;
int element_1 = cycles_for_destroy.first_cycle.get(id_1);
cycles_for_destroy.first_cycle.remove(id_1);
int id_2 = rand.nextInt(cycles_for_destroy.first_cycle.size() - 2) + 1;
int element_2 = cycles_for_destroy.first_cycle.get(id_2);
cycles_for_destroy.first_cycle.remove(id_2);
removed_nodes.add(element_1);
removed_nodes.add(element_2);
}
ArrayList<Integer> removed_nodes_ale_to_lista = new ArrayList<>(removed_nodes);
//napraw, również za pomocą greedy cycle
while (!removed_nodes_ale_to_lista.isEmpty() && cycles_for_destroy.first_cycle.size() < 101 && cycles_for_destroy.second_cycle.size() < 101) {
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.second_cycle);
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.first_cycle);
}
if (cycles_for_destroy.first_cycle.size() == 101) {
while (!removed_nodes_ale_to_lista.isEmpty())
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.second_cycle);
} else {
while (!removed_nodes_ale_to_lista.isEmpty())
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.first_cycle);
}
cycles_for_destroy = Steepest.steepest(distances, cycles_for_destroy);
//jak jest poprawa to zwróć poprawione, jak nie to CHLIP, ale no trudno i zwróć stare
if (HelperFunctions.get_total_dist(distances, cycles) - HelperFunctions.get_total_dist(distances, cycles_for_destroy) > 0) {
return cycles_for_destroy;
} else {
return cycles;
}
}
static class Nearest implements Comparable {
int x;
int y;
double evaluation;
Nearest(int x, int y, double evaluation) {
this.x = x;
this.y = y;
this.evaluation = evaluation;
}
@Override
public int compareTo(Object o) {
return Double.compare(evaluation, ((Nearest) o).evaluation);
}
}
}
| //usun 20 procent najbliższych sobie wierzchołków, które są w osobnych cyklach | import java.util.*;
public class DestroyAndRepair {
static Main.Cycles destroy_and_repair(double[][] distances, Main.Cycles cycles) {
List<Nearest> nearests = new ArrayList<>();
//utworz listę najbliższych sobie wierzchołków
for (int i = 1; i < cycles.first_cycle.size() - 1; i++) {
var val = cycles.first_cycle.get(i);
for (int x = val + 1; x < Main.size; x++) {
if (cycles.first_cycle.contains(x) || (x == cycles.first_cycle.get(0)) || (x == cycles.second_cycle.get(0))) {
continue;
}
nearests.add(new Nearest(val, x, distances[val][x]));
}
}
for (int i = 1; i < cycles.second_cycle.size() - 1; i++) {
var val = cycles.second_cycle.get(i);
for (int x = val + 1; x < Main.size; x++) {
if (cycles.second_cycle.contains(x) || (x == cycles.first_cycle.get(0)) || (x == cycles.second_cycle.get(0))) {
continue;
}
nearests.add(new Nearest(x, val, distances[val][x]));
}
}
Collections.sort(nearests);
//posortuj, by znaleźć najbliższe sobie
Set<Integer> removed_nodes = new HashSet<>();
//idiotyczna inicjalizacja tablicy pomocnicznej, bo zazwyczaj idzie po referencji zamiast po wartościach XD
Main.Cycles cycles_for_destroy = cycles.clone();
//usun 20 <SUF>
for (int i = 0; i < nearests.size() &&
cycles_for_destroy.first_cycle.size() + cycles_for_destroy.second_cycle.size() > Main.size * 0.9; i++) {
cycles_for_destroy.first_cycle.remove((Integer) nearests.get(i).x);
removed_nodes.add(nearests.get(i).x);
cycles_for_destroy.second_cycle.remove((Integer) nearests.get(i).y);
removed_nodes.add(nearests.get(i).y);
}
//usun losowe 6 procent wierzchołków
Random rand = new Random();
for (int i = 0; i < 0.08 * Main.size; i++) {
int id_1 = rand.nextInt(cycles_for_destroy.first_cycle.size() - 2) + 1;
int element_1 = cycles_for_destroy.first_cycle.get(id_1);
cycles_for_destroy.first_cycle.remove(id_1);
int id_2 = rand.nextInt(cycles_for_destroy.first_cycle.size() - 2) + 1;
int element_2 = cycles_for_destroy.first_cycle.get(id_2);
cycles_for_destroy.first_cycle.remove(id_2);
removed_nodes.add(element_1);
removed_nodes.add(element_2);
}
ArrayList<Integer> removed_nodes_ale_to_lista = new ArrayList<>(removed_nodes);
//napraw, również za pomocą greedy cycle
while (!removed_nodes_ale_to_lista.isEmpty() && cycles_for_destroy.first_cycle.size() < 101 && cycles_for_destroy.second_cycle.size() < 101) {
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.second_cycle);
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.first_cycle);
}
if (cycles_for_destroy.first_cycle.size() == 101) {
while (!removed_nodes_ale_to_lista.isEmpty())
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.second_cycle);
} else {
while (!removed_nodes_ale_to_lista.isEmpty())
GreedyCycle.cycle_creation(distances, removed_nodes_ale_to_lista, cycles_for_destroy.first_cycle);
}
cycles_for_destroy = Steepest.steepest(distances, cycles_for_destroy);
//jak jest poprawa to zwróć poprawione, jak nie to CHLIP, ale no trudno i zwróć stare
if (HelperFunctions.get_total_dist(distances, cycles) - HelperFunctions.get_total_dist(distances, cycles_for_destroy) > 0) {
return cycles_for_destroy;
} else {
return cycles;
}
}
static class Nearest implements Comparable {
int x;
int y;
double evaluation;
Nearest(int x, int y, double evaluation) {
this.x = x;
this.y = y;
this.evaluation = evaluation;
}
@Override
public int compareTo(Object o) {
return Double.compare(evaluation, ((Nearest) o).evaluation);
}
}
}
| t |
7695_0 | jansaklak/Java | 197 | Constructors/B.java | public class B extends A{
public B(){
super(7.6);//referencja do czesci ktora pochodzi z dziedziczenia
//this() - naredzie zeby z jednego konstruktora tej klasy wywolac inny konstrukotor tej klasy
System.out.println("Tutaj konstruktor B"); //this/super musi byc pierwszą instrukcją,potem np print
}
public static void main(String[] args){
System.out.println("Tu main B");
A.metodaStatyczna();
B b = new B(); //tworząc obiekt B, konstruktor A jest? - żeby sprawdzić daje println do konstruktora A
}
}
| //referencja do czesci ktora pochodzi z dziedziczenia | public class B extends A{
public B(){
super(7.6);//referencja do <SUF>
//this() - naredzie zeby z jednego konstruktora tej klasy wywolac inny konstrukotor tej klasy
System.out.println("Tutaj konstruktor B"); //this/super musi byc pierwszą instrukcją,potem np print
}
public static void main(String[] args){
System.out.println("Tu main B");
A.metodaStatyczna();
B b = new B(); //tworząc obiekt B, konstruktor A jest? - żeby sprawdzić daje println do konstruktora A
}
}
| t |
8296_1 | jaugustyn02/concurrency-theory | 463 | labs/concurrency_theory_labs/src/main/java/org/lab04/Philosopher2.java | package org.lab04;
// 2. Rozwiązanie z możliwością zagłodzenia. Każdy filozof sprawdza czy oba sąsiednie widelce są wolne i dopiero wtedy
// zajmuje je jednocześnie. Rozwiązanie to jest wolne od blokady, jednak w przypadku, gdy zawsze któryś z sąsiadów
// będzie zajęty jedzeniem, nastąpi zagłodzenie, gdyż oba widelce nigdy nie będą wolne.
public class Philosopher2 extends Philosopher {
public Philosopher2(Fork leftFork, Fork rightFork, WaitTimer timer) {
super(leftFork, rightFork, timer);
}
@Override
public void run() {
long startTime = System.nanoTime();
long acquisitionTime;
long waitingTime = 0;
long waitingCount = 0;
while (!Thread.currentThread().isInterrupted()) {
if (leftFork.lock.tryLock() && rightFork.lock.tryLock()) {
acquisitionTime = System.nanoTime();
this.printBothForksLifted();
leftFork.lock.unlock();
rightFork.lock.unlock();
waitingTime += acquisitionTime - startTime;
waitingCount++;
startTime = System.nanoTime();
} else {
if (leftFork.lock.isHeldByCurrentThread()){
leftFork.lock.unlock();
}
if (rightFork.lock.isHeldByCurrentThread()){
rightFork.lock.unlock();
}
}
}
timer.addTime(this.id, waitingTime, waitingCount);
}
} | // zajmuje je jednocześnie. Rozwiązanie to jest wolne od blokady, jednak w przypadku, gdy zawsze któryś z sąsiadów | package org.lab04;
// 2. Rozwiązanie z możliwością zagłodzenia. Każdy filozof sprawdza czy oba sąsiednie widelce są wolne i dopiero wtedy
// zajmuje je <SUF>
// będzie zajęty jedzeniem, nastąpi zagłodzenie, gdyż oba widelce nigdy nie będą wolne.
public class Philosopher2 extends Philosopher {
public Philosopher2(Fork leftFork, Fork rightFork, WaitTimer timer) {
super(leftFork, rightFork, timer);
}
@Override
public void run() {
long startTime = System.nanoTime();
long acquisitionTime;
long waitingTime = 0;
long waitingCount = 0;
while (!Thread.currentThread().isInterrupted()) {
if (leftFork.lock.tryLock() && rightFork.lock.tryLock()) {
acquisitionTime = System.nanoTime();
this.printBothForksLifted();
leftFork.lock.unlock();
rightFork.lock.unlock();
waitingTime += acquisitionTime - startTime;
waitingCount++;
startTime = System.nanoTime();
} else {
if (leftFork.lock.isHeldByCurrentThread()){
leftFork.lock.unlock();
}
if (rightFork.lock.isHeldByCurrentThread()){
rightFork.lock.unlock();
}
}
}
timer.addTime(this.id, waitingTime, waitingCount);
}
} | t |
3439_1 | javastartpl/java-akpk1 | 471 | 21/src/pl/javastart/library/model/Library.java | package pl.javastart.library.model;
import pl.javastart.library.exception.PublicationAlreadyExistsException;
import pl.javastart.library.exception.UserAlreadyExistsException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
public class Library implements Serializable {
//zmieniony typ
private Map<String, Publication> publications = new HashMap<>();
//dodane
private Map<String, LibraryUser> users = new HashMap<>();
//zmieniony typ zwracany
public Map<String, Publication> getPublications() {
return publications;
}
//dodany getter
public Map<String, LibraryUser> getUsers() {
return users;
}
//dodana metoda i rzucany nowy typ wyjątku
public void addUser(LibraryUser user) {
if(users.containsKey(user.getPesel()))
throw new UserAlreadyExistsException(
"Użytkownik ze wskazanym peselem już istnieje " + user.getPesel()
);
users.put(user.getPesel(), user);
}
//zmieniona logika
public void addPublication(Publication publication) {
if(publications.containsKey(publication.getTitle()))
throw new PublicationAlreadyExistsException(
"Publikacja o takim tytule już istnieje " + publication.getTitle()
);
publications.put(publication.getTitle(), publication);
}
//zmieniona logika
public boolean removePublication(Publication publication) {
if(publications.containsValue(publication)) {
publications.remove(publication.getTitle());
return true;
} else {
return false;
}
}
} | //dodana metoda i rzucany nowy typ wyjątku | package pl.javastart.library.model;
import pl.javastart.library.exception.PublicationAlreadyExistsException;
import pl.javastart.library.exception.UserAlreadyExistsException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
public class Library implements Serializable {
//zmieniony typ
private Map<String, Publication> publications = new HashMap<>();
//dodane
private Map<String, LibraryUser> users = new HashMap<>();
//zmieniony typ zwracany
public Map<String, Publication> getPublications() {
return publications;
}
//dodany getter
public Map<String, LibraryUser> getUsers() {
return users;
}
//dodana metoda <SUF>
public void addUser(LibraryUser user) {
if(users.containsKey(user.getPesel()))
throw new UserAlreadyExistsException(
"Użytkownik ze wskazanym peselem już istnieje " + user.getPesel()
);
users.put(user.getPesel(), user);
}
//zmieniona logika
public void addPublication(Publication publication) {
if(publications.containsKey(publication.getTitle()))
throw new PublicationAlreadyExistsException(
"Publikacja o takim tytule już istnieje " + publication.getTitle()
);
publications.put(publication.getTitle(), publication);
}
//zmieniona logika
public boolean removePublication(Publication publication) {
if(publications.containsValue(publication)) {
publications.remove(publication.getTitle());
return true;
} else {
return false;
}
}
} | t |
3799_10 | jbzdak/genie-connector | 2,457 | src/main/java/cx/jbzdak/diesIrae/genieConnector/GenieLibrary.java | /*
* GenieConnector java library to connect with
* Canberra Genie 2000 library
* Copyright (C) 2009 - 2010 Jacek Bzdak jbzdak@gmail.com
*
* This program was written for my BA in Faculty of Physics of
* Warsaw University of Technology.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package cx.jbzdak.diesIrae.genieConnector;
import com.sun.jna.Library;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;
import com.sun.jna.ptr.DoubleByReference;
import com.sun.jna.ptr.NativeLongByReference;
import com.sun.jna.ptr.PointerByReference;
import com.sun.jna.ptr.ShortByReference;
import cx.jbzdak.diesIrae.genieConnector.structs.DSQuery;
@SuppressWarnings({"MethodWithTooManyParameters", "UnusedReturnValue"})
interface GenieLibrary extends Library {
/**
* Inicjalizuje środowisko z danych z rejestru
*/
public void vG2KEnv();
/**
* Inicjalizuje hDsc
*
* @param hDSC Inicjalizowany wskaźnik na źródło danych
* @param zero Parametr który musi być zerem
* @param zero2 Kolejny parametr który musi być zerem
* @return zero jak OK inaczej że źle
*/
@SuppressWarnings({"SameParameterValue"})
public int iUtlCreateFileDSC(PointerByReference hDSC, int zero, int zero2);
/**
* Inicjalizuje hDsc
*
* @param hDSC Inicjalizowany wskaźnik na źródło danych
* @param zero Parametr który musi być zerem
* @param zero2 Kolejny parametr który musi być zerem
* @return zero jak OK inaczej że źle
*/
@SuppressWarnings({"SameParameterValue"})
public int iUtlCreateFileDSC2(PointerByReference hDSC, int zero, int zero2);
/**
* @param dscPointer dsc którego status sobie czytamy
* @param result wynik działania
* @param dummy1 coś co musi tam być, ale się nie wykorzystuje
* @param dummy2 patrz dummy1
* @return nie wiem co zwraca --- error kod sprawdzenia błędu?? Dokumentacja po stronie C jest niepełna w tym zkresie
*/
public short SadGetStatus(DscPointer dscPointer, NativeLongByReference result, ShortByReference dummy1, ShortByReference dummy2);
/**
* Otwiera źródło danych
*
* @param dsc dsc dla ktorego otwieramy dataSource
* @param sourceName nazwa źródła (moze być kwalifikowana nazwa pliku (bez spacji w środku??)), albo nazwa detektora.
* @param type typ
* @param acces tryb dostępu
* @param verify to nie wiem.
* @param shellId dla nas ""
* @return kod błędu
*/
public short SadOpenDataSource(DscPointer dsc, String sourceName, short type, short acces, short verify, String shellId);
/**
* Zwraca wartość parametru
*
* @param hDSC źródło
* @param ulParam kod parametru
* @param usRecord rekord
* @param usEntry entry
* @param result tutaj zapiszemy wynik
* @param usExpect rozmiar <code>result</code> w bajtach
* @return kod błedu.
*/
public short SadGetParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, byte[] result, short usExpect);
/**
* Zwraca wartość parametru
*
* @param hDSC źródło
* @param ulParam kod parametru
* @param usRecord rekord
* @param usEntry entry
* @param result tutaj zapiszemy wynik
* @param usExpect rozmiar <code>result</code> w bajtach
* @return kod błedu.
*/
public short SadGetParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, NativeLongByReference result, short usExpect);
public short SadGetParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, DoubleByReference result, short usExpect);
/**
* Ustawia parametr CAMA
*
* @param hDSC źródło
* @param ulParam kod parametru
* @param usRecord rekord
* @param usEntry entru
* @param result dane do zapisania
* @param usExpect rozmiar danych w bajtach
* @return kod błędu
*/
public short SadPutParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, byte[] result, short usExpect);
public short SadPutParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, NativeLongByReference result, short usExpect);
public short SadPutParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, DoubleByReference result, short usExpect);
/**
* Zamyka żródło danych otwarte przes DSC
*
* @param dsc dsc
* @return kod błędu
*/
public short SadCloseDataSource(DscPointer dsc);
/**
* Dealokuje ten kawałek biblioteki :)
*
* @param dsc dsc
* @return kod błędu
*/
public short SadDeleteDSC(DscPointer dsc);
/**
* @param sdc
* @param structType
* @param record
* @param entry
* @param ptr
* @param structSize
* @return
*/
public short SadPutStruct(DscPointer sdc, short structType, short record, short entry, Pointer ptr, short structSize);
/**
* @param sdc
* @param structType
* @param record
* @param entry
* @param ptr
* @param structSize
* @return
*/
public short SadPutStruct(DscPointer sdc, short structType, short record, short entry, Structure str, short structSize);
/**
* Powoduje wyplucie danych do pliku/urządzenia
*
* @param dsc dsc
* @return kod błędu
*/
public short SadFlush(DscPointer dsc);
/**
* Ustawia stru
*
* @param dsc
* @param usDevice
* @param usOpCode
* @return
*/
public short SadControlDSC(DscPointer dsc, short usDevice, short usOpCode);
/**
* Pobiera spektralne dane
*
* @param dsc żródło danych
* @param start pierwszy kanał
* @param count ilość kanałów do zapisania --- max 4000 na raz przy jednym wywołaniu
* @param useFloats 1 jeśli wybnik ma być zwrocony jako dana zmienniprzecinkowa
* @param result wynik działania
* @return kod błędu
*/
public short SadGetSpectrum(DscPointer dsc, short start, short count, short useFloats, int[] result);
/**
* Pobiera spektralne dane
*
* @param dsc żródło danych
* @param start pierwszy kanał
* @param count ilość kanałów do zapisania --- max 4000 na raz przy jednym wywołaniu
* @param input dane
* @return kod błędu
*/
public short SadPutSpectrum(DscPointer dsc, short start, short count, int[] input);
/**
* Zwraca stan źródła danych
*
* @param dscPointer żródło danych
* @param opCode typ danych do zwrócenia
* @param result wyniyk
* @return kod błędu
*/
public short SadQueryDataSource(DscPointer dscPointer, short opCode, DSQuery result);
}
| /**
* Dealokuje ten kawałek biblioteki :)
*
* @param dsc dsc
* @return kod błędu
*/ | /*
* GenieConnector java library to connect with
* Canberra Genie 2000 library
* Copyright (C) 2009 - 2010 Jacek Bzdak jbzdak@gmail.com
*
* This program was written for my BA in Faculty of Physics of
* Warsaw University of Technology.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package cx.jbzdak.diesIrae.genieConnector;
import com.sun.jna.Library;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;
import com.sun.jna.ptr.DoubleByReference;
import com.sun.jna.ptr.NativeLongByReference;
import com.sun.jna.ptr.PointerByReference;
import com.sun.jna.ptr.ShortByReference;
import cx.jbzdak.diesIrae.genieConnector.structs.DSQuery;
@SuppressWarnings({"MethodWithTooManyParameters", "UnusedReturnValue"})
interface GenieLibrary extends Library {
/**
* Inicjalizuje środowisko z danych z rejestru
*/
public void vG2KEnv();
/**
* Inicjalizuje hDsc
*
* @param hDSC Inicjalizowany wskaźnik na źródło danych
* @param zero Parametr który musi być zerem
* @param zero2 Kolejny parametr który musi być zerem
* @return zero jak OK inaczej że źle
*/
@SuppressWarnings({"SameParameterValue"})
public int iUtlCreateFileDSC(PointerByReference hDSC, int zero, int zero2);
/**
* Inicjalizuje hDsc
*
* @param hDSC Inicjalizowany wskaźnik na źródło danych
* @param zero Parametr który musi być zerem
* @param zero2 Kolejny parametr który musi być zerem
* @return zero jak OK inaczej że źle
*/
@SuppressWarnings({"SameParameterValue"})
public int iUtlCreateFileDSC2(PointerByReference hDSC, int zero, int zero2);
/**
* @param dscPointer dsc którego status sobie czytamy
* @param result wynik działania
* @param dummy1 coś co musi tam być, ale się nie wykorzystuje
* @param dummy2 patrz dummy1
* @return nie wiem co zwraca --- error kod sprawdzenia błędu?? Dokumentacja po stronie C jest niepełna w tym zkresie
*/
public short SadGetStatus(DscPointer dscPointer, NativeLongByReference result, ShortByReference dummy1, ShortByReference dummy2);
/**
* Otwiera źródło danych
*
* @param dsc dsc dla ktorego otwieramy dataSource
* @param sourceName nazwa źródła (moze być kwalifikowana nazwa pliku (bez spacji w środku??)), albo nazwa detektora.
* @param type typ
* @param acces tryb dostępu
* @param verify to nie wiem.
* @param shellId dla nas ""
* @return kod błędu
*/
public short SadOpenDataSource(DscPointer dsc, String sourceName, short type, short acces, short verify, String shellId);
/**
* Zwraca wartość parametru
*
* @param hDSC źródło
* @param ulParam kod parametru
* @param usRecord rekord
* @param usEntry entry
* @param result tutaj zapiszemy wynik
* @param usExpect rozmiar <code>result</code> w bajtach
* @return kod błedu.
*/
public short SadGetParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, byte[] result, short usExpect);
/**
* Zwraca wartość parametru
*
* @param hDSC źródło
* @param ulParam kod parametru
* @param usRecord rekord
* @param usEntry entry
* @param result tutaj zapiszemy wynik
* @param usExpect rozmiar <code>result</code> w bajtach
* @return kod błedu.
*/
public short SadGetParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, NativeLongByReference result, short usExpect);
public short SadGetParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, DoubleByReference result, short usExpect);
/**
* Ustawia parametr CAMA
*
* @param hDSC źródło
* @param ulParam kod parametru
* @param usRecord rekord
* @param usEntry entru
* @param result dane do zapisania
* @param usExpect rozmiar danych w bajtach
* @return kod błędu
*/
public short SadPutParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, byte[] result, short usExpect);
public short SadPutParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, NativeLongByReference result, short usExpect);
public short SadPutParam(DscPointer hDSC, NativeLong ulParam, short usRecord, short usEntry, DoubleByReference result, short usExpect);
/**
* Zamyka żródło danych otwarte przes DSC
*
* @param dsc dsc
* @return kod błędu
*/
public short SadCloseDataSource(DscPointer dsc);
/**
* Dealokuje ten kawałek <SUF>*/
public short SadDeleteDSC(DscPointer dsc);
/**
* @param sdc
* @param structType
* @param record
* @param entry
* @param ptr
* @param structSize
* @return
*/
public short SadPutStruct(DscPointer sdc, short structType, short record, short entry, Pointer ptr, short structSize);
/**
* @param sdc
* @param structType
* @param record
* @param entry
* @param ptr
* @param structSize
* @return
*/
public short SadPutStruct(DscPointer sdc, short structType, short record, short entry, Structure str, short structSize);
/**
* Powoduje wyplucie danych do pliku/urządzenia
*
* @param dsc dsc
* @return kod błędu
*/
public short SadFlush(DscPointer dsc);
/**
* Ustawia stru
*
* @param dsc
* @param usDevice
* @param usOpCode
* @return
*/
public short SadControlDSC(DscPointer dsc, short usDevice, short usOpCode);
/**
* Pobiera spektralne dane
*
* @param dsc żródło danych
* @param start pierwszy kanał
* @param count ilość kanałów do zapisania --- max 4000 na raz przy jednym wywołaniu
* @param useFloats 1 jeśli wybnik ma być zwrocony jako dana zmienniprzecinkowa
* @param result wynik działania
* @return kod błędu
*/
public short SadGetSpectrum(DscPointer dsc, short start, short count, short useFloats, int[] result);
/**
* Pobiera spektralne dane
*
* @param dsc żródło danych
* @param start pierwszy kanał
* @param count ilość kanałów do zapisania --- max 4000 na raz przy jednym wywołaniu
* @param input dane
* @return kod błędu
*/
public short SadPutSpectrum(DscPointer dsc, short start, short count, int[] input);
/**
* Zwraca stan źródła danych
*
* @param dscPointer żródło danych
* @param opCode typ danych do zwrócenia
* @param result wyniyk
* @return kod błędu
*/
public short SadQueryDataSource(DscPointer dscPointer, short opCode, DSQuery result);
}
| t |
3755_1 | jedrekf/Agents-mobility | 517 | src/agents/runnerAgent/behaviours/LocalBehaviour.java | package agents.runnerAgent.behaviours;
import jade.core.AID;
import jade.core.behaviours.CyclicBehaviour;
import jade.lang.acl.ACLMessage;
import jade.lang.acl.MessageTemplate;
/**
* Created by jedrek on 01.05.16.
* Receives messages:
* If a message comes from judge (start race) it swaps a behaviour to runner
* If a message comes from runner it responds with confirm and swaps to runner
*/
public class LocalBehaviour extends CyclicBehaviour{
/*
nie wiem czy te templaty tak działają
czasami dajesz block(); czasami nie
*/
@Override
public void action() {
MessageTemplate msgStartTemplate = MessageTemplate.MatchPerformative(ACLMessage.REQUEST);
ACLMessage msgStart = myAgent.receive(msgStartTemplate);
if(msgStart != null) {
myAgent.addBehaviour(new RunnerBehaviour());
//System.out.println("started the run");
myAgent.removeBehaviour(this);
}else{
//other messages will not start flowing untill the REQUEST start message from judge doesn't come
MessageTemplate msgRunnerTemplate = MessageTemplate.MatchPerformative(ACLMessage.INFORM);
ACLMessage msgFromRunner = myAgent.receive(msgRunnerTemplate);
if(msgFromRunner != null) {
ACLMessage replymsg = msgFromRunner.createReply();
replymsg.setPerformative(ACLMessage.CONFIRM);
myAgent.send(replymsg);
// System.out.println(myAgent.getLocalName() + "received message from runner "+
// msgFromRunner.getSender().getLocalName() + " , confirming and starting to run");
myAgent.addBehaviour(new RunnerBehaviour());
myAgent.removeBehaviour(this);
}else{
// block();
}
}
}
}
| /*
nie wiem czy te templaty tak działają
czasami dajesz block(); czasami nie
*/ | package agents.runnerAgent.behaviours;
import jade.core.AID;
import jade.core.behaviours.CyclicBehaviour;
import jade.lang.acl.ACLMessage;
import jade.lang.acl.MessageTemplate;
/**
* Created by jedrek on 01.05.16.
* Receives messages:
* If a message comes from judge (start race) it swaps a behaviour to runner
* If a message comes from runner it responds with confirm and swaps to runner
*/
public class LocalBehaviour extends CyclicBehaviour{
/*
nie wiem czy <SUF>*/
@Override
public void action() {
MessageTemplate msgStartTemplate = MessageTemplate.MatchPerformative(ACLMessage.REQUEST);
ACLMessage msgStart = myAgent.receive(msgStartTemplate);
if(msgStart != null) {
myAgent.addBehaviour(new RunnerBehaviour());
//System.out.println("started the run");
myAgent.removeBehaviour(this);
}else{
//other messages will not start flowing untill the REQUEST start message from judge doesn't come
MessageTemplate msgRunnerTemplate = MessageTemplate.MatchPerformative(ACLMessage.INFORM);
ACLMessage msgFromRunner = myAgent.receive(msgRunnerTemplate);
if(msgFromRunner != null) {
ACLMessage replymsg = msgFromRunner.createReply();
replymsg.setPerformative(ACLMessage.CONFIRM);
myAgent.send(replymsg);
// System.out.println(myAgent.getLocalName() + "received message from runner "+
// msgFromRunner.getSender().getLocalName() + " , confirming and starting to run");
myAgent.addBehaviour(new RunnerBehaviour());
myAgent.removeBehaviour(this);
}else{
// block();
}
}
}
}
| t |
8204_3 | jkaleba/EvolutionSimulation | 1,455 | oolab/src/main/java/agh/ics/oop/model/Animal.java | package agh.ics.oop.model;
import agh.ics.oop.model.genome.BasicGenome;
import agh.ics.oop.model.genome.Genome;
import agh.ics.oop.model.map.MapDirection;
import agh.ics.oop.model.map.MoveValidator;
import agh.ics.oop.model.map.Vector2d;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Animal implements WorldElement, Comparable<Animal> {
private MapDirection orientation;
private Vector2d position;
private final Genome genome;
private int energy;
private final ArrayList<Animal> children = new ArrayList<>();
private final int dayOfBirth;
private int dayOfDeath = -1;
private int plantsEaten = 0;
private static final MapDirection[] directions = MapDirection.values();
private final Random random = new Random();
public Animal(Vector2d position, int energy, int dayOfBirth, int genomeLength) {
this.position = position;
this.orientation = directions[random.nextInt(directions.length)];
this.energy = energy;
this.dayOfBirth = dayOfBirth;
this.genome = new BasicGenome(genomeLength);
}
public Animal(Vector2d position, int energy, int dayOfBirth, Genome genome) {
this.position = position;
this.orientation = directions[random.nextInt(directions.length)];
this.energy = energy;
this.dayOfBirth = dayOfBirth;
this.genome = genome;
}
public int useCurrentAnimalGene() {
return genome.useCurrentGene();
}
public void setDayOfDeath(int day) {
this.dayOfDeath = day;
}
public boolean isDead() {
return energy<=0;
}
public int getEnergy() {
return energy;
}
public int getPlantsEatenCount() {
return plantsEaten;
}
public int getChildrenCount() {
return children.size();
}
public int getDayOfBirth() {
return dayOfBirth;
}
public int getDayOfDeath() {
return dayOfDeath;
}
public int getLifeLength() {
return dayOfDeath - dayOfBirth;
}
public void eatPlant(int plantEnergy) {
this.energy += plantEnergy;
this.plantsEaten++;
}
public String toString() {
return orientation.toString();
}
@Override
public Vector2d position() {
return this.position;
}
public boolean move(MoveValidator validator) {
Vector2d oldPosition = this.position;
MapDirection newOrientation = this.orientation.rotate(this.useCurrentAnimalGene());
Vector2d newPosition = this.position.add(newOrientation.toUnitVector());
if (validator.canMoveTo(newPosition)) {
this.position = newPosition;
this.orientation = newOrientation;
}
else {
this.orientation = newOrientation.opposite();
}
return !this.position.equals(oldPosition);
}
public void useEnergy (int energyToUse) {
energy -= energyToUse;
}
public void addChild(Animal animal) { //tutaj ewentualnie przerobic, zeby przyjmowalo animala i dodawalo mu do listy
children.add(animal);
}
public void setPosition (Vector2d position) {
this.position = position;
}
public Genome getGenome() {
return genome;
}
@Override
public int compareTo(Animal animal) {
if (animal==this)
return 0;
// Porównywanie energii
int energyComparison = Integer.compare(this.getEnergy(), animal.getEnergy());
if (energyComparison != 0) {
return energyComparison;
}
// Jeżeli energia jest taka sama, porównujemy wiek
int birthComparison = Integer.compare(this.getDayOfBirth(), animal.getDayOfBirth());
if (birthComparison != 0) {
return -birthComparison;
}
// Jeżeli wiek też jest taki sam, porównujemy liczbę dzieci
int childrenComparison = Integer.compare(this.getChildrenCount(), animal.getChildrenCount());
if (childrenComparison != 0) {
return childrenComparison;
}
// Jeżeli liczba dzieci też jest taka sama, zwracamy losowy wynik
return Math.random() < 0.5 ? -1 : 1;
}
private List<Animal> getDescendants() {
return children.stream()
.flatMap(child -> Stream.concat(
Stream.of(child), child.getDescendants().stream()))
.collect(Collectors.toList());
}
protected List<Animal> getAliveDescendants() {
return getDescendants().stream().filter(animal -> animal.getDayOfDeath() == -1).toList();
}
public int getDescendantsNumber() {
return getDescendants().size();
}
public int getAliveDescendantsNumber() {
return getAliveDescendants().size();
}
}
| // Jeżeli liczba dzieci też jest taka sama, zwracamy losowy wynik | package agh.ics.oop.model;
import agh.ics.oop.model.genome.BasicGenome;
import agh.ics.oop.model.genome.Genome;
import agh.ics.oop.model.map.MapDirection;
import agh.ics.oop.model.map.MoveValidator;
import agh.ics.oop.model.map.Vector2d;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Animal implements WorldElement, Comparable<Animal> {
private MapDirection orientation;
private Vector2d position;
private final Genome genome;
private int energy;
private final ArrayList<Animal> children = new ArrayList<>();
private final int dayOfBirth;
private int dayOfDeath = -1;
private int plantsEaten = 0;
private static final MapDirection[] directions = MapDirection.values();
private final Random random = new Random();
public Animal(Vector2d position, int energy, int dayOfBirth, int genomeLength) {
this.position = position;
this.orientation = directions[random.nextInt(directions.length)];
this.energy = energy;
this.dayOfBirth = dayOfBirth;
this.genome = new BasicGenome(genomeLength);
}
public Animal(Vector2d position, int energy, int dayOfBirth, Genome genome) {
this.position = position;
this.orientation = directions[random.nextInt(directions.length)];
this.energy = energy;
this.dayOfBirth = dayOfBirth;
this.genome = genome;
}
public int useCurrentAnimalGene() {
return genome.useCurrentGene();
}
public void setDayOfDeath(int day) {
this.dayOfDeath = day;
}
public boolean isDead() {
return energy<=0;
}
public int getEnergy() {
return energy;
}
public int getPlantsEatenCount() {
return plantsEaten;
}
public int getChildrenCount() {
return children.size();
}
public int getDayOfBirth() {
return dayOfBirth;
}
public int getDayOfDeath() {
return dayOfDeath;
}
public int getLifeLength() {
return dayOfDeath - dayOfBirth;
}
public void eatPlant(int plantEnergy) {
this.energy += plantEnergy;
this.plantsEaten++;
}
public String toString() {
return orientation.toString();
}
@Override
public Vector2d position() {
return this.position;
}
public boolean move(MoveValidator validator) {
Vector2d oldPosition = this.position;
MapDirection newOrientation = this.orientation.rotate(this.useCurrentAnimalGene());
Vector2d newPosition = this.position.add(newOrientation.toUnitVector());
if (validator.canMoveTo(newPosition)) {
this.position = newPosition;
this.orientation = newOrientation;
}
else {
this.orientation = newOrientation.opposite();
}
return !this.position.equals(oldPosition);
}
public void useEnergy (int energyToUse) {
energy -= energyToUse;
}
public void addChild(Animal animal) { //tutaj ewentualnie przerobic, zeby przyjmowalo animala i dodawalo mu do listy
children.add(animal);
}
public void setPosition (Vector2d position) {
this.position = position;
}
public Genome getGenome() {
return genome;
}
@Override
public int compareTo(Animal animal) {
if (animal==this)
return 0;
// Porównywanie energii
int energyComparison = Integer.compare(this.getEnergy(), animal.getEnergy());
if (energyComparison != 0) {
return energyComparison;
}
// Jeżeli energia jest taka sama, porównujemy wiek
int birthComparison = Integer.compare(this.getDayOfBirth(), animal.getDayOfBirth());
if (birthComparison != 0) {
return -birthComparison;
}
// Jeżeli wiek też jest taki sam, porównujemy liczbę dzieci
int childrenComparison = Integer.compare(this.getChildrenCount(), animal.getChildrenCount());
if (childrenComparison != 0) {
return childrenComparison;
}
// Jeżeli liczba <SUF>
return Math.random() < 0.5 ? -1 : 1;
}
private List<Animal> getDescendants() {
return children.stream()
.flatMap(child -> Stream.concat(
Stream.of(child), child.getDescendants().stream()))
.collect(Collectors.toList());
}
protected List<Animal> getAliveDescendants() {
return getDescendants().stream().filter(animal -> animal.getDayOfDeath() == -1).toList();
}
public int getDescendantsNumber() {
return getDescendants().size();
}
public int getAliveDescendantsNumber() {
return getAliveDescendants().size();
}
}
| t |
3500_3 | jmardyla/pz1 | 361 | lab14-zombie/src/Sprite.java | import javax.swing.*;
import java.awt.*;
public interface Sprite {
/**
* Rysuje postać
*
* @param g
* @param parent
*/
void draw(Graphics g, JPanel parent);
/**
* Przechodzi do następnej klatki
*/
void next();
/**
* Czy już zniknął z ekranu
*
* @return
*/
default boolean isVisble() {
return true;
}
/**
* Czy punkt o współrzędnych _x, _y leży w obszarze postaci -
* czyli czy trafiliśmy ją strzelając w punkcie o tych współrzednych
*
* @param _x
* @param _y
* @return
*/
default boolean isHit(int _x, int _y) {
return false;
}
/**
* Czy jest bliżej widza niż other, czyli w naszym przypadku czy jest większy,
* czyli ma wiekszą skalę...
*
* @param other
* @return
*/
default boolean isCloser(Sprite other) {
return false;
}
} | /**
* Czy punkt o współrzędnych _x, _y leży w obszarze postaci -
* czyli czy trafiliśmy ją strzelając w punkcie o tych współrzednych
*
* @param _x
* @param _y
* @return
*/ | import javax.swing.*;
import java.awt.*;
public interface Sprite {
/**
* Rysuje postać
*
* @param g
* @param parent
*/
void draw(Graphics g, JPanel parent);
/**
* Przechodzi do następnej klatki
*/
void next();
/**
* Czy już zniknął z ekranu
*
* @return
*/
default boolean isVisble() {
return true;
}
/**
* Czy punkt o <SUF>*/
default boolean isHit(int _x, int _y) {
return false;
}
/**
* Czy jest bliżej widza niż other, czyli w naszym przypadku czy jest większy,
* czyli ma wiekszą skalę...
*
* @param other
* @return
*/
default boolean isCloser(Sprite other) {
return false;
}
} | t |
6222_2 | jmatoga/Tower_Defense_Game | 770 | src/help/ImgFix.java | package help;
import java.awt.*;
import java.awt.image.BufferedImage;
public class ImgFix {
/**
* Rotacja spiritsów (o wielokrotności 90 stopni)
* @param img Obraz obracany
* @param rotAngle Stopnie rotacji
* @return Obrócony obrazek
*/
public static BufferedImage getRotImg(BufferedImage img, int rotAngle){
int w = img.getWidth();
int h = img.getHeight();
BufferedImage newImg = new BufferedImage(w, h, img.getType());
Graphics2D g2d = newImg.createGraphics();
g2d.rotate(Math.toRadians(rotAngle), w/2, h/2 ); //koordynaty spirita wokół których rotacja
g2d.drawImage(img, 0, 0,null);
g2d.dispose();
return newImg;
}
/**
* Dodawawanie więcej niż jednego obrazka w jedym miejscu
* @param imgs Tablica obiektów do nałożenia na siebie
* @return Zwraca nowy obiekt (obrazek)
*/
public static BufferedImage buildImg(BufferedImage[] imgs){
int w = imgs[0].getWidth();
int h = imgs[0].getHeight();
BufferedImage newImg = new BufferedImage(w, h, imgs[0].getType());
Graphics2D g2d = newImg.createGraphics();
for(BufferedImage i : imgs){
g2d.drawImage(i, 0, 0, null);
}
g2d.dispose();
return newImg;
}
/**
* Rotacja tylko drugiego obrazka
* @param imgs Tablica obiektów do nałożenia na siebie
* @param rotAngle Stopnie rotacji
* @param rotAtIndex Który indeks obracać
* @return Obrócony obrazek
*/
public static BufferedImage getBuildRotImg(BufferedImage[] imgs, int rotAngle, int rotAtIndex){
int w = imgs[0].getWidth();
int h = imgs[0].getHeight();
BufferedImage newImg = new BufferedImage(w, h, imgs[0].getType());
Graphics2D g2d = newImg.createGraphics();
for(int i=0; i < imgs.length; i++){
if(rotAtIndex == i)
g2d.rotate(Math.toRadians(rotAngle), w/2, h/2 );
g2d.drawImage(imgs[i],0,0,null);
if(rotAtIndex == i)
g2d.rotate(Math.toRadians(rotAngle), w/2, h/2 ); //obracamy ponownie "na miejsce", żeby następny obrazek nie był obrócony
}
g2d.dispose();
return newImg;
}
}
| /**
* Dodawawanie więcej niż jednego obrazka w jedym miejscu
* @param imgs Tablica obiektów do nałożenia na siebie
* @return Zwraca nowy obiekt (obrazek)
*/ | package help;
import java.awt.*;
import java.awt.image.BufferedImage;
public class ImgFix {
/**
* Rotacja spiritsów (o wielokrotności 90 stopni)
* @param img Obraz obracany
* @param rotAngle Stopnie rotacji
* @return Obrócony obrazek
*/
public static BufferedImage getRotImg(BufferedImage img, int rotAngle){
int w = img.getWidth();
int h = img.getHeight();
BufferedImage newImg = new BufferedImage(w, h, img.getType());
Graphics2D g2d = newImg.createGraphics();
g2d.rotate(Math.toRadians(rotAngle), w/2, h/2 ); //koordynaty spirita wokół których rotacja
g2d.drawImage(img, 0, 0,null);
g2d.dispose();
return newImg;
}
/**
* Dodawawanie więcej niż <SUF>*/
public static BufferedImage buildImg(BufferedImage[] imgs){
int w = imgs[0].getWidth();
int h = imgs[0].getHeight();
BufferedImage newImg = new BufferedImage(w, h, imgs[0].getType());
Graphics2D g2d = newImg.createGraphics();
for(BufferedImage i : imgs){
g2d.drawImage(i, 0, 0, null);
}
g2d.dispose();
return newImg;
}
/**
* Rotacja tylko drugiego obrazka
* @param imgs Tablica obiektów do nałożenia na siebie
* @param rotAngle Stopnie rotacji
* @param rotAtIndex Który indeks obracać
* @return Obrócony obrazek
*/
public static BufferedImage getBuildRotImg(BufferedImage[] imgs, int rotAngle, int rotAtIndex){
int w = imgs[0].getWidth();
int h = imgs[0].getHeight();
BufferedImage newImg = new BufferedImage(w, h, imgs[0].getType());
Graphics2D g2d = newImg.createGraphics();
for(int i=0; i < imgs.length; i++){
if(rotAtIndex == i)
g2d.rotate(Math.toRadians(rotAngle), w/2, h/2 );
g2d.drawImage(imgs[i],0,0,null);
if(rotAtIndex == i)
g2d.rotate(Math.toRadians(rotAngle), w/2, h/2 ); //obracamy ponownie "na miejsce", żeby następny obrazek nie był obrócony
}
g2d.dispose();
return newImg;
}
}
| t |
5287_1 | jmolinski/po | 373 | cover/src/cover/Main.java | package cover;
import java.util.*;
public class Main {
private static void executeQuery(Query query, List<ISet> sets) {
var result = new ArrayList<>(query.execute(sets));
if (result.size() == 1 && result.get(0) == -1) {
// Pokrycie zbioru niemożliwe.
System.out.println(0);
} else {
Collections.sort(result);
for (int i = 0; i < result.size(); i++) {
System.out.print(result.get(i) + 1); // Sety są liczone od 1, nie od 0.
if (i != result.size() - 1)
System.out.print(" ");
}
System.out.println();
}
}
public static void main(String[] args) {
var scanner = new Scanner(System.in);
var tokens = new ArrayList<Integer>();
while (scanner.hasNext() && scanner.hasNextInt()) {
tokens.add(scanner.nextInt());
}
var parser = new InputParser(tokens);
var sets = new ArrayList<ISet>();
while (parser.hasNextSet() || parser.hasNextQuery()) {
if (parser.hasNextSet()) {
sets.add(parser.nextSet());
} else {
executeQuery(parser.nextQuery(), sets);
}
}
}
}
| // Sety są liczone od 1, nie od 0. | package cover;
import java.util.*;
public class Main {
private static void executeQuery(Query query, List<ISet> sets) {
var result = new ArrayList<>(query.execute(sets));
if (result.size() == 1 && result.get(0) == -1) {
// Pokrycie zbioru niemożliwe.
System.out.println(0);
} else {
Collections.sort(result);
for (int i = 0; i < result.size(); i++) {
System.out.print(result.get(i) + 1); // Sety są <SUF>
if (i != result.size() - 1)
System.out.print(" ");
}
System.out.println();
}
}
public static void main(String[] args) {
var scanner = new Scanner(System.in);
var tokens = new ArrayList<Integer>();
while (scanner.hasNext() && scanner.hasNextInt()) {
tokens.add(scanner.nextInt());
}
var parser = new InputParser(tokens);
var sets = new ArrayList<ISet>();
while (parser.hasNextSet() || parser.hasNextQuery()) {
if (parser.hasNextSet()) {
sets.add(parser.nextSet());
} else {
executeQuery(parser.nextQuery(), sets);
}
}
}
}
| t |
3863_2 | jpomykala/PaxCosmica | 134 | core/src/pl/evelanblog/enums/GameState.java | package pl.evelanblog.enums;
/**
* Created by Evelan on 09-02-2015 - 21:31
*/
public enum GameState {
ongoing, // gra się toczy i jest elegancko, szczelanie etc
paused, //wcisniety przycisk pauzy -> wyswietlenie przycisków coś al'a menu
win, // wygrana
defeat, // przegrana
powermanager // power manager + pauza
}
| //wcisniety przycisk pauzy -> wyswietlenie przycisków coś al'a menu | package pl.evelanblog.enums;
/**
* Created by Evelan on 09-02-2015 - 21:31
*/
public enum GameState {
ongoing, // gra się toczy i jest elegancko, szczelanie etc
paused, //wcisniety przycisk <SUF>
win, // wygrana
defeat, // przegrana
powermanager // power manager + pauza
}
| t |
3698_11 | junsevith/lista4 | 2,539 | src/GoTile.java | import java.util.*;
public class GoTile {
/**
* Kolor kamienia na polu, jeśli null to pole jest puste
*/
private Color stoneColor = null;
/**
* Tablica sąsiadów pola
* 0 - Góra
* 1 - Dół
* 2 - Lewo
* 3 - Prawo
*/
private GoTile[] neighbors = new GoTile[4];
private final Set<GoTile> breathTiles = new HashSet<>();
/**
* Licznik zbitych kamieni
*/
private final GameCounter counter;
public GoTile(GameCounter counter) {
this.counter = counter;
}
public void setNeighbors(GoTile[] neighbors) {
this.neighbors = neighbors;
}
/**
* Resetuje pole do stanu początkowego
*/
private void resetTile() {
stoneColor = null;
breathTiles.clear();
}
/**
* Zwraca kolor kamienia na polu
* Null, jeśli pole jest puste
*
* @return Kolor kamienia na polu
*/
public Color getStoneColor() {
return stoneColor;
}
/**
* Zwraca sąsiadów o danym kolorze
*
* @param color Kolor do dopasowania
* @return Lista sąsiadów o danym kolorze
*/
public List<Integer> getNeighbors(Color color) {
List<Integer> matchingNeighbors = new ArrayList<>();
for (int i = 0; i < 4; i++) {
if (neighbors[i] != null && neighbors[i].getStoneColor() == color) {
matchingNeighbors.add(i);
}
}
return matchingNeighbors;
}
/**
* Dodaje oddechy do kamienia
* @param tiles oddechy do dodania
*/
public void inheritBreath(Set<GoTile> tiles) {
breathTiles.addAll(tiles);
}
/**
* Dodaje oddech do kamienia
* @param tile oddech do dodania
*/
public void inheritBreath(GoTile tile) {
breathTiles.add(tile);
}
/**
* Odbiera oddech z danego kierunku
* @param breath odbiera oddech z tego pola
*/
public void looseBreath(GoTile breath, Set<GoTile> already) {
already.add(this);
breathTiles.remove(breath);
// Jeśli używamy checkNeighborsV2() to musi być ten warunek
// if (stoneColor == null) {
// return;
// }
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if ( neighbor != null && neighbor.stoneColor == stoneColor) {
if (neighbor != breath && !already.contains(neighbor)) {
neighbor.looseBreath(breath, already);
}
}
}
if (breathTiles.isEmpty()) {
killStone();
}
}
/**
* Zabija kamień na polu
*/
private void killStone() {
counter.addCapturedStone(stoneColor);
//oddaje oddech sąsiadom przeciwnego koloru
for (Integer dir : getNeighbors(stoneColor.opposite())) {
neighbors[dir].inheritBreath(this);
}
resetTile();
}
/**
* Ustawia kamień na polu
*
* @param color Kolor kamienia
* @return True, jeśli udało się ustawić kamień
*/
public boolean placeStone(Color color) {
if (stoneColor != null) {
return false;
} else if (getNeighbors(null).isEmpty()) {
//Jeśli miejsce otoczone jest kamieniami
for (Integer direction : getNeighbors(color)) {
if (!neighbors[direction].onlyBreath(this)) {
//sprawdza, czy można odziedziczyć oddechy od sąsiadów tego samego koloru
setupStone(color);
return true;
}
}
for (Integer dir : getNeighbors(color.opposite())) {
if (neighbors[dir].onlyBreath(this)) {
//sprawdza, czy można zabić kamienie przeciwnika
setupStone(color);
return true;
}
}
//Jeśli nie można odziedziczyć oddechów ani zabić kamieni przeciwnika
//ruch spowodowałby samobójstwo, więc nie można go wykonać
return false;
} else {
setupStone(color);
return true;
}
}
/**
* Ustawia na polu kamień danego koloru
*
* @param color Kolor kamienia
*/
private void setupStone(Color color) {
stoneColor = color;
checkNeighborsV3();
}
/**
* Sprawdza sąsiadów i aktualizuje oddechy oraz zależności
*/
private void checkNeighborsV2() {
//zabiera oddechy wszystkim sąsiadom przeciwnego koloru
for (Integer direction : getNeighbors(stoneColor.opposite())) {
neighbors[direction].looseBreath(this, Set.of(this));
}
//ustawia sobie oddechy od pustych sąsiadów
for (Integer direction : getNeighbors(null)) {
this.inheritBreath(neighbors[direction]);
}
//zabiera oddechy od sąsiadów tego samego koloru
List<Integer> sameColorNeighbors = getNeighbors(stoneColor);
if (!sameColorNeighbors.isEmpty()) {
for (Integer direction : sameColorNeighbors) {
this.inheritBreath(neighbors[direction].breathTiles);
}
breathTiles.remove(this);
for (Integer direction : sameColorNeighbors) {
neighbors[direction].inheritBreath(this.breathTiles);
neighbors[direction].looseBreath(this, Set.of(this));
}
}
}
/**
* Sprawdza sąsiadów i aktualizuje oddechy oraz zależności
*/
private void checkNeighborsV3() {
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if (neighbor != null ) {
if (neighbor.stoneColor == stoneColor.opposite()) {
//zabiera oddechy od sąsiadów tego samego koloru
neighbor.looseBreath(this, new HashSet<>(Set.of(this)));
} else if (neighbor.stoneColor == null) {
//ustawia sobie oddechy od pustych sąsiadów
this.inheritBreath(neighbor);
}
}
}
if (!getNeighbors(stoneColor).isEmpty()) {
//zabiera oddechy od sąsiadów tego samego koloru
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if (neighbor != null) {
if (neighbor.stoneColor == stoneColor) {
this.inheritBreath(neighbor.breathTiles);
}
}
}
// usuwa siebie z oddechów, ponieważ dziedziczenie oddechów od sąsiadów nas tu dodało
// this.looseBreath(this, this, this);
breathTiles.remove(this);
//dodaje oddechy do sąsiadów tego samego koloru
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if (neighbor != null) {
if (neighbor.stoneColor == stoneColor) {
neighbor.inheritBreath(this.breathTiles);
neighbor.looseBreath(this, new HashSet<>(Set.of(this)));
}
}
}
}
}
/**
* Sprawdza, czy podane pole jest jedynym oddechem tego pola
* @param tile pole do sprawdzenia
* @return true, jeśli podane pole jest jedynym oddechem tego pola
*/
private boolean onlyBreath(GoTile tile) {
return breathTiles.contains(tile) && breathTiles.size() == 1;
}
public boolean countTerritory(Color color, Set<GoTile> territory) {
territory.add(this);
boolean isTerritory = true;
for (int i = 0; i < 4; i++) {
if (neighbors[i] != null) {
if (neighbors[i].getStoneColor() == null && !territory.contains(neighbors[i])){
isTerritory = isTerritory && neighbors[i].countTerritory(color, territory);
} else if (neighbors[i].getStoneColor() == color.opposite()) {
return false;
}
}
}
return isTerritory;
}
}
| /**
* Zabija kamień na polu
*/ | import java.util.*;
public class GoTile {
/**
* Kolor kamienia na polu, jeśli null to pole jest puste
*/
private Color stoneColor = null;
/**
* Tablica sąsiadów pola
* 0 - Góra
* 1 - Dół
* 2 - Lewo
* 3 - Prawo
*/
private GoTile[] neighbors = new GoTile[4];
private final Set<GoTile> breathTiles = new HashSet<>();
/**
* Licznik zbitych kamieni
*/
private final GameCounter counter;
public GoTile(GameCounter counter) {
this.counter = counter;
}
public void setNeighbors(GoTile[] neighbors) {
this.neighbors = neighbors;
}
/**
* Resetuje pole do stanu początkowego
*/
private void resetTile() {
stoneColor = null;
breathTiles.clear();
}
/**
* Zwraca kolor kamienia na polu
* Null, jeśli pole jest puste
*
* @return Kolor kamienia na polu
*/
public Color getStoneColor() {
return stoneColor;
}
/**
* Zwraca sąsiadów o danym kolorze
*
* @param color Kolor do dopasowania
* @return Lista sąsiadów o danym kolorze
*/
public List<Integer> getNeighbors(Color color) {
List<Integer> matchingNeighbors = new ArrayList<>();
for (int i = 0; i < 4; i++) {
if (neighbors[i] != null && neighbors[i].getStoneColor() == color) {
matchingNeighbors.add(i);
}
}
return matchingNeighbors;
}
/**
* Dodaje oddechy do kamienia
* @param tiles oddechy do dodania
*/
public void inheritBreath(Set<GoTile> tiles) {
breathTiles.addAll(tiles);
}
/**
* Dodaje oddech do kamienia
* @param tile oddech do dodania
*/
public void inheritBreath(GoTile tile) {
breathTiles.add(tile);
}
/**
* Odbiera oddech z danego kierunku
* @param breath odbiera oddech z tego pola
*/
public void looseBreath(GoTile breath, Set<GoTile> already) {
already.add(this);
breathTiles.remove(breath);
// Jeśli używamy checkNeighborsV2() to musi być ten warunek
// if (stoneColor == null) {
// return;
// }
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if ( neighbor != null && neighbor.stoneColor == stoneColor) {
if (neighbor != breath && !already.contains(neighbor)) {
neighbor.looseBreath(breath, already);
}
}
}
if (breathTiles.isEmpty()) {
killStone();
}
}
/**
* Zabija kamień na <SUF>*/
private void killStone() {
counter.addCapturedStone(stoneColor);
//oddaje oddech sąsiadom przeciwnego koloru
for (Integer dir : getNeighbors(stoneColor.opposite())) {
neighbors[dir].inheritBreath(this);
}
resetTile();
}
/**
* Ustawia kamień na polu
*
* @param color Kolor kamienia
* @return True, jeśli udało się ustawić kamień
*/
public boolean placeStone(Color color) {
if (stoneColor != null) {
return false;
} else if (getNeighbors(null).isEmpty()) {
//Jeśli miejsce otoczone jest kamieniami
for (Integer direction : getNeighbors(color)) {
if (!neighbors[direction].onlyBreath(this)) {
//sprawdza, czy można odziedziczyć oddechy od sąsiadów tego samego koloru
setupStone(color);
return true;
}
}
for (Integer dir : getNeighbors(color.opposite())) {
if (neighbors[dir].onlyBreath(this)) {
//sprawdza, czy można zabić kamienie przeciwnika
setupStone(color);
return true;
}
}
//Jeśli nie można odziedziczyć oddechów ani zabić kamieni przeciwnika
//ruch spowodowałby samobójstwo, więc nie można go wykonać
return false;
} else {
setupStone(color);
return true;
}
}
/**
* Ustawia na polu kamień danego koloru
*
* @param color Kolor kamienia
*/
private void setupStone(Color color) {
stoneColor = color;
checkNeighborsV3();
}
/**
* Sprawdza sąsiadów i aktualizuje oddechy oraz zależności
*/
private void checkNeighborsV2() {
//zabiera oddechy wszystkim sąsiadom przeciwnego koloru
for (Integer direction : getNeighbors(stoneColor.opposite())) {
neighbors[direction].looseBreath(this, Set.of(this));
}
//ustawia sobie oddechy od pustych sąsiadów
for (Integer direction : getNeighbors(null)) {
this.inheritBreath(neighbors[direction]);
}
//zabiera oddechy od sąsiadów tego samego koloru
List<Integer> sameColorNeighbors = getNeighbors(stoneColor);
if (!sameColorNeighbors.isEmpty()) {
for (Integer direction : sameColorNeighbors) {
this.inheritBreath(neighbors[direction].breathTiles);
}
breathTiles.remove(this);
for (Integer direction : sameColorNeighbors) {
neighbors[direction].inheritBreath(this.breathTiles);
neighbors[direction].looseBreath(this, Set.of(this));
}
}
}
/**
* Sprawdza sąsiadów i aktualizuje oddechy oraz zależności
*/
private void checkNeighborsV3() {
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if (neighbor != null ) {
if (neighbor.stoneColor == stoneColor.opposite()) {
//zabiera oddechy od sąsiadów tego samego koloru
neighbor.looseBreath(this, new HashSet<>(Set.of(this)));
} else if (neighbor.stoneColor == null) {
//ustawia sobie oddechy od pustych sąsiadów
this.inheritBreath(neighbor);
}
}
}
if (!getNeighbors(stoneColor).isEmpty()) {
//zabiera oddechy od sąsiadów tego samego koloru
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if (neighbor != null) {
if (neighbor.stoneColor == stoneColor) {
this.inheritBreath(neighbor.breathTiles);
}
}
}
// usuwa siebie z oddechów, ponieważ dziedziczenie oddechów od sąsiadów nas tu dodało
// this.looseBreath(this, this, this);
breathTiles.remove(this);
//dodaje oddechy do sąsiadów tego samego koloru
for (int i = 0; i < 4; i++) {
GoTile neighbor = neighbors[i];
if (neighbor != null) {
if (neighbor.stoneColor == stoneColor) {
neighbor.inheritBreath(this.breathTiles);
neighbor.looseBreath(this, new HashSet<>(Set.of(this)));
}
}
}
}
}
/**
* Sprawdza, czy podane pole jest jedynym oddechem tego pola
* @param tile pole do sprawdzenia
* @return true, jeśli podane pole jest jedynym oddechem tego pola
*/
private boolean onlyBreath(GoTile tile) {
return breathTiles.contains(tile) && breathTiles.size() == 1;
}
public boolean countTerritory(Color color, Set<GoTile> territory) {
territory.add(this);
boolean isTerritory = true;
for (int i = 0; i < 4; i++) {
if (neighbors[i] != null) {
if (neighbors[i].getStoneColor() == null && !territory.contains(neighbors[i])){
isTerritory = isTerritory && neighbors[i].countTerritory(color, territory);
} else if (neighbors[i].getStoneColor() == color.opposite()) {
return false;
}
}
}
return isTerritory;
}
}
| t |
9354_3 | kacper0276/Nauka_Java | 532 | src/Watki/MetodaWaitINotify.java | package Watki;
import java.util.LinkedList;
class MyHouse {
private LinkedList<String> delivery = new LinkedList<>();
public void waitForDelivery() {
synchronized (delivery) {
while (delivery.isEmpty()) {
try {
System.out.println("Waiting for delivery");
delivery.wait();
} catch (InterruptedException e) {}
}
}
System.out.println("Delivery recieved: " + delivery.poll());
}
public void pizzaGuy() {
synchronized (delivery) {
System.out.println("Pizza delivery ");
this.delivery.add("Pizza");
delivery.notify();
}
}
}
// Pętla while jest konieczna, bo wątek może być wybudzony nawet jeśli dane nie są gotowem czyli gdy nie było wywołania notify, dlatego sprawdza się czy listanie jest pusta
// Do synchronizacji jest użyty delivery dzięki czemu mamy pewność że nie nastąpi wyścig przy dodawaniu i zdejmowaniu elementów
// Każdy obiekt powiązany jest z monitorem i ma też zbiór powiadamianych wątków, które czekają na jego powiadomienie (delivery.wait())
// notify() wysyła powiadomeinie i wybudza czekajacy wątek
public class MetodaWaitINotify {
public static void main(String[] args) throws InterruptedException {
MyHouse myHouse = new MyHouse();
Thread customer = new Thread(new Runnable() {
@Override
public void run() {
myHouse.waitForDelivery();
}
});
customer.start();
Thread.sleep(3000);
Thread producer = new Thread(new Runnable() {
@Override
public void run() {
myHouse.pizzaGuy();
}
});
producer.start();
customer.join(); // Main thread wait for customer
}
}
| // notify() wysyła powiadomeinie i wybudza czekajacy wątek | package Watki;
import java.util.LinkedList;
class MyHouse {
private LinkedList<String> delivery = new LinkedList<>();
public void waitForDelivery() {
synchronized (delivery) {
while (delivery.isEmpty()) {
try {
System.out.println("Waiting for delivery");
delivery.wait();
} catch (InterruptedException e) {}
}
}
System.out.println("Delivery recieved: " + delivery.poll());
}
public void pizzaGuy() {
synchronized (delivery) {
System.out.println("Pizza delivery ");
this.delivery.add("Pizza");
delivery.notify();
}
}
}
// Pętla while jest konieczna, bo wątek może być wybudzony nawet jeśli dane nie są gotowem czyli gdy nie było wywołania notify, dlatego sprawdza się czy listanie jest pusta
// Do synchronizacji jest użyty delivery dzięki czemu mamy pewność że nie nastąpi wyścig przy dodawaniu i zdejmowaniu elementów
// Każdy obiekt powiązany jest z monitorem i ma też zbiór powiadamianych wątków, które czekają na jego powiadomienie (delivery.wait())
// notify() wysyła <SUF>
public class MetodaWaitINotify {
public static void main(String[] args) throws InterruptedException {
MyHouse myHouse = new MyHouse();
Thread customer = new Thread(new Runnable() {
@Override
public void run() {
myHouse.waitForDelivery();
}
});
customer.start();
Thread.sleep(3000);
Thread producer = new Thread(new Runnable() {
@Override
public void run() {
myHouse.pizzaGuy();
}
});
producer.start();
customer.join(); // Main thread wait for customer
}
}
| t |
9093_1 | kacper0276/Programowanie_Obiektowe | 584 | PowtorzenieProgramowanieObiektowe/src/Kolekcje/TreeSetPowtorzenie.java | package Kolekcje;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetPowtorzenie {
public static void main(String[] args) {
// https://pjastr.github.io/zima2023-24/POwyklad14.html#/treeset-zbiór-drzewiasty
// Tworzenie TreeSet
TreeSet<String> stringSet = new TreeSet<>();
TreeSet<Integer> intSet = new TreeSet<>();
// Dodawanie elementów
stringSet.add("Jabłko");
stringSet.add("Banana");
intSet.add(1);
intSet.add(2);
// Sprawdzanie, czy zbiór zawiera element
boolean containsBanana = stringSet.contains("Banana");
// Pobieranie pierwszego i ostatniego elementu
String firstString = stringSet.first();
Integer lastInt = intSet.last();
// Usuwanie elementów
stringSet.remove("Jabłko");
intSet.pollFirst();
// Pobieranie podzbioru
TreeSet<Integer> subSet = new TreeSet<>(intSet.subSet(1, true, 3, false));
// Iteracja przez zbiór
for(String s : stringSet) {
System.out.println(s);
}
// Czyszczenie zbioru
intSet.clear();
// Utworzenie TreeSet z odwróconym porównywaniem
TreeSet<String> reverseOrderSet = new TreeSet<>(Comparator.reverseOrder());
// Dodanie elementów do TreeSet
reverseOrderSet.add("Alfa");
reverseOrderSet.add("Bravo");
reverseOrderSet.add("Charlie");
reverseOrderSet.add("Delta");
// Wyświetlenie elementów w odwróconym porządku
System.out.println("Elementy TreeSet w odwróconym porządku:");
for(String element : reverseOrderSet) {
System.out.println(element);
}
}
}
| // Pobieranie pierwszego i ostatniego elementu
| package Kolekcje;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetPowtorzenie {
public static void main(String[] args) {
// https://pjastr.github.io/zima2023-24/POwyklad14.html#/treeset-zbiór-drzewiasty
// Tworzenie TreeSet
TreeSet<String> stringSet = new TreeSet<>();
TreeSet<Integer> intSet = new TreeSet<>();
// Dodawanie elementów
stringSet.add("Jabłko");
stringSet.add("Banana");
intSet.add(1);
intSet.add(2);
// Sprawdzanie, czy zbiór zawiera element
boolean containsBanana = stringSet.contains("Banana");
// Pobieranie pierwszego <SUF>
String firstString = stringSet.first();
Integer lastInt = intSet.last();
// Usuwanie elementów
stringSet.remove("Jabłko");
intSet.pollFirst();
// Pobieranie podzbioru
TreeSet<Integer> subSet = new TreeSet<>(intSet.subSet(1, true, 3, false));
// Iteracja przez zbiór
for(String s : stringSet) {
System.out.println(s);
}
// Czyszczenie zbioru
intSet.clear();
// Utworzenie TreeSet z odwróconym porównywaniem
TreeSet<String> reverseOrderSet = new TreeSet<>(Comparator.reverseOrder());
// Dodanie elementów do TreeSet
reverseOrderSet.add("Alfa");
reverseOrderSet.add("Bravo");
reverseOrderSet.add("Charlie");
reverseOrderSet.add("Delta");
// Wyświetlenie elementów w odwróconym porządku
System.out.println("Elementy TreeSet w odwróconym porządku:");
for(String element : reverseOrderSet) {
System.out.println(element);
}
}
}
| t |
3329_4 | kacper2TI/Rzeczy | 445 | BMI.java | package com.example.rzeczy;
//Program obliczający wskaźnik BMI
import java.util.Scanner;
public class BMI {
public static void main(String[] args) {
Scanner wej = new Scanner(System.in);
System.out.println("Podaj wagę");//Podaję wagę
double waga = wej.nextDouble();
System.out.println("Podaj wzrost");//Podaję wzrost
double wzrost = wej.nextDouble();
double BMI = waga / Math.pow(wzrost,2);//Obliczanie wskaźnika BMI
System.out.println("Twój wskaźnik BMI wynosi " + BMI);
if(BMI <= 18.5) //jeśli obliczony wskaźnik jest mniejszy równy 18.5 program wyświetla |
{ |
System.out.println("Jesteś za chudy. PRZYTYJ !"); <----------------------------
} else if (BMI>18.5 && BMI < 25) { //jeśli obliczony wskaźnik jest większy od 18.5 i mniejszy od 25 program wyświetla |
System.out.println("Jesteś w optymalnej wadze"); <-----------------------------------------------------------
} else if (BMI >= 25) //jeśli obliczony wskaźnik jest większy równy 25 program wyświetla |
{ |
System.out.println("Jesteś za gruby. SCHUDNIJ !"); <------------------------------
}
}
}
| //jeśli obliczony wskaźnik jest większy równy 25 program wyświetla |
| package com.example.rzeczy;
//Program obliczający wskaźnik BMI
import java.util.Scanner;
public class BMI {
public static void main(String[] args) {
Scanner wej = new Scanner(System.in);
System.out.println("Podaj wagę");//Podaję wagę
double waga = wej.nextDouble();
System.out.println("Podaj wzrost");//Podaję wzrost
double wzrost = wej.nextDouble();
double BMI = waga / Math.pow(wzrost,2);//Obliczanie wskaźnika BMI
System.out.println("Twój wskaźnik BMI wynosi " + BMI);
if(BMI <= 18.5) //jeśli obliczony wskaźnik jest mniejszy równy 18.5 program wyświetla |
{ |
System.out.println("Jesteś za chudy. PRZYTYJ !"); <----------------------------
} else if (BMI>18.5 && BMI < 25) { //jeśli obliczony wskaźnik jest większy od 18.5 i mniejszy od 25 program wyświetla |
System.out.println("Jesteś w optymalnej wadze"); <-----------------------------------------------------------
} else if (BMI >= 25) //jeśli obliczony <SUF>
{ |
System.out.println("Jesteś za gruby. SCHUDNIJ !"); <------------------------------
}
}
}
| t |
2732_1 | kacperAsad/Toolkits | 656 | MapIO/src/MapReader.java | import java.io.File;
import java.io.FileReader;
import java.lang.annotation.Documented;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class MapReader {
/**
* Statyczna metoda loadMapWithFile służy do jak nazwa wskazuje ładowania danych i tworzenia nowego objektu Mapy
* @param filePath
* Określa plik z którego są pobierane dane
* @return
* Nowy objekt Map z załadowanymi danymi z pliku / null-a jeśli wystąpił jakikolwiek bezinwazyjny problem z pobraniem danych z pliku
*/
public static HashMap<String, String> loadMapWithFile(String filePath)
{
return loadMapWithFile(new File(filePath));
}
/**
* Statyczna metoda loadMapWithFile służy do jak nazwa wskazuje ładowania danych i tworzenia nowego objektu Mapy
* @param file
* Określa abstrakcyjny plik z którego są pobierane dane
* @return
* Nowy objekt Map z załadowanymi danymi z pliku / null-a jeśli wystąpił jakikolwiek bezinwazyjny problem z pobraniem danych z pliku
*/
public static HashMap<String, String> loadMapWithFile(File file)
{
HashMap<String, String> map = new HashMap();
if (!file.exists())return null;
if (!file.canRead())return null;
try (Scanner sc = new Scanner(file)) {
while (sc.hasNext())
{
formatAndAdd(sc.nextLine() , map);
}
}catch (Exception e){
e.printStackTrace();
}
return map;
}
/**
* Służy do formatowania danych z pliku na parę objektów typu 'klucz - wartość'
* @param s
* Jest to jedna linia z pliku. Może być to na przykład 'email:examplemail@example.com'
* @param m
* Określa mapę do której ma być dodana para 'klucz - wartość' pobrana z @param s
*/
private static void formatAndAdd(String s , Map m)
{
String[] w = s.split(":");
m.put(w[0] , w[1]);
}
}
| /**
* Statyczna metoda loadMapWithFile służy do jak nazwa wskazuje ładowania danych i tworzenia nowego objektu Mapy
* @param file
* Określa abstrakcyjny plik z którego są pobierane dane
* @return
* Nowy objekt Map z załadowanymi danymi z pliku / null-a jeśli wystąpił jakikolwiek bezinwazyjny problem z pobraniem danych z pliku
*/ | import java.io.File;
import java.io.FileReader;
import java.lang.annotation.Documented;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class MapReader {
/**
* Statyczna metoda loadMapWithFile służy do jak nazwa wskazuje ładowania danych i tworzenia nowego objektu Mapy
* @param filePath
* Określa plik z którego są pobierane dane
* @return
* Nowy objekt Map z załadowanymi danymi z pliku / null-a jeśli wystąpił jakikolwiek bezinwazyjny problem z pobraniem danych z pliku
*/
public static HashMap<String, String> loadMapWithFile(String filePath)
{
return loadMapWithFile(new File(filePath));
}
/**
* Statyczna metoda loadMapWithFile <SUF>*/
public static HashMap<String, String> loadMapWithFile(File file)
{
HashMap<String, String> map = new HashMap();
if (!file.exists())return null;
if (!file.canRead())return null;
try (Scanner sc = new Scanner(file)) {
while (sc.hasNext())
{
formatAndAdd(sc.nextLine() , map);
}
}catch (Exception e){
e.printStackTrace();
}
return map;
}
/**
* Służy do formatowania danych z pliku na parę objektów typu 'klucz - wartość'
* @param s
* Jest to jedna linia z pliku. Może być to na przykład 'email:examplemail@example.com'
* @param m
* Określa mapę do której ma być dodana para 'klucz - wartość' pobrana z @param s
*/
private static void formatAndAdd(String s , Map m)
{
String[] w = s.split(":");
m.put(w[0] , w[1]);
}
}
| t |
3985_0 | kal0sz/agak1 | 307 | src/zad1/zad14.java | package zad1;
import java.util.Scanner;
public class zad14 {
public static void main(String[] args) {
Scanner klawiatura = new Scanner(System.in);
System.out.println("Podaj wynik z 1 testu: ");
double test1 = klawiatura.nextDouble();
System.out.println("Podaj wynik z 2 testu: ");
double test2 = klawiatura.nextDouble();
System.out.println("Podaj wynik z 3 testu: ");
double test3 = klawiatura.nextDouble();
double srednia = ((test1+test2+test3)/3);
System.out.println("Twój wynik z pierwszego testu to: " + test1 + ", z drugiego: " + test2 + ", a z trzeciego: " + test3 + ". Tak więc twoja średnia wynosi: " + srednia);
}
}
/*
. Napisz program, który wyświetla prośbę o wprowadzenie wyników z trzech testów.
Program powinien wyświetlać wyniki z każdego testu, a także średnią.
*/ | /*
. Napisz program, który wyświetla prośbę o wprowadzenie wyników z trzech testów.
Program powinien wyświetlać wyniki z każdego testu, a także średnią.
*/ | package zad1;
import java.util.Scanner;
public class zad14 {
public static void main(String[] args) {
Scanner klawiatura = new Scanner(System.in);
System.out.println("Podaj wynik z 1 testu: ");
double test1 = klawiatura.nextDouble();
System.out.println("Podaj wynik z 2 testu: ");
double test2 = klawiatura.nextDouble();
System.out.println("Podaj wynik z 3 testu: ");
double test3 = klawiatura.nextDouble();
double srednia = ((test1+test2+test3)/3);
System.out.println("Twój wynik z pierwszego testu to: " + test1 + ", z drugiego: " + test2 + ", a z trzeciego: " + test3 + ". Tak więc twoja średnia wynosi: " + srednia);
}
}
/*
. Napisz program, <SUF>*/ | t |
8142_7 | kallazz/AlgorithmicComputerScience | 808 | sem3/tp/list3/composite/Shape.java | /**
* Copyright 2011 Joao Miguel Pereira
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package eu.jpereira.trainings.designpatterns.structural.composite.model;
/**
* @author jpereira
*
*/
public abstract class Shape {
// The shape coordinates
private int x;
private int y;
/**
* If this object is a CompositeShape, return it. Null otherwise.
*
* @return an compositeShape instance if this is an composite, null
* otherwise
*/
public CompositeShape asComposite() {
// Zwracamy CompositeShape, jeśli to on
if (this instanceof CompositeShape) {
return (CompositeShape) this;
}
return null;
}
/**
* Move a shape in a 2D scale
*
* @param xIncrement
* The increment in X axis
* @param yIncremet
* The increment in the Y axis
*/
public void move(int xIncrement, int yIncrement) {
this.x += xIncrement;
this.y += yIncrement;
// if is composite, delegate to children
CompositeShape composite = this.asComposite();
if (composite != null) {
// Inkrementujemy rekurencyjnie też na wszystkich dzieciach
for (Shape child : composite.getShapes()) {
child.move(xIncrement, yIncrement);
}
}
}
/**
* @return the x coordinate
*/
public int getX() {
return x;
}
/**
* @param x
* the x coordinate to set
*/
public void setX(int x) {
this.x = x;
}
/**
* @return the y coordinate
*/
public int getY() {
return y;
}
/**
* @param y
* the y coordinate to set
*/
public void setY(int y) {
this.y = y;
}
/**
* Each instance of a Shape must know it's type
* @return
*/
public abstract ShapeType getType();
}
| // Inkrementujemy rekurencyjnie też na wszystkich dzieciach
| /**
* Copyright 2011 Joao Miguel Pereira
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package eu.jpereira.trainings.designpatterns.structural.composite.model;
/**
* @author jpereira
*
*/
public abstract class Shape {
// The shape coordinates
private int x;
private int y;
/**
* If this object is a CompositeShape, return it. Null otherwise.
*
* @return an compositeShape instance if this is an composite, null
* otherwise
*/
public CompositeShape asComposite() {
// Zwracamy CompositeShape, jeśli to on
if (this instanceof CompositeShape) {
return (CompositeShape) this;
}
return null;
}
/**
* Move a shape in a 2D scale
*
* @param xIncrement
* The increment in X axis
* @param yIncremet
* The increment in the Y axis
*/
public void move(int xIncrement, int yIncrement) {
this.x += xIncrement;
this.y += yIncrement;
// if is composite, delegate to children
CompositeShape composite = this.asComposite();
if (composite != null) {
// Inkrementujemy rekurencyjnie <SUF>
for (Shape child : composite.getShapes()) {
child.move(xIncrement, yIncrement);
}
}
}
/**
* @return the x coordinate
*/
public int getX() {
return x;
}
/**
* @param x
* the x coordinate to set
*/
public void setX(int x) {
this.x = x;
}
/**
* @return the y coordinate
*/
public int getY() {
return y;
}
/**
* @param y
* the y coordinate to set
*/
public void setY(int y) {
this.y = y;
}
/**
* Each instance of a Shape must know it's type
* @return
*/
public abstract ShapeType getType();
}
| t |
2738_7 | kamcio96/KGildieAPI | 537 | src/main/java/pl/kamcio96/kgildieapi/PlayerData.java | package pl.kamcio96.kgildieapi;
import org.bukkit.entity.Player;
import java.util.Optional;
import java.util.UUID;
/**
* PlayerData
* Podstawowe informacje o graczu
* @author kamcio96
*/
public interface PlayerData {
/**
* Zwraca UUID gracza
* @return uuid
*/
UUID getUniqueId();
/**
* Zwraca nazwe gracza
* @return nazwa
*/
String getName();
/**
* Zwraca liczbe zabic gracza
* @return zabicia
*/
int getKills();
/**
* Ustawia liczbe zabic gracza
* @param kills zabicia
*/
void setKills(int kills);
/**
* Zwraca liczbe smierci gracza
* @return smierci
*/
int getDeaths();
/**
* Ustawia liczbe smierci gracza
* @param deaths smierci
*/
void setDeaths(int deaths);
/**
* Zwraca liczbe punktów gracza
* @return pkt
*/
int getPoints();
/**
* Ustawia liczbe punktów gracza
* @param points pkt
*/
void setPoints(int points);
/**
* Zwraca obiekt gracza, o ile istnieje
* @return
*/
Optional<Player> getPlayer();
/**
* Zwraca gildie, o ile gracz ją ma
* @return gildia
*/
Optional<Guild> getGuild();
/**
* Zwraca liczbe sekund przez ktora gracz był na serwerze
* <p>
* Może nie być wspierane przez wszystkie pluginy
* </p>
* @return czas
*/
@Deprecated
long getPlayedTime();
}
| /**
* Zwraca liczbe punktów gracza
* @return pkt
*/ | package pl.kamcio96.kgildieapi;
import org.bukkit.entity.Player;
import java.util.Optional;
import java.util.UUID;
/**
* PlayerData
* Podstawowe informacje o graczu
* @author kamcio96
*/
public interface PlayerData {
/**
* Zwraca UUID gracza
* @return uuid
*/
UUID getUniqueId();
/**
* Zwraca nazwe gracza
* @return nazwa
*/
String getName();
/**
* Zwraca liczbe zabic gracza
* @return zabicia
*/
int getKills();
/**
* Ustawia liczbe zabic gracza
* @param kills zabicia
*/
void setKills(int kills);
/**
* Zwraca liczbe smierci gracza
* @return smierci
*/
int getDeaths();
/**
* Ustawia liczbe smierci gracza
* @param deaths smierci
*/
void setDeaths(int deaths);
/**
* Zwraca liczbe punktów <SUF>*/
int getPoints();
/**
* Ustawia liczbe punktów gracza
* @param points pkt
*/
void setPoints(int points);
/**
* Zwraca obiekt gracza, o ile istnieje
* @return
*/
Optional<Player> getPlayer();
/**
* Zwraca gildie, o ile gracz ją ma
* @return gildia
*/
Optional<Guild> getGuild();
/**
* Zwraca liczbe sekund przez ktora gracz był na serwerze
* <p>
* Może nie być wspierane przez wszystkie pluginy
* </p>
* @return czas
*/
@Deprecated
long getPlayedTime();
}
| t |
10046_13 | kamils224/OperatingSystemSimulator-JAVA | 2,450 | src/scheduler/Scheduler.java | package scheduler;
import interpreter.Interpreter;
import process_management.PCB;
import process_management.ProcessManager;
//import shellpackage.Shell;
/**
* 1. POLA
* 2. KONSTRUKOR
* 3. METODY PRYWATNE
* 4.METODY PUBLICZNE
* 4.1 NEWREADY PROCES
* 4.2 FINDANDRUN
* 4.3 VOPERARIONOCCURE
*/
public class Scheduler {
///POLA////////////////////////////////////
///////////////////////////////////////////
//Nad tymi staticami się jeszcze zastanowie
private static boolean sNotExistReadyProces =false; //Flaga określająca czy jest coś do sprawdzenia
private static boolean sNewReadyProces =false; //Wymagane ponowne sprawdzenie Procesów na liście
private PCB mRunning; //Obecnie wykonywany proces
private PCB mFinalTry; //Proces który zostanie sprawdzony po jako ostatni
private PCB mNextTry; //Kolejne próby
private int mTimeQuantum; //Liczba rozkazów jakie nalezy wykonać zanim nastąpi przejście do następnego procesu
private int mRemainTimeQuantum;//Pozostały kwant czasu
///KONSTRUKKTORY///////////////////////////
///////////////////////////////////////////
public Scheduler(int mTimeQuantum)//Dodać wyjątki
{
mRunning =null;
mFinalTry =null;
mNextTry =null;
if(mTimeQuantum<=0)
throw new ArithmeticException("Niedozwolony kwant czasy <=0");
else
{
this.mTimeQuantum = mTimeQuantum;
mRemainTimeQuantum = mTimeQuantum;
}
}
///METODY PRYWATNE/////////////////////////
///////////////////////////////////////////
private void Run()
{
boolean wasTerminated=false;
//Ustawnienie mRunning na wyszukany gotowy proces jeśli został właśnie wytypowany
if (mRemainTimeQuantum == mTimeQuantum)//Jeśli zostałprzydzilony świeży kwant czasu
{
try
{
if(mNextTry==ProcessManager.findProcess(1))
mRemainTimeQuantum=1;
}
catch(Exception e)
{
System.out.println("Błąd procesu pustego w metodzie run");
}
mRunning = mNextTry;
if( mRunning.getState()==PCB.State.Terminated )
{
mRemainTimeQuantum=1;
wasTerminated=true;
}
else
{
mRunning.setState(PCB.State.Active); //Przejście z stanu Ready do Run
}
mNextTry = mRunning.getPrevAll();
find();
}
// KOLEJNOSC TAKA A NIE INNA PONIEWAZ NIE WIEM CO SIE BEDZIE DZIAŁO W EXECUTE WIĘKSZE BEZPIECZEŃSTWO
mRemainTimeQuantum--; //Zmniejszenie pozostałego kwantu czasu
Interpreter.executeInstruction(mRunning); //Wykonaie 1 rozkazu//Kwestia uzgodnienia jak bedzie uruchamiany proces
inform();
if(!wasTerminated)
{
if(mRunning.getState()!=PCB.State.Active) //Wyjście jeśli proces został zablokowany lub syało się cos innego
return;
if(mRemainTimeQuantum==0) //Sprawdzenie czy czas się nie skończył
mRunning.setState(PCB.State.Ready ); //Zmiana stanu na Ready aby nie było 2 procesów w stanie Active
}
else
{
mNextTry=mRunning.getPrevAll();
}
}
private void find()
{
if(mNextTry==null)
{
mNextTry=ProcessManager.sAllProcessList.get(0);//Ustawienie na pierwszy Proces PROCES PUSTY
}
if(!sNotExistReadyProces) //Sprawdzenie czy są jakieś aktywne procesy
{
mFinalTry=mNextTry; //Ustawienie procesu który zostanie sprawzoy jako ostatni;
do
{
if(PCB.State.Ready==mNextTry.getState()||mNextTry.getState()==PCB.State.Active)//||mNextTry.getState()==PCB.State.Terminated)//Sprawdzenie czy proces jest aktywny lub w stanie gotowości
{
try {
if (mNextTry==ProcessManager.findProcess(1))
{
mNextTry=mNextTry.getPrevAll(); //Przeskakiwanie Procesu Pustego
}
else
{
return; //wyjscie z metody
}
}
catch (Exception e)
{
System.out.println("Błąd aktualnego procesu");
}
}
else
{
// System.out.println(mNextTry.getProcessName()+" jest wstrzymany.");//Debug
mNextTry=mNextTry.getPrevAll(); //Przejście do sprawdzenia kolejnego
}
}while(mNextTry!=mFinalTry);//Sprawdzam tak długo aż nie sprawdzę wszystkich
}
//Jeśli nie znalazło aktywnych procesów przydziela procesor procesowi pustemu
try {
mNextTry = ProcessManager.findProcess(1);
}
catch (Exception e)
{
System.out.println("BLAD Procesu Pustego");
}
sNotExistReadyProces = true;//Ustawiam fllagę sNotExistReadyProces na true ponieważ nie ma żadanych procesów
//System.out.println("Nie znaleziono żadnych gotowych procesów. NextTry = EmptyProces");//Debug
}
///METODY PUBLICZNE////////////////////////
///////////////////////////////////////////
public static void newReadyProces() //Uruchamiana gdy pojawi się nowy aktywny proces
{
sNewReadyProces =true;
if(sNotExistReadyProces)
{
sNotExistReadyProces = false;//zmienia flagę
}
}
public void findAndRun()
{
if (!ProcessManager.sAllProcessList.isEmpty())
{
if (mRunning == null)//Przypadek graniczny pierwsze uruchomienie
{
find();
}
else //Normalna Praca
{
if (sNewReadyProces)
{
mNextTry = mRunning.getPrevAll();//Ponowne szukanie kandydata
find(); //Szukanie
sNewReadyProces =false;
informNewReadyProces();
if(mRemainTimeQuantum==0)
informWhatNext();
}
if (mRunning.getState() != PCB.State.Active)//Przypadek gdy wyczerpał się kwant czasu lub wystąpiła operacja P
{
mRemainTimeQuantum = mTimeQuantum;//Odnowienie kwantu
if(mNextTry.getState()!= PCB.State.Ready)
find();
}
}
//URUCHAMIAMY WYTYPOWANY PROCES
Run();
}
}
///GETERY i SETERY////////////////////////
public PCB getRunningProces()//Zwraca uruchominy proces
{
return mRunning;
}
public PCB getNextTry()//Zwtaca proces który zostanie wybany jako następny
{
return mNextTry;
}
public int getTimeQuantum()//Zwaraca Ustawiony kwant czasy
{
return mTimeQuantum;
}
public int getReaminTimeQuantum(){
return mRemainTimeQuantum;
}
public static boolean getNotExistReadyProces()//Ustawia flage brak aktywnych procesów (Oprócz pustego)
{
return sNotExistReadyProces;
}
public void informNewReadyProces()
{
//System.out.println("Nowy proces przeszedł w stan Ready");
}
public void informWhatNext()
{
System.out.println("Nastęny kandydat do uruchomienia "+mNextTry.getProcessName());
}
private void inform() {
System.out.println("Obecnie wykonywany proces "+mRunning.getProcessName());
System.out.println("Pozostały kwant czasu "+ mRemainTimeQuantum);
System.out.println("Nastęny kandydat do uruchomienia "+mNextTry.getProcessName());
System.out.println("--------------------------------------");
}
} | //Wykonaie 1 rozkazu//Kwestia uzgodnienia jak bedzie uruchamiany proces | package scheduler;
import interpreter.Interpreter;
import process_management.PCB;
import process_management.ProcessManager;
//import shellpackage.Shell;
/**
* 1. POLA
* 2. KONSTRUKOR
* 3. METODY PRYWATNE
* 4.METODY PUBLICZNE
* 4.1 NEWREADY PROCES
* 4.2 FINDANDRUN
* 4.3 VOPERARIONOCCURE
*/
public class Scheduler {
///POLA////////////////////////////////////
///////////////////////////////////////////
//Nad tymi staticami się jeszcze zastanowie
private static boolean sNotExistReadyProces =false; //Flaga określająca czy jest coś do sprawdzenia
private static boolean sNewReadyProces =false; //Wymagane ponowne sprawdzenie Procesów na liście
private PCB mRunning; //Obecnie wykonywany proces
private PCB mFinalTry; //Proces który zostanie sprawdzony po jako ostatni
private PCB mNextTry; //Kolejne próby
private int mTimeQuantum; //Liczba rozkazów jakie nalezy wykonać zanim nastąpi przejście do następnego procesu
private int mRemainTimeQuantum;//Pozostały kwant czasu
///KONSTRUKKTORY///////////////////////////
///////////////////////////////////////////
public Scheduler(int mTimeQuantum)//Dodać wyjątki
{
mRunning =null;
mFinalTry =null;
mNextTry =null;
if(mTimeQuantum<=0)
throw new ArithmeticException("Niedozwolony kwant czasy <=0");
else
{
this.mTimeQuantum = mTimeQuantum;
mRemainTimeQuantum = mTimeQuantum;
}
}
///METODY PRYWATNE/////////////////////////
///////////////////////////////////////////
private void Run()
{
boolean wasTerminated=false;
//Ustawnienie mRunning na wyszukany gotowy proces jeśli został właśnie wytypowany
if (mRemainTimeQuantum == mTimeQuantum)//Jeśli zostałprzydzilony świeży kwant czasu
{
try
{
if(mNextTry==ProcessManager.findProcess(1))
mRemainTimeQuantum=1;
}
catch(Exception e)
{
System.out.println("Błąd procesu pustego w metodzie run");
}
mRunning = mNextTry;
if( mRunning.getState()==PCB.State.Terminated )
{
mRemainTimeQuantum=1;
wasTerminated=true;
}
else
{
mRunning.setState(PCB.State.Active); //Przejście z stanu Ready do Run
}
mNextTry = mRunning.getPrevAll();
find();
}
// KOLEJNOSC TAKA A NIE INNA PONIEWAZ NIE WIEM CO SIE BEDZIE DZIAŁO W EXECUTE WIĘKSZE BEZPIECZEŃSTWO
mRemainTimeQuantum--; //Zmniejszenie pozostałego kwantu czasu
Interpreter.executeInstruction(mRunning); //Wykonaie 1 <SUF>
inform();
if(!wasTerminated)
{
if(mRunning.getState()!=PCB.State.Active) //Wyjście jeśli proces został zablokowany lub syało się cos innego
return;
if(mRemainTimeQuantum==0) //Sprawdzenie czy czas się nie skończył
mRunning.setState(PCB.State.Ready ); //Zmiana stanu na Ready aby nie było 2 procesów w stanie Active
}
else
{
mNextTry=mRunning.getPrevAll();
}
}
private void find()
{
if(mNextTry==null)
{
mNextTry=ProcessManager.sAllProcessList.get(0);//Ustawienie na pierwszy Proces PROCES PUSTY
}
if(!sNotExistReadyProces) //Sprawdzenie czy są jakieś aktywne procesy
{
mFinalTry=mNextTry; //Ustawienie procesu który zostanie sprawzoy jako ostatni;
do
{
if(PCB.State.Ready==mNextTry.getState()||mNextTry.getState()==PCB.State.Active)//||mNextTry.getState()==PCB.State.Terminated)//Sprawdzenie czy proces jest aktywny lub w stanie gotowości
{
try {
if (mNextTry==ProcessManager.findProcess(1))
{
mNextTry=mNextTry.getPrevAll(); //Przeskakiwanie Procesu Pustego
}
else
{
return; //wyjscie z metody
}
}
catch (Exception e)
{
System.out.println("Błąd aktualnego procesu");
}
}
else
{
// System.out.println(mNextTry.getProcessName()+" jest wstrzymany.");//Debug
mNextTry=mNextTry.getPrevAll(); //Przejście do sprawdzenia kolejnego
}
}while(mNextTry!=mFinalTry);//Sprawdzam tak długo aż nie sprawdzę wszystkich
}
//Jeśli nie znalazło aktywnych procesów przydziela procesor procesowi pustemu
try {
mNextTry = ProcessManager.findProcess(1);
}
catch (Exception e)
{
System.out.println("BLAD Procesu Pustego");
}
sNotExistReadyProces = true;//Ustawiam fllagę sNotExistReadyProces na true ponieważ nie ma żadanych procesów
//System.out.println("Nie znaleziono żadnych gotowych procesów. NextTry = EmptyProces");//Debug
}
///METODY PUBLICZNE////////////////////////
///////////////////////////////////////////
public static void newReadyProces() //Uruchamiana gdy pojawi się nowy aktywny proces
{
sNewReadyProces =true;
if(sNotExistReadyProces)
{
sNotExistReadyProces = false;//zmienia flagę
}
}
public void findAndRun()
{
if (!ProcessManager.sAllProcessList.isEmpty())
{
if (mRunning == null)//Przypadek graniczny pierwsze uruchomienie
{
find();
}
else //Normalna Praca
{
if (sNewReadyProces)
{
mNextTry = mRunning.getPrevAll();//Ponowne szukanie kandydata
find(); //Szukanie
sNewReadyProces =false;
informNewReadyProces();
if(mRemainTimeQuantum==0)
informWhatNext();
}
if (mRunning.getState() != PCB.State.Active)//Przypadek gdy wyczerpał się kwant czasu lub wystąpiła operacja P
{
mRemainTimeQuantum = mTimeQuantum;//Odnowienie kwantu
if(mNextTry.getState()!= PCB.State.Ready)
find();
}
}
//URUCHAMIAMY WYTYPOWANY PROCES
Run();
}
}
///GETERY i SETERY////////////////////////
public PCB getRunningProces()//Zwraca uruchominy proces
{
return mRunning;
}
public PCB getNextTry()//Zwtaca proces który zostanie wybany jako następny
{
return mNextTry;
}
public int getTimeQuantum()//Zwaraca Ustawiony kwant czasy
{
return mTimeQuantum;
}
public int getReaminTimeQuantum(){
return mRemainTimeQuantum;
}
public static boolean getNotExistReadyProces()//Ustawia flage brak aktywnych procesów (Oprócz pustego)
{
return sNotExistReadyProces;
}
public void informNewReadyProces()
{
//System.out.println("Nowy proces przeszedł w stan Ready");
}
public void informWhatNext()
{
System.out.println("Nastęny kandydat do uruchomienia "+mNextTry.getProcessName());
}
private void inform() {
System.out.println("Obecnie wykonywany proces "+mRunning.getProcessName());
System.out.println("Pozostały kwant czasu "+ mRemainTimeQuantum);
System.out.println("Nastęny kandydat do uruchomienia "+mNextTry.getProcessName());
System.out.println("--------------------------------------");
}
} | t |
3996_7 | karmatys8/PO_2023_PT0800_ARMATYS | 609 | oolab/src/main/java/agh/ics/oop/World.java | package agh.ics.oop;
import agh.ics.oop.model.*;
import java.util.ArrayList;
import java.util.List;
public class World {
public static void main(String[] args) {
try {
List<MoveDirection> moves = OptionsParser.parse(args);
// List<Vector2d> animals1 = List.of(new Vector2d(2,2), new Vector2d(3,4));
// WorldMap<Animal, Vector2d> worldMap1 = new RectangularMap(5, 5);
// Simulation simulation1 = new Simulation(animals1, moves, worldMap1);
//
// List<Vector2d> animals2 = List.of(new Vector2d(-8,1), new Vector2d(3,14), new Vector2d(0, 0));
// WorldMap<Animal, Vector2d> worldMap2 = new GrassField(15);
// Simulation simulation2 = new Simulation(animals2, moves, worldMap2);
//
// SimulationEngine engine = new SimulationEngine(List.of(simulation2, simulation1));
// engine.runAsync();
ConsoleMapDisplay observer = new ConsoleMapDisplay();
List<Simulation> simulations = new ArrayList<>();
for(int i = 0; i < 1000; i++) {
List<Vector2d> animals = List.of(new Vector2d(-8,1), new Vector2d(3,14), new Vector2d(0, 0));
WorldMap<Animal, Vector2d> worldMap = new GrassField(15);
worldMap.addObserver(observer);
simulations.add(new Simulation(animals, moves, worldMap));
}
SimulationEngine engine = new SimulationEngine(simulations);
engine.runAsyncInThreadPool(); // pula wątków jest lepszym pomysłem ponieważ korzystamy z 4 rdzeni (jeżeli są dostępne)
// więc program będzie się wykonywać około 4 razy szybciej
engine.awaitSimulationsEnd();
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
} catch (InterruptedException e) {
System.out.println("Engine got interrupted");
}
System.out.println("System zakończył działanie");
}
}
| // pula wątków jest lepszym pomysłem ponieważ korzystamy z 4 rdzeni (jeżeli są dostępne) | package agh.ics.oop;
import agh.ics.oop.model.*;
import java.util.ArrayList;
import java.util.List;
public class World {
public static void main(String[] args) {
try {
List<MoveDirection> moves = OptionsParser.parse(args);
// List<Vector2d> animals1 = List.of(new Vector2d(2,2), new Vector2d(3,4));
// WorldMap<Animal, Vector2d> worldMap1 = new RectangularMap(5, 5);
// Simulation simulation1 = new Simulation(animals1, moves, worldMap1);
//
// List<Vector2d> animals2 = List.of(new Vector2d(-8,1), new Vector2d(3,14), new Vector2d(0, 0));
// WorldMap<Animal, Vector2d> worldMap2 = new GrassField(15);
// Simulation simulation2 = new Simulation(animals2, moves, worldMap2);
//
// SimulationEngine engine = new SimulationEngine(List.of(simulation2, simulation1));
// engine.runAsync();
ConsoleMapDisplay observer = new ConsoleMapDisplay();
List<Simulation> simulations = new ArrayList<>();
for(int i = 0; i < 1000; i++) {
List<Vector2d> animals = List.of(new Vector2d(-8,1), new Vector2d(3,14), new Vector2d(0, 0));
WorldMap<Animal, Vector2d> worldMap = new GrassField(15);
worldMap.addObserver(observer);
simulations.add(new Simulation(animals, moves, worldMap));
}
SimulationEngine engine = new SimulationEngine(simulations);
engine.runAsyncInThreadPool(); // pula wątków <SUF>
// więc program będzie się wykonywać około 4 razy szybciej
engine.awaitSimulationsEnd();
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
} catch (InterruptedException e) {
System.out.println("Engine got interrupted");
}
System.out.println("System zakończył działanie");
}
}
| t |
8367_1 | karol1999/javafx-car-saloon | 4,243 | src/sample/Controller.java | package sample;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.AnchorPane;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class Controller {
private CarShowroomData carShowroomData;
private static final String CSV_SEPARATOR = ";";
private List<Vehicle> soldCars;
@FXML
private ComboBox<String> cityBox;
@FXML
private ComboBox<String> showroomBox;
@FXML
private TableView<Vehicle> carsTable;
@FXML
private TableColumn<Vehicle, String> brandColumn;
@FXML
private TableColumn<Vehicle, String> modelColumn;
@FXML
private TableColumn<Vehicle, Double> priceColumn;
@FXML
private TableColumn<Vehicle, Integer> yearColumn;
@FXML
private TableColumn<Vehicle, ItemCondition> conditionColumn;
@FXML
private TableColumn<Vehicle, String> cityColumn;
@FXML
private TableColumn<Vehicle, String> statusColumn;
@FXML
private TextField searchField;
@FXML
private AnchorPane anchorPane;
public Controller() {
this.carShowroomData = new CarShowroomData();
this.soldCars = new ArrayList<>();
}
public void initialize() {
carsTable.setRowFactory(tv -> new TableRow<Vehicle>() {
private Tooltip tooltip = new Tooltip();
@Override
public void updateItem(Vehicle vehicle, boolean empty) {
super.updateItem(vehicle, empty);
if (vehicle == null) {
setTooltip(null);
} else {
tooltip.setText("Pojemność śilnika: " + vehicle.getEngineCapacity() + " Przebieg: " + vehicle.getMileage());
setTooltip(tooltip);
}
}
});
readFromCSV();
ObservableList<String> listShowroom = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
listShowroom.add("Sprzedane");
listShowroom.add("Salony");
showroomBox.setItems(listShowroom);
showroomBox.getSelectionModel().select("Salony");
ObservableList<String> listCity = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCity());
listCity.add("Miasto");
cityBox.setItems(listCity);
cityBox.getSelectionModel().select("Miasto");
brandColumn.setCellValueFactory(new PropertyValueFactory<>("brand"));
brandColumn.setReorderable(false);
modelColumn.setCellValueFactory(new PropertyValueFactory<>("model"));
modelColumn.setReorderable(false);
priceColumn.setCellValueFactory(new PropertyValueFactory<>("price"));
priceColumn.setReorderable(false);
yearColumn.setCellValueFactory(new PropertyValueFactory<>("yearOfProduction"));
yearColumn.setReorderable(false);
conditionColumn.setCellValueFactory(new PropertyValueFactory<>("condition"));
conditionColumn.setReorderable(false);
cityColumn.setCellValueFactory(new PropertyValueFactory<>("city"));
cityColumn.setReorderable(false);
statusColumn.setCellValueFactory(new PropertyValueFactory<>("status"));
statusColumn.setReorderable(false);
fillTable();
}
@FXML
public void onSalonSelected() {
if (!cityBox.getSelectionModel().getSelectedItem().equals("Miasto")) {
fillWhenCityAndShowroomIsSelected(cityBox.getValue(), showroomBox.getValue());
} else {
if (showroomBox.getValue().equals("Salony")) {
fillTable();
} else if (showroomBox.getValue().equals("Sprzedane")) {
fillTableSold();
} else {
fillTableWhenShowroomSelected(showroomBox.getValue());
}
}
}
@FXML
public void onCitySelected() {
String city = cityBox.getValue();
if (city.equals("Miasto")) {
fillTable();
} else {
fillWhenCitySelected(city);
}
}
@FXML
public void searchButton() {
fillWhenSearch(searchField.getText());
}
public void fillTableWhenShowroomSelected(String name) {
ObservableList<Vehicle> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.selectedParticularShowroom(name).getCarList());
if (!list.isEmpty()) carsTable.setItems(list);
}
public void fillTable() {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (String s : list) {
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
list2.addAll(temp);
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void fillWhenCitySelected(String city) {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (String s : list) {
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
for (Vehicle vehicle : temp) {
if (vehicle.getCity().equals(city)) {
list2.add(vehicle);
}
}
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void fillWhenCityAndShowroomIsSelected(String city, String showroom) {
if (showroom.equals("Salony")) {
fillWhenCitySelected(city);
return;
}
ObservableList<Vehicle> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.selectedParticularShowroom(showroom).getCarList());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (Vehicle vehicle : list) {
if (vehicle.getCity().equals(city)) list2.add(vehicle);
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void fillWhenSearch(String name) {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (String s : list) {
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
for (Vehicle vehicle : temp) {
if (vehicle.getBrand().equals(name)) {
list2.add(vehicle);
}
}
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
// kupowanie samochodu czyli tak naprawdę usuwanie go
public void buyButton() {
if (carsTable.getSelectionModel().getSelectedItem() != null) {
Vehicle vehicle = carsTable.getSelectionModel().getSelectedItem();
if (vehicle.getStatus() != "Rez" && vehicle.getStatus() != "Niedostępny") {
Dialog<ButtonType> dialog = new Dialog<>();
dialog.initOwner(anchorPane.getScene().getWindow());
try {
Parent root = FXMLLoader.load(getClass().getResource("afterBuy.fxml"));
dialog.getDialogPane().setContent(root);
} catch (IOException e) {
System.out.println("Couldn't load the dialog");
e.printStackTrace();
return;
}
dialog.getDialogPane().getButtonTypes().add(ButtonType.OK);
dialog.getDialogPane().getButtonTypes().add(ButtonType.CANCEL);
Optional<ButtonType> result = dialog.showAndWait();
if (result.isPresent() && result.get() == ButtonType.OK) {
vehicle.setStatus("Niedostępny");
carShowroomData.carShowroomContainer.selectedParticularShowroom(carShowroomData.carShowroomContainer.findParticularSaloon(vehicle)).removeProduct(vehicle);
soldCars.add(vehicle);
fillTable();
showroomBox.getSelectionModel().select("Salony");
cityBox.getSelectionModel().select("Miasto");
}
} else {
Alert alert = new Alert(Alert.AlertType.WARNING);
alert.setTitle("Error");
alert.setHeaderText("Samochod zarezerwowany tudziez niedostepny, nie mozesz tego kupic");
alert.showAndWait();
}
}
}
// rezerwacja
public void reservationButton() {
ObservableList<Vehicle> selectedRow, allCars;
allCars = carsTable.getItems();
selectedRow = carsTable.getSelectionModel().getSelectedItems();
for (Vehicle vehicle : selectedRow) {
allCars.remove(vehicle);
vehicle.setStatus("Rez");
allCars.add(vehicle);
carsTable.refresh();
}
}
public void fillTableSold() {
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
list2.addAll(soldCars);
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void readFromCSV() {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
String stringCurrentLine;
for (String s : list) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(s).append(".csv");
try {
BufferedReader bw = new BufferedReader(new InputStreamReader(new FileInputStream(stringBuilder.toString())));
for (int i = 0; (stringCurrentLine = bw.readLine()) != null; i++) {
if (i == 0) {
continue;
}
String[] result = stringCurrentLine.split("\\;");
Vehicle vehicle = new Vehicle(result[0], result[1], ItemCondition.NEW, Double.parseDouble(result[2]), Integer.parseInt(result[3]), Double.parseDouble(result[4]),
Double.parseDouble(result[5]), Integer.parseInt(result[6]), result[7]);
carShowroomData.carShowroomContainer.selectedParticularShowroom(s).addProduct(vehicle);
}
bw.close();
} catch (IOException e) {
alert();
}
}
try {
BufferedReader bw = new BufferedReader(new InputStreamReader(new FileInputStream("SprzedaneSamochody.csv")));
for (int i = 0; (stringCurrentLine = bw.readLine()) != null; i++) {
if (i == 0) {
continue;
}
String[] result = stringCurrentLine.split("\\;");
Vehicle vehicle = new Vehicle(result[0], result[1], ItemCondition.NEW, Double.parseDouble(result[2]), Integer.parseInt(result[3]), Double.parseDouble(result[4]),
Double.parseDouble(result[5]), Integer.parseInt(result[6]), result[7]);
vehicle.setStatus("Niedostępny");
soldCars.add(vehicle);
}
} catch (IOException e) {
alert();
}
}
public void writeToCSV() {
ArrayList<String> columnNames = new ArrayList<String>();
for (Field f : Vehicle.class.getDeclaredFields()) {
CSVAnnotation annotation = f.getDeclaredAnnotation(CSVAnnotation.class);
if (annotation != null)
columnNames.add(annotation.value()); //dodanie adnotacji do listy
}
String concatenated = String.join(",", columnNames);
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
for (String s : list) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(s).append(".csv");
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
try {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(stringBuilder.toString()), "UTF-8"));
write(bw, concatenated);
write(bw, temp);
bw.flush();
bw.close();
} catch (IOException e) {
alert();
}
}
try {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("SprzedaneSamochody.csv"), "UTF-8"));
write(bw, concatenated);
write(bw, soldCars);
bw.flush();
bw.close();
} catch (IOException e) {
alert();
}
}
public void write(BufferedWriter bw, List<Vehicle> sold) throws IOException {
for (Vehicle vehicle : sold) {
StringBuffer oneLine = new StringBuffer();
oneLine.append(vehicle.getBrand().trim().length() == 0 ? "" : vehicle.getBrand());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getModel().trim().length() == 0 ? "" : vehicle.getModel());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getPrice() < 0 ? "" : vehicle.getPrice());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getYearOfProduction() < 0 ? "" : vehicle.getYearOfProduction());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getMileage() < 0 ? "" : vehicle.getMileage());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getEngineCapacity() < 0 ? "" : vehicle.getEngineCapacity());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getAmount() < 0 ? "" : vehicle.getAmount());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getCity().trim().length() == 0 ? "" : vehicle.getCity());
bw.write(oneLine.toString());
bw.newLine();
}
}
public void write(BufferedWriter bw, String s) throws IOException {
bw.write(s);
bw.newLine();
}
public void alert() {
carsTable.setPlaceholder(new Label("ERROR! Nie znaleziono pliku!!!"));
}
}
| //dodanie adnotacji do listy
| package sample;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.AnchorPane;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class Controller {
private CarShowroomData carShowroomData;
private static final String CSV_SEPARATOR = ";";
private List<Vehicle> soldCars;
@FXML
private ComboBox<String> cityBox;
@FXML
private ComboBox<String> showroomBox;
@FXML
private TableView<Vehicle> carsTable;
@FXML
private TableColumn<Vehicle, String> brandColumn;
@FXML
private TableColumn<Vehicle, String> modelColumn;
@FXML
private TableColumn<Vehicle, Double> priceColumn;
@FXML
private TableColumn<Vehicle, Integer> yearColumn;
@FXML
private TableColumn<Vehicle, ItemCondition> conditionColumn;
@FXML
private TableColumn<Vehicle, String> cityColumn;
@FXML
private TableColumn<Vehicle, String> statusColumn;
@FXML
private TextField searchField;
@FXML
private AnchorPane anchorPane;
public Controller() {
this.carShowroomData = new CarShowroomData();
this.soldCars = new ArrayList<>();
}
public void initialize() {
carsTable.setRowFactory(tv -> new TableRow<Vehicle>() {
private Tooltip tooltip = new Tooltip();
@Override
public void updateItem(Vehicle vehicle, boolean empty) {
super.updateItem(vehicle, empty);
if (vehicle == null) {
setTooltip(null);
} else {
tooltip.setText("Pojemność śilnika: " + vehicle.getEngineCapacity() + " Przebieg: " + vehicle.getMileage());
setTooltip(tooltip);
}
}
});
readFromCSV();
ObservableList<String> listShowroom = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
listShowroom.add("Sprzedane");
listShowroom.add("Salony");
showroomBox.setItems(listShowroom);
showroomBox.getSelectionModel().select("Salony");
ObservableList<String> listCity = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCity());
listCity.add("Miasto");
cityBox.setItems(listCity);
cityBox.getSelectionModel().select("Miasto");
brandColumn.setCellValueFactory(new PropertyValueFactory<>("brand"));
brandColumn.setReorderable(false);
modelColumn.setCellValueFactory(new PropertyValueFactory<>("model"));
modelColumn.setReorderable(false);
priceColumn.setCellValueFactory(new PropertyValueFactory<>("price"));
priceColumn.setReorderable(false);
yearColumn.setCellValueFactory(new PropertyValueFactory<>("yearOfProduction"));
yearColumn.setReorderable(false);
conditionColumn.setCellValueFactory(new PropertyValueFactory<>("condition"));
conditionColumn.setReorderable(false);
cityColumn.setCellValueFactory(new PropertyValueFactory<>("city"));
cityColumn.setReorderable(false);
statusColumn.setCellValueFactory(new PropertyValueFactory<>("status"));
statusColumn.setReorderable(false);
fillTable();
}
@FXML
public void onSalonSelected() {
if (!cityBox.getSelectionModel().getSelectedItem().equals("Miasto")) {
fillWhenCityAndShowroomIsSelected(cityBox.getValue(), showroomBox.getValue());
} else {
if (showroomBox.getValue().equals("Salony")) {
fillTable();
} else if (showroomBox.getValue().equals("Sprzedane")) {
fillTableSold();
} else {
fillTableWhenShowroomSelected(showroomBox.getValue());
}
}
}
@FXML
public void onCitySelected() {
String city = cityBox.getValue();
if (city.equals("Miasto")) {
fillTable();
} else {
fillWhenCitySelected(city);
}
}
@FXML
public void searchButton() {
fillWhenSearch(searchField.getText());
}
public void fillTableWhenShowroomSelected(String name) {
ObservableList<Vehicle> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.selectedParticularShowroom(name).getCarList());
if (!list.isEmpty()) carsTable.setItems(list);
}
public void fillTable() {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (String s : list) {
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
list2.addAll(temp);
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void fillWhenCitySelected(String city) {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (String s : list) {
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
for (Vehicle vehicle : temp) {
if (vehicle.getCity().equals(city)) {
list2.add(vehicle);
}
}
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void fillWhenCityAndShowroomIsSelected(String city, String showroom) {
if (showroom.equals("Salony")) {
fillWhenCitySelected(city);
return;
}
ObservableList<Vehicle> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.selectedParticularShowroom(showroom).getCarList());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (Vehicle vehicle : list) {
if (vehicle.getCity().equals(city)) list2.add(vehicle);
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void fillWhenSearch(String name) {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
for (String s : list) {
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
for (Vehicle vehicle : temp) {
if (vehicle.getBrand().equals(name)) {
list2.add(vehicle);
}
}
}
if (!list2.isEmpty()) carsTable.setItems(list2);
}
// kupowanie samochodu czyli tak naprawdę usuwanie go
public void buyButton() {
if (carsTable.getSelectionModel().getSelectedItem() != null) {
Vehicle vehicle = carsTable.getSelectionModel().getSelectedItem();
if (vehicle.getStatus() != "Rez" && vehicle.getStatus() != "Niedostępny") {
Dialog<ButtonType> dialog = new Dialog<>();
dialog.initOwner(anchorPane.getScene().getWindow());
try {
Parent root = FXMLLoader.load(getClass().getResource("afterBuy.fxml"));
dialog.getDialogPane().setContent(root);
} catch (IOException e) {
System.out.println("Couldn't load the dialog");
e.printStackTrace();
return;
}
dialog.getDialogPane().getButtonTypes().add(ButtonType.OK);
dialog.getDialogPane().getButtonTypes().add(ButtonType.CANCEL);
Optional<ButtonType> result = dialog.showAndWait();
if (result.isPresent() && result.get() == ButtonType.OK) {
vehicle.setStatus("Niedostępny");
carShowroomData.carShowroomContainer.selectedParticularShowroom(carShowroomData.carShowroomContainer.findParticularSaloon(vehicle)).removeProduct(vehicle);
soldCars.add(vehicle);
fillTable();
showroomBox.getSelectionModel().select("Salony");
cityBox.getSelectionModel().select("Miasto");
}
} else {
Alert alert = new Alert(Alert.AlertType.WARNING);
alert.setTitle("Error");
alert.setHeaderText("Samochod zarezerwowany tudziez niedostepny, nie mozesz tego kupic");
alert.showAndWait();
}
}
}
// rezerwacja
public void reservationButton() {
ObservableList<Vehicle> selectedRow, allCars;
allCars = carsTable.getItems();
selectedRow = carsTable.getSelectionModel().getSelectedItems();
for (Vehicle vehicle : selectedRow) {
allCars.remove(vehicle);
vehicle.setStatus("Rez");
allCars.add(vehicle);
carsTable.refresh();
}
}
public void fillTableSold() {
ObservableList<Vehicle> list2 = FXCollections.observableArrayList();
list2.addAll(soldCars);
if (!list2.isEmpty()) carsTable.setItems(list2);
}
public void readFromCSV() {
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
String stringCurrentLine;
for (String s : list) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(s).append(".csv");
try {
BufferedReader bw = new BufferedReader(new InputStreamReader(new FileInputStream(stringBuilder.toString())));
for (int i = 0; (stringCurrentLine = bw.readLine()) != null; i++) {
if (i == 0) {
continue;
}
String[] result = stringCurrentLine.split("\\;");
Vehicle vehicle = new Vehicle(result[0], result[1], ItemCondition.NEW, Double.parseDouble(result[2]), Integer.parseInt(result[3]), Double.parseDouble(result[4]),
Double.parseDouble(result[5]), Integer.parseInt(result[6]), result[7]);
carShowroomData.carShowroomContainer.selectedParticularShowroom(s).addProduct(vehicle);
}
bw.close();
} catch (IOException e) {
alert();
}
}
try {
BufferedReader bw = new BufferedReader(new InputStreamReader(new FileInputStream("SprzedaneSamochody.csv")));
for (int i = 0; (stringCurrentLine = bw.readLine()) != null; i++) {
if (i == 0) {
continue;
}
String[] result = stringCurrentLine.split("\\;");
Vehicle vehicle = new Vehicle(result[0], result[1], ItemCondition.NEW, Double.parseDouble(result[2]), Integer.parseInt(result[3]), Double.parseDouble(result[4]),
Double.parseDouble(result[5]), Integer.parseInt(result[6]), result[7]);
vehicle.setStatus("Niedostępny");
soldCars.add(vehicle);
}
} catch (IOException e) {
alert();
}
}
public void writeToCSV() {
ArrayList<String> columnNames = new ArrayList<String>();
for (Field f : Vehicle.class.getDeclaredFields()) {
CSVAnnotation annotation = f.getDeclaredAnnotation(CSVAnnotation.class);
if (annotation != null)
columnNames.add(annotation.value()); //dodanie adnotacji <SUF>
}
String concatenated = String.join(",", columnNames);
ObservableList<String> list = FXCollections.observableArrayList(carShowroomData.carShowroomContainer.listOfCarSaloons());
for (String s : list) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(s).append(".csv");
List<Vehicle> temp = new ArrayList<>(carShowroomData.carShowroomContainer.selectedParticularShowroom(s).getCarList());
try {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(stringBuilder.toString()), "UTF-8"));
write(bw, concatenated);
write(bw, temp);
bw.flush();
bw.close();
} catch (IOException e) {
alert();
}
}
try {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("SprzedaneSamochody.csv"), "UTF-8"));
write(bw, concatenated);
write(bw, soldCars);
bw.flush();
bw.close();
} catch (IOException e) {
alert();
}
}
public void write(BufferedWriter bw, List<Vehicle> sold) throws IOException {
for (Vehicle vehicle : sold) {
StringBuffer oneLine = new StringBuffer();
oneLine.append(vehicle.getBrand().trim().length() == 0 ? "" : vehicle.getBrand());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getModel().trim().length() == 0 ? "" : vehicle.getModel());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getPrice() < 0 ? "" : vehicle.getPrice());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getYearOfProduction() < 0 ? "" : vehicle.getYearOfProduction());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getMileage() < 0 ? "" : vehicle.getMileage());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getEngineCapacity() < 0 ? "" : vehicle.getEngineCapacity());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getAmount() < 0 ? "" : vehicle.getAmount());
oneLine.append(CSV_SEPARATOR);
oneLine.append(vehicle.getCity().trim().length() == 0 ? "" : vehicle.getCity());
bw.write(oneLine.toString());
bw.newLine();
}
}
public void write(BufferedWriter bw, String s) throws IOException {
bw.write(s);
bw.newLine();
}
public void alert() {
carsTable.setPlaceholder(new Label("ERROR! Nie znaleziono pliku!!!"));
}
}
| t |
2825_3 | karolk-pwr/WdPO22 | 714 | Cheatsheets/psy/Pies.java | package psy;
/**
* Klasa psy.Pies
*/
public class Pies {
private int wiek;
private String rasa;
private String imie;
/**
* Domyślny konstruktor
*/
public Pies () {
wiek = 1;
rasa = "kundel";
imie = "Azor";
}
/**
* Konstruktor pobierający trzy parametry
* @param init_wiek wiek psa
* @param init_rasa rasa psa
* @param init_imie imię psa
*/
public Pies (int init_wiek, String init_rasa, String init_imie) {
wiek = init_wiek;
rasa = init_rasa;
imie = init_imie;
}
/**
* Zmień imię psa
* @param nowe_imie imię psa
*/
public void setImie(String nowe_imie) {
imie = nowe_imie;
}
/**
* Zmień rasę psa
* @param nowa_rasa rasa psa
*/
public void setRasa(String nowa_rasa) {
rasa = nowa_rasa;
}
/**
* Zmień wiek pieska
* @param nowy_wiek wiek w latach
* @throws IllegalArgumentException jeśli wiek <= 0
*/
public void setWiek(int nowy_wiek) {
try {
if (nowy_wiek <= 0) {
throw new IllegalArgumentException("Niepoprawny wiek!");
}
else {
wiek = nowy_wiek;
}
} catch (IllegalArgumentException e) {
System.out.println(e);
}
}
/**
* Informacje o piesku
*/
public void getInfo() {
System.out.println("Hau hau, mam na imię " + imie + " jestem psem rasy " + rasa + " i mam " + wiek + " lat, szczek szczek"); // (5)
}
/**
* Metoda do tworzenia psów
* @param init_wiek wiek psa
* @param init_rasa rasa psa
* @param init_imie imię psa
*/
static public Pies nowyPies(int init_wiek, String init_rasa, String init_imie) {
Pies nowy_pies = new Pies(init_wiek, init_rasa, init_imie);
return nowy_pies;
}
}
| /**
* Zmień imię psa
* @param nowe_imie imię psa
*/ | package psy;
/**
* Klasa psy.Pies
*/
public class Pies {
private int wiek;
private String rasa;
private String imie;
/**
* Domyślny konstruktor
*/
public Pies () {
wiek = 1;
rasa = "kundel";
imie = "Azor";
}
/**
* Konstruktor pobierający trzy parametry
* @param init_wiek wiek psa
* @param init_rasa rasa psa
* @param init_imie imię psa
*/
public Pies (int init_wiek, String init_rasa, String init_imie) {
wiek = init_wiek;
rasa = init_rasa;
imie = init_imie;
}
/**
* Zmień imię psa <SUF>*/
public void setImie(String nowe_imie) {
imie = nowe_imie;
}
/**
* Zmień rasę psa
* @param nowa_rasa rasa psa
*/
public void setRasa(String nowa_rasa) {
rasa = nowa_rasa;
}
/**
* Zmień wiek pieska
* @param nowy_wiek wiek w latach
* @throws IllegalArgumentException jeśli wiek <= 0
*/
public void setWiek(int nowy_wiek) {
try {
if (nowy_wiek <= 0) {
throw new IllegalArgumentException("Niepoprawny wiek!");
}
else {
wiek = nowy_wiek;
}
} catch (IllegalArgumentException e) {
System.out.println(e);
}
}
/**
* Informacje o piesku
*/
public void getInfo() {
System.out.println("Hau hau, mam na imię " + imie + " jestem psem rasy " + rasa + " i mam " + wiek + " lat, szczek szczek"); // (5)
}
/**
* Metoda do tworzenia psów
* @param init_wiek wiek psa
* @param init_rasa rasa psa
* @param init_imie imię psa
*/
static public Pies nowyPies(int init_wiek, String init_rasa, String init_imie) {
Pies nowy_pies = new Pies(init_wiek, init_rasa, init_imie);
return nowy_pies;
}
}
| t |
4952_3 | kczapla/eksterminator | 538 | eksterminatorbeta/Obraz.java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package eksterminatorbeta;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author perun
*/
public class Obraz {
/**
* Konstruktor klasy Obraz, ktory wczytuje sprite sheeta z postaciami do gry
*/
public Obraz(){
try {
image = load.LoadImage("/res/Siatka.png/");
bgimage = load.LoadImage("/res/tlo.png/");
} catch (IOException ex) {
Logger.getLogger(Obraz.class.getName()).log(Level.SEVERE, null, ex);
}
ss = new SpriteSheet(image);
getTextures();
}
/**
* Metoda przypisująca konkretną grafikę do pola np. avatar gracza
* przypisuje do pola player, ktory będzie wykorzystany w klasie gracza
*/
private void getTextures(){
player = ss.grabImage(1, 1, 32, 32);
bullet = ss.grabImage(2, 1, 32, 32);
enemy1 = ss.grabImage(3, 1, 32, 32);
enemy2 = ss.grabImage(6, 1, 32, 32);
enemy3 = ss.grabImage(7, 1, 32, 32);
}
public BufferedImage player;
public BufferedImage bullet;
public BufferedImage enemy1;
public BufferedImage enemy2;
public BufferedImage enemy3;
BufferedImage image;
BufferedImage bgimage;
ImageLoader load = new ImageLoader();
SpriteSheet ss;
}
| /**
* Metoda przypisująca konkretną grafikę do pola np. avatar gracza
* przypisuje do pola player, ktory będzie wykorzystany w klasie gracza
*/ | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package eksterminatorbeta;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author perun
*/
public class Obraz {
/**
* Konstruktor klasy Obraz, ktory wczytuje sprite sheeta z postaciami do gry
*/
public Obraz(){
try {
image = load.LoadImage("/res/Siatka.png/");
bgimage = load.LoadImage("/res/tlo.png/");
} catch (IOException ex) {
Logger.getLogger(Obraz.class.getName()).log(Level.SEVERE, null, ex);
}
ss = new SpriteSheet(image);
getTextures();
}
/**
* Metoda przypisująca konkretną <SUF>*/
private void getTextures(){
player = ss.grabImage(1, 1, 32, 32);
bullet = ss.grabImage(2, 1, 32, 32);
enemy1 = ss.grabImage(3, 1, 32, 32);
enemy2 = ss.grabImage(6, 1, 32, 32);
enemy3 = ss.grabImage(7, 1, 32, 32);
}
public BufferedImage player;
public BufferedImage bullet;
public BufferedImage enemy1;
public BufferedImage enemy2;
public BufferedImage enemy3;
BufferedImage image;
BufferedImage bgimage;
ImageLoader load = new ImageLoader();
SpriteSheet ss;
}
| t |
7297_3 | keencelia/advanced-java | 1,392 | practice/multithreading/SearchEngine.java | package mini.java.task;
public class SearchEngine {
private Thread loaderThread;
private Thread[] indexerThreads;
private DataLoader loader;
private InvertedIndex[] indexers;
private queue;
private index;
/**
* Konstruuje SearchEngine
* @param dir - nazwa katalogu
* @param pattern - nazwa pliku lub wzoru plików wg wyrażeń regularnych (nie wildcard !!!)
* @param indexerNum - liczba indeksujących wątków
*/
public SearchEngine(String dir, String pattern, int indexerNum) {
// TODO: utwórz queue oraz index
loader = new DataLoader();
indexerNum = Math.max(1,indexerNum);
indexers = new InvertedIndex[indexerNum];
indexerThreads = new Thread[indexerNum];
for (int i = 0; i<indexerNum; i++) {
indexers[i] = new InvertedIndex(index);
}
loaderThread = new Thread(new Runnable() {
@Override
public void run() {
loader.read(dir, pattern, queue);
}
});
for (int i = 0; i < indexerNum; i++) {
int finalI = i;
indexerThreads[i] = new Thread(new Runnable() {
@Override
public void run() {
indexers[finalI].build(queue);
}
});
}
}
/**
* startuje wszystkie wątki które budują index
*/
public void build () {
loaderThread.start();
for (int i = 0; i < indexerThreads.length; i++) {
indexerThreads[i].start();
}
}
/**
* przeszukuje index celem znalezienia lokalizacji słów, po czym czyta z pliku odpowiednią linię
* indexer przeszukuje index wg zasad wyjaśnionych w opisie metody w InvertedIndex
* DataLoader wczytuje linię (w głównym, nie w osobnym wątku)
* @param words - jedno lub więcej słów do wyszukania
* @return Entry zawierające nazwę pliku, nr linii, oraz daną linię wczytaną z pliku (na żądanie)
*/
public Entry query(String words) {
Entry entry = indexers[0].query(words);
if (entry == null) return null;
entry.setText(loader.load(entry.getFilename(), entry.getLine()));
return entry;
}
/**
* zatrzymuje budowanie indeksu(poprzez zastopowanie wszystkich wątków)
*/
public void stop() {
loader.stop();
for (int i = 0; i < indexerThreads.length; i++) {
indexers[i].stop();
}
}
/**
* zwraca rozmiar indeksu
* @return liczba kluczy w indeksie
*/
public int getSize() {
return index.size();
}
/**
* zwraca wszystkie słowa w indeksie, posortowane
* @return all keys in the index, sorted
*/
public List<String> getWords() {
ArrayList <String> list = new ArrayList <>();
list.addAll(index.keySet());
Collections.sort(list);
return list;
}
/**
* sprawdza czy wszystkie wątki pracują
* @return
*/
public boolean isRunning() {
boolean isRunning = !loaderThread.getState().equals(Thread.State.TERMINATED);
for (int i = 0; i < indexerThreads.length; i++) {
isRunning = isRunning && !indexerThreads[i].getState().equals(Thread.State.TERMINATED);
}
return isRunning;
}
/**
* sprawdza czy wszystkie wątki się zakończyły
* @return
*/
public boolean isStopped() {
boolean isStopped = loaderThread.getState().equals(Thread.State.TERMINATED);
for (int i = 0; i < indexerThreads.length; i++) {
isStopped = isStopped && indexerThreads[i].getState().equals(Thread.State.TERMINATED);
}
return isStopped;
}
/**
* podklasa Entry do zwracania rezultatów
*/
static public class Entry {
private String text;
private String filename;
private int line;
public Entry(String filename, int line) {
this.filename = filename;
this.line = line;
}
public Entry(String filename, int line, String text) {
this.filename = filename;
this.line = line;
this.text = text;
}
public String getText() {
return text;
}
public String getFilename() {
return filename;
}
public int getLine() {
return line;
}
public void setText(String text) {
this.text = text;
}
}
}
| /**
* przeszukuje index celem znalezienia lokalizacji słów, po czym czyta z pliku odpowiednią linię
* indexer przeszukuje index wg zasad wyjaśnionych w opisie metody w InvertedIndex
* DataLoader wczytuje linię (w głównym, nie w osobnym wątku)
* @param words - jedno lub więcej słów do wyszukania
* @return Entry zawierające nazwę pliku, nr linii, oraz daną linię wczytaną z pliku (na żądanie)
*/ | package mini.java.task;
public class SearchEngine {
private Thread loaderThread;
private Thread[] indexerThreads;
private DataLoader loader;
private InvertedIndex[] indexers;
private queue;
private index;
/**
* Konstruuje SearchEngine
* @param dir - nazwa katalogu
* @param pattern - nazwa pliku lub wzoru plików wg wyrażeń regularnych (nie wildcard !!!)
* @param indexerNum - liczba indeksujących wątków
*/
public SearchEngine(String dir, String pattern, int indexerNum) {
// TODO: utwórz queue oraz index
loader = new DataLoader();
indexerNum = Math.max(1,indexerNum);
indexers = new InvertedIndex[indexerNum];
indexerThreads = new Thread[indexerNum];
for (int i = 0; i<indexerNum; i++) {
indexers[i] = new InvertedIndex(index);
}
loaderThread = new Thread(new Runnable() {
@Override
public void run() {
loader.read(dir, pattern, queue);
}
});
for (int i = 0; i < indexerNum; i++) {
int finalI = i;
indexerThreads[i] = new Thread(new Runnable() {
@Override
public void run() {
indexers[finalI].build(queue);
}
});
}
}
/**
* startuje wszystkie wątki które budują index
*/
public void build () {
loaderThread.start();
for (int i = 0; i < indexerThreads.length; i++) {
indexerThreads[i].start();
}
}
/**
* przeszukuje index celem <SUF>*/
public Entry query(String words) {
Entry entry = indexers[0].query(words);
if (entry == null) return null;
entry.setText(loader.load(entry.getFilename(), entry.getLine()));
return entry;
}
/**
* zatrzymuje budowanie indeksu(poprzez zastopowanie wszystkich wątków)
*/
public void stop() {
loader.stop();
for (int i = 0; i < indexerThreads.length; i++) {
indexers[i].stop();
}
}
/**
* zwraca rozmiar indeksu
* @return liczba kluczy w indeksie
*/
public int getSize() {
return index.size();
}
/**
* zwraca wszystkie słowa w indeksie, posortowane
* @return all keys in the index, sorted
*/
public List<String> getWords() {
ArrayList <String> list = new ArrayList <>();
list.addAll(index.keySet());
Collections.sort(list);
return list;
}
/**
* sprawdza czy wszystkie wątki pracują
* @return
*/
public boolean isRunning() {
boolean isRunning = !loaderThread.getState().equals(Thread.State.TERMINATED);
for (int i = 0; i < indexerThreads.length; i++) {
isRunning = isRunning && !indexerThreads[i].getState().equals(Thread.State.TERMINATED);
}
return isRunning;
}
/**
* sprawdza czy wszystkie wątki się zakończyły
* @return
*/
public boolean isStopped() {
boolean isStopped = loaderThread.getState().equals(Thread.State.TERMINATED);
for (int i = 0; i < indexerThreads.length; i++) {
isStopped = isStopped && indexerThreads[i].getState().equals(Thread.State.TERMINATED);
}
return isStopped;
}
/**
* podklasa Entry do zwracania rezultatów
*/
static public class Entry {
private String text;
private String filename;
private int line;
public Entry(String filename, int line) {
this.filename = filename;
this.line = line;
}
public Entry(String filename, int line, String text) {
this.filename = filename;
this.line = line;
this.text = text;
}
public String getText() {
return text;
}
public String getFilename() {
return filename;
}
public int getLine() {
return line;
}
public void setText(String text) {
this.text = text;
}
}
}
| t |
8114_0 | keencelia/oo-java2 | 1,229 | lab4/Doreczyciel.java | package mini.java.poczta;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public abstract class Doreczyciel {
protected Poczta poczta;
protected List <Przesylka> doDostarczenia = new ArrayList <Przesylka>();
protected int maxPrzesylki = 100;
protected boolean wpracy = true;
protected boolean zajety = false;
protected HashMap <Class, Boolean> akceptuje = new HashMap <Class, Boolean>();
protected HashMap <Class, Double> dostarczam = new HashMap <Class, Double>();
protected Doreczyciel(Poczta poczta) {
this.poczta = poczta;
poczta.addDoreczyciel(this);
}
protected Doreczyciel(Poczta poczta, int maxPrzesylki) {
this.poczta = poczta;
this.maxPrzesylki = maxPrzesylki;
poczta.addDoreczyciel(this);
}
protected void niePrzyjmuje(Class c) {
this.akceptuje.put(c, false);
}
protected void dostarczam(Class c, double p) {
this.dostarczam.put(c, p);
}
public boolean isWpracy() {
return wpracy;
}
public void setWpracy(boolean wpracy) {
this.wpracy = wpracy;
}
public boolean isZajety() {
return zajety;
}
public void setZajety(boolean zajety) {
this.zajety = zajety;
}
public int getMaxPrzesylki() {
return maxPrzesylki;
}
public int getIleMa() {
return this.doDostarczenia.size();
}
/**
* sprawdza po kolei, wiec kolejnosć istotna
* @param p
* @return
*/
public boolean akceptuje(Przesylka p) {
Boolean a=null;
for (Class c: this.akceptuje.keySet()) {
if (c.isInstance(p)) {
a = this.akceptuje.get(c);
return a;
}
}
return true;
}
/**
* gorszy sposób ale też działa
* @param p
* @return
*/
public boolean akceptuje2(Przesylka p) {
Boolean a = null;
Class c = p.getClass();
while (c != null) {
if ((a = this.akceptuje.get(c)) != null) break;
c = c.getSuperclass();
}
if ((a != null && !a.booleanValue()))
return false;
return true;
}
/**
*
* @param p
* @return
*/
protected double jakCzestoDostarczam(Przesylka p) {
Double prob = null;
for (Class c: this.dostarczam.keySet()) {
if (c.isInstance(p)) {
prob = this.dostarczam.get(c);
return prob;
}
}
return 1.0;
}
protected boolean pobierz() {
List<Przesylka> przesylki = poczta.dajPrzesylki(this);
doDostarczenia.addAll(przesylki);
return (!doDostarczenia.isEmpty());
}
protected boolean dorecz() {
List<Przesylka> niedostarczone = new ArrayList<Przesylka>();
int dostarczone = 0;
for (Przesylka p: this.doDostarczenia) {
double prob = jakCzestoDostarczam(p);
if (Math.random() > prob) {
niedostarczone.add(p);
}
else {
dostarczone++;
}
}
System.out.println(this.getClass().getSimpleName().toString() +
": dostarczy1em " + dostarczone + " z " + this.doDostarczenia.size() + " przesylek");
this.doDostarczenia.clear();
return poczta.odbierzPrzesylki(niedostarczone);
}
public void doreczPrzesylki() {
if (!wpracy || zajety) return;
zajety = true;
if (pobierz()) {
dorecz();
}
zajety = false;
}
}
| /**
* sprawdza po kolei, wiec kolejnosć istotna
* @param p
* @return
*/ | package mini.java.poczta;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public abstract class Doreczyciel {
protected Poczta poczta;
protected List <Przesylka> doDostarczenia = new ArrayList <Przesylka>();
protected int maxPrzesylki = 100;
protected boolean wpracy = true;
protected boolean zajety = false;
protected HashMap <Class, Boolean> akceptuje = new HashMap <Class, Boolean>();
protected HashMap <Class, Double> dostarczam = new HashMap <Class, Double>();
protected Doreczyciel(Poczta poczta) {
this.poczta = poczta;
poczta.addDoreczyciel(this);
}
protected Doreczyciel(Poczta poczta, int maxPrzesylki) {
this.poczta = poczta;
this.maxPrzesylki = maxPrzesylki;
poczta.addDoreczyciel(this);
}
protected void niePrzyjmuje(Class c) {
this.akceptuje.put(c, false);
}
protected void dostarczam(Class c, double p) {
this.dostarczam.put(c, p);
}
public boolean isWpracy() {
return wpracy;
}
public void setWpracy(boolean wpracy) {
this.wpracy = wpracy;
}
public boolean isZajety() {
return zajety;
}
public void setZajety(boolean zajety) {
this.zajety = zajety;
}
public int getMaxPrzesylki() {
return maxPrzesylki;
}
public int getIleMa() {
return this.doDostarczenia.size();
}
/**
* sprawdza po kolei, <SUF>*/
public boolean akceptuje(Przesylka p) {
Boolean a=null;
for (Class c: this.akceptuje.keySet()) {
if (c.isInstance(p)) {
a = this.akceptuje.get(c);
return a;
}
}
return true;
}
/**
* gorszy sposób ale też działa
* @param p
* @return
*/
public boolean akceptuje2(Przesylka p) {
Boolean a = null;
Class c = p.getClass();
while (c != null) {
if ((a = this.akceptuje.get(c)) != null) break;
c = c.getSuperclass();
}
if ((a != null && !a.booleanValue()))
return false;
return true;
}
/**
*
* @param p
* @return
*/
protected double jakCzestoDostarczam(Przesylka p) {
Double prob = null;
for (Class c: this.dostarczam.keySet()) {
if (c.isInstance(p)) {
prob = this.dostarczam.get(c);
return prob;
}
}
return 1.0;
}
protected boolean pobierz() {
List<Przesylka> przesylki = poczta.dajPrzesylki(this);
doDostarczenia.addAll(przesylki);
return (!doDostarczenia.isEmpty());
}
protected boolean dorecz() {
List<Przesylka> niedostarczone = new ArrayList<Przesylka>();
int dostarczone = 0;
for (Przesylka p: this.doDostarczenia) {
double prob = jakCzestoDostarczam(p);
if (Math.random() > prob) {
niedostarczone.add(p);
}
else {
dostarczone++;
}
}
System.out.println(this.getClass().getSimpleName().toString() +
": dostarczy1em " + dostarczone + " z " + this.doDostarczenia.size() + " przesylek");
this.doDostarczenia.clear();
return poczta.odbierzPrzesylki(niedostarczone);
}
public void doreczPrzesylki() {
if (!wpracy || zajety) return;
zajety = true;
if (pobierz()) {
dorecz();
}
zajety = false;
}
}
| t |
7050_1 | kempikl/GUI-PJATK | 474 | src/PRO1/Pawn.java | package PRO1;
import java.util.ArrayList;
import java.util.List;
public class Pawn extends Figure {
/**
* Konstruktor klasy Pawn.
*
* @param isWhite Czy pionek należy do białego gracza (true) czy czarnego (false).
*/
public Pawn(boolean isWhite) {
super(isWhite);
figureType = FigureType.PAWN;
}
@Override
public List<int[]> getPossibleMoves(Board board) {
List<int[]> moves = new ArrayList<>();
int direction = isWhite() ? -1 : 1;
int newRow = row + direction;
// Ruch o jedno pole do przodu
if (board.isValidMove(row, col, newRow, col)) {
moves.add(new int[]{newRow, col});
// Ruch o dwa pola do przodu dla pionka, który jeszcze się nie ruszał
int twoStepsRow = newRow + direction;
if ((isWhite() && row == 6) || (!isWhite() && row == 1)) {
if (board.isValidMove(row, col, twoStepsRow, col)) {
moves.add(new int[]{twoStepsRow, col});
}
}
}
// Bicie po skosie
for (int newCol = col - 1; newCol <= col + 1; newCol += 2) {
if (board.isValidMove(row, col, newRow, newCol)) {
moves.add(new int[]{newRow, newCol});
}
}
return moves;
}
@Override
public char getSymbol() {
if (isWhite) return '\u2659';
else return '\u265F';
}
}
| // Ruch o jedno pole do przodu | package PRO1;
import java.util.ArrayList;
import java.util.List;
public class Pawn extends Figure {
/**
* Konstruktor klasy Pawn.
*
* @param isWhite Czy pionek należy do białego gracza (true) czy czarnego (false).
*/
public Pawn(boolean isWhite) {
super(isWhite);
figureType = FigureType.PAWN;
}
@Override
public List<int[]> getPossibleMoves(Board board) {
List<int[]> moves = new ArrayList<>();
int direction = isWhite() ? -1 : 1;
int newRow = row + direction;
// Ruch o <SUF>
if (board.isValidMove(row, col, newRow, col)) {
moves.add(new int[]{newRow, col});
// Ruch o dwa pola do przodu dla pionka, który jeszcze się nie ruszał
int twoStepsRow = newRow + direction;
if ((isWhite() && row == 6) || (!isWhite() && row == 1)) {
if (board.isValidMove(row, col, twoStepsRow, col)) {
moves.add(new int[]{twoStepsRow, col});
}
}
}
// Bicie po skosie
for (int newCol = col - 1; newCol <= col + 1; newCol += 2) {
if (board.isValidMove(row, col, newRow, newCol)) {
moves.add(new int[]{newRow, newCol});
}
}
return moves;
}
@Override
public char getSymbol() {
if (isWhite) return '\u2659';
else return '\u265F';
}
}
| t |
9988_10 | kirkosyn/Java-project | 1,417 | Klient/Objects/Bullet.java | package Objects;
import Constants.Constants;
import Constants.GameParam;
import javax.swing.*;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.BasicStroke;
/**
* Klasa opisująca pocisk
*/
public class Bullet extends JComponent {
/**
* Pozycja X obiektu
*/
int posX;
/**
* Pozycja Y obiektu
*/
int posY;
/**
* szerokość statku
*/
private int imageWidth = GameParam.shipWidth;
/**
* wysokość statku
*/
private int imageHeight = GameParam.shipHeight;
/**
* Wysokość ekranu
*/
private int winHeight = Constants.gameFrameHeight;
/**
* szerokość ekranu
*/
private int winWidth = Constants.gameFrameWidth;
/**
* przebyta droga X w przypadku poruszania się pocisku pod kątem
*/
private double velocity_posX = 0;
/**
* przebyta droga Y w przypadku poruszania się pocisku pod kątem
*/
private double velocity_posY = 0;
/**
* szybkość poruszania się pocisku
*/
private static final int SPEED = 5;
/**
* maksymalna długość życia pocisków
*/
private static final int LIFE_SPAN = 70;
/**
* kąt, pod jakim jest wystrzeliwany pocisk
*/
private double angle;
/**
* długość życia aktualnej liczby pocisków
*/
private int life = 0;
/**
* konstruktor pocisku
*
* @param posX pozycja X
* @param posY pozycja Y
* @param angle kąt
*/
public Bullet(int posX, int posY, double angle) {
this.posX = posX + imageWidth / 2;
this.posY = posY + imageHeight / 2;
this.angle = angle;
}
/**
* metoda poruszająca pocisk
*
* @return prawda lub fałsz, prawda w przypadku osiągnięcia max
* długości życia pocisku, fałsz w p.p.
*/
public boolean move() {
if (angle > (2 * Math.PI))
angle -= (2 * Math.PI);
else if (angle < 0)
angle += (2 * Math.PI);
velocity_posX = SPEED * Math.cos(angle);
velocity_posY = SPEED * Math.sin(angle);
posX = (int) (posX + velocity_posX);
posY = (int) (posY + velocity_posY);
if (posX >= winWidth)
posX = 1;
if (posX <= 0)
posX = winWidth;
if (posY >= winHeight)
posY = 1;
if (posY <= 0)
posY = winHeight;
life++;
if (life >= LIFE_SPAN)
return true;
return false;
}
/**
* rysowanie pocisku
*
* @param g grafika
*/
public void draw(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
int xPoint[] = {(int) (10 * Math.cos(angle) + posX + 0.5), (int) (15 * Math.cos(angle) + posX + 0.5)};
int yPoint[] = {(int) (10 * Math.sin(angle) + posY + 0.5), (int) (15 * Math.sin(angle) + posY + 0.5)};
g2.setStroke(new BasicStroke(4));
g2.drawPolygon(xPoint, yPoint, 2);
}
/**
* Metoda pobierająca pozycję X obiektu
*
* @return pozycja X
*/
public int getPosX() {
return posX;
}
/**
* Metoda pobierająca pozycję Y obiektu
*
* @return pozycja Y
*/
public int getPosY() {
return posY;
}
/**
* metoda ustawiająca wielkość okna
*
* @param w szerokość
* @param h wysokość
*/
public void setWin(int w, int h) {
winWidth = w;
winHeight = h;
}
/**
* Metoda ustawiająca rozmiar statku
*
* @param w szerokość
* @param h wysokość
*/
public void setSize(int w, int h) {
imageHeight = h;
imageWidth = w;
}
} | /**
* maksymalna długość życia pocisków
*/ | package Objects;
import Constants.Constants;
import Constants.GameParam;
import javax.swing.*;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.BasicStroke;
/**
* Klasa opisująca pocisk
*/
public class Bullet extends JComponent {
/**
* Pozycja X obiektu
*/
int posX;
/**
* Pozycja Y obiektu
*/
int posY;
/**
* szerokość statku
*/
private int imageWidth = GameParam.shipWidth;
/**
* wysokość statku
*/
private int imageHeight = GameParam.shipHeight;
/**
* Wysokość ekranu
*/
private int winHeight = Constants.gameFrameHeight;
/**
* szerokość ekranu
*/
private int winWidth = Constants.gameFrameWidth;
/**
* przebyta droga X w przypadku poruszania się pocisku pod kątem
*/
private double velocity_posX = 0;
/**
* przebyta droga Y w przypadku poruszania się pocisku pod kątem
*/
private double velocity_posY = 0;
/**
* szybkość poruszania się pocisku
*/
private static final int SPEED = 5;
/**
* maksymalna długość życia <SUF>*/
private static final int LIFE_SPAN = 70;
/**
* kąt, pod jakim jest wystrzeliwany pocisk
*/
private double angle;
/**
* długość życia aktualnej liczby pocisków
*/
private int life = 0;
/**
* konstruktor pocisku
*
* @param posX pozycja X
* @param posY pozycja Y
* @param angle kąt
*/
public Bullet(int posX, int posY, double angle) {
this.posX = posX + imageWidth / 2;
this.posY = posY + imageHeight / 2;
this.angle = angle;
}
/**
* metoda poruszająca pocisk
*
* @return prawda lub fałsz, prawda w przypadku osiągnięcia max
* długości życia pocisku, fałsz w p.p.
*/
public boolean move() {
if (angle > (2 * Math.PI))
angle -= (2 * Math.PI);
else if (angle < 0)
angle += (2 * Math.PI);
velocity_posX = SPEED * Math.cos(angle);
velocity_posY = SPEED * Math.sin(angle);
posX = (int) (posX + velocity_posX);
posY = (int) (posY + velocity_posY);
if (posX >= winWidth)
posX = 1;
if (posX <= 0)
posX = winWidth;
if (posY >= winHeight)
posY = 1;
if (posY <= 0)
posY = winHeight;
life++;
if (life >= LIFE_SPAN)
return true;
return false;
}
/**
* rysowanie pocisku
*
* @param g grafika
*/
public void draw(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
int xPoint[] = {(int) (10 * Math.cos(angle) + posX + 0.5), (int) (15 * Math.cos(angle) + posX + 0.5)};
int yPoint[] = {(int) (10 * Math.sin(angle) + posY + 0.5), (int) (15 * Math.sin(angle) + posY + 0.5)};
g2.setStroke(new BasicStroke(4));
g2.drawPolygon(xPoint, yPoint, 2);
}
/**
* Metoda pobierająca pozycję X obiektu
*
* @return pozycja X
*/
public int getPosX() {
return posX;
}
/**
* Metoda pobierająca pozycję Y obiektu
*
* @return pozycja Y
*/
public int getPosY() {
return posY;
}
/**
* metoda ustawiająca wielkość okna
*
* @param w szerokość
* @param h wysokość
*/
public void setWin(int w, int h) {
winWidth = w;
winHeight = h;
}
/**
* Metoda ustawiająca rozmiar statku
*
* @param w szerokość
* @param h wysokość
*/
public void setSize(int w, int h) {
imageHeight = h;
imageWidth = w;
}
} | t |
10273_0 | klaudek123/hangman | 1,163 | Wisielec-GUI/src/main/java/LoginGUI.java | package main.java;
import org.json.JSONObject;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.net.Socket;
import java.net.SocketException;
public class LoginGUI extends JFrame {
private JTextField usernameField;
private JButton loginButton;
private Socket socket;
private JsonObjectReader jsonObjectReader;
PrintWriter out;
public LoginGUI(Socket socket) {
this.socket = socket;
jsonObjectReader = new JsonObjectReader();
setTitle("Login");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(1000, 750);
setLayout(new FlowLayout());
JLabel usernameLabel = new JLabel("Nick:");
usernameField = new JTextField(15);
loginButton = new JButton("Zaloguj");
add(usernameLabel);
add(usernameField);
add(loginButton);
loginButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String username = usernameField.getText().trim();
if (username.isEmpty()) {
JOptionPane.showMessageDialog(null, "Proszę podać nick.", "Błąd logowania", JOptionPane.ERROR_MESSAGE);
} else {
if(doesUsernameExist(username)){
dispose(); // Zamknij okno logowania po zalogowaniu
new LobbyGUI(username, socket);
JOptionPane.showMessageDialog(null, "Nick jest poprawny.", "Poprawne logowanie", JOptionPane.INFORMATION_MESSAGE);
}else {
handleUsernameExistence(username);
}
}
}
});
setVisible(true);
// Dodanie WindowListener do obsługi zdarzenia zamknięcia okna
addWindowListener(new java.awt.event.WindowAdapter() {
@Override
public void windowClosing(java.awt.event.WindowEvent windowEvent) {
closeWindow();
}
});
}
private void handleUsernameExistence(String username) {
int option = JOptionPane.showConfirmDialog(
null,
"Nick jest zajęty. Czy chcesz spróbować innego?",
"Błąd logowania",
JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE
);
if (option == JOptionPane.YES_OPTION) {
// Użytkownik chce spróbować ponownie
// Możesz dodać dowolne dodatkowe akcje tutaj
// Na przykład wyczyść pole usernameField i pozwól mu wprowadzić nową nazwę użytkownika.
new LoginGUI(socket);
dispose();
} else {
// Zamknij okno logowania
dispose();
}
}
private void closeWindow() {
dispose();
}
private boolean doesUsernameExist(String username) {
JSONObject jsonResponse = null; // Zadeklaruj przed try, aby była dostępna poza blokiem
String command = "register";
try {
try {
out = new PrintWriter(socket.getOutputStream(), true);
} catch (SocketException se) {
if (socket.isClosed()) {
socket = new Socket("192.168.0.12", 8080);
out = new PrintWriter(socket.getOutputStream(), true);
}
}
JSONObject jsonRequest = new JSONObject();
jsonRequest.put("command", command);
jsonRequest.put("username", username);
System.out.println("request:" + jsonRequest);
out.println(jsonRequest.toString());
jsonResponse = jsonObjectReader.readJsonObject(username, command, socket);
if (jsonResponse != null) {
// Przetwarzamy odpowiedź (możesz przyjąć, że odpowiedź będzie w formacie JSON)
return jsonResponse.getBoolean("success");
}
} catch (IOException e) {
e.printStackTrace();
}
return false; // Obsługa błędu - zwracamy false
}
}
| // Zamknij okno logowania po zalogowaniu
| package main.java;
import org.json.JSONObject;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.net.Socket;
import java.net.SocketException;
public class LoginGUI extends JFrame {
private JTextField usernameField;
private JButton loginButton;
private Socket socket;
private JsonObjectReader jsonObjectReader;
PrintWriter out;
public LoginGUI(Socket socket) {
this.socket = socket;
jsonObjectReader = new JsonObjectReader();
setTitle("Login");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(1000, 750);
setLayout(new FlowLayout());
JLabel usernameLabel = new JLabel("Nick:");
usernameField = new JTextField(15);
loginButton = new JButton("Zaloguj");
add(usernameLabel);
add(usernameField);
add(loginButton);
loginButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String username = usernameField.getText().trim();
if (username.isEmpty()) {
JOptionPane.showMessageDialog(null, "Proszę podać nick.", "Błąd logowania", JOptionPane.ERROR_MESSAGE);
} else {
if(doesUsernameExist(username)){
dispose(); // Zamknij okno <SUF>
new LobbyGUI(username, socket);
JOptionPane.showMessageDialog(null, "Nick jest poprawny.", "Poprawne logowanie", JOptionPane.INFORMATION_MESSAGE);
}else {
handleUsernameExistence(username);
}
}
}
});
setVisible(true);
// Dodanie WindowListener do obsługi zdarzenia zamknięcia okna
addWindowListener(new java.awt.event.WindowAdapter() {
@Override
public void windowClosing(java.awt.event.WindowEvent windowEvent) {
closeWindow();
}
});
}
private void handleUsernameExistence(String username) {
int option = JOptionPane.showConfirmDialog(
null,
"Nick jest zajęty. Czy chcesz spróbować innego?",
"Błąd logowania",
JOptionPane.YES_NO_OPTION,
JOptionPane.ERROR_MESSAGE
);
if (option == JOptionPane.YES_OPTION) {
// Użytkownik chce spróbować ponownie
// Możesz dodać dowolne dodatkowe akcje tutaj
// Na przykład wyczyść pole usernameField i pozwól mu wprowadzić nową nazwę użytkownika.
new LoginGUI(socket);
dispose();
} else {
// Zamknij okno logowania
dispose();
}
}
private void closeWindow() {
dispose();
}
private boolean doesUsernameExist(String username) {
JSONObject jsonResponse = null; // Zadeklaruj przed try, aby była dostępna poza blokiem
String command = "register";
try {
try {
out = new PrintWriter(socket.getOutputStream(), true);
} catch (SocketException se) {
if (socket.isClosed()) {
socket = new Socket("192.168.0.12", 8080);
out = new PrintWriter(socket.getOutputStream(), true);
}
}
JSONObject jsonRequest = new JSONObject();
jsonRequest.put("command", command);
jsonRequest.put("username", username);
System.out.println("request:" + jsonRequest);
out.println(jsonRequest.toString());
jsonResponse = jsonObjectReader.readJsonObject(username, command, socket);
if (jsonResponse != null) {
// Przetwarzamy odpowiedź (możesz przyjąć, że odpowiedź będzie w formacie JSON)
return jsonResponse.getBoolean("success");
}
} catch (IOException e) {
e.printStackTrace();
}
return false; // Obsługa błędu - zwracamy false
}
}
| t |
9525_1 | klemawa/PlanerWeselny | 1,041 | app/src/main/java/com/example/planerweselny/Ankieta.java | package com.example.planerweselny;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.LinearLayout;
import android.widget.CheckBox;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
public class Ankieta extends AppCompatActivity {
private ArrayList<String> selectedItems;
private Button submitButton;
private CheckBox checkBox1, checkBox2, checkBox3, checkBox4, checkBox5, checkBox6;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ankieta);
selectedItems = new ArrayList<>();
checkBox1 = findViewById(R.id.checkBox);
checkBox2 = findViewById(R.id.checkBox2);
checkBox3 = findViewById(R.id.checkBox3);
checkBox4 = findViewById(R.id.checkBox4);
checkBox5 = findViewById(R.id.checkBox5);
checkBox6 = findViewById(R.id.checkBox6);
submitButton = findViewById(R.id.button25);
submitButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (checkBox1.isChecked()) {
selectedItems.add(checkBox1.getText().toString());
}
if (checkBox2.isChecked()) {
selectedItems.add(checkBox2.getText().toString());
}
if (checkBox3.isChecked()) {
selectedItems.add(checkBox3.getText().toString());
}
if (checkBox4.isChecked()) {
selectedItems.add(checkBox4.getText().toString());
}
if (checkBox5.isChecked()) {
selectedItems.add(checkBox5.getText().toString());
}
if (checkBox6.isChecked()) {
selectedItems.add(checkBox6.getText().toString());
}
saveDataToFile();
Toast.makeText(Ankieta.this, "Dziękuję za wypełnienie ankiety", Toast.LENGTH_SHORT).show();
}
});
}
private void saveDataToFile() {
String fileName = "Ankieta.txt";
File file = new File(getFilesDir(), fileName);
try {
FileOutputStream fos = new FileOutputStream(file);
OutputStreamWriter osw = new OutputStreamWriter(fos);
for (String item : selectedItems) {
osw.write(item + "\n");
}
osw.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void przejscieOdliczaj(View v){ //przejście przyciskiem do okna home
Intent i = new Intent(this,HomeActivity.class);
startActivity(i);
}
public void przejscieSzukaj(View v){ //przejście przyciskiem do okna szukaj
Intent i = new Intent(this,SzukajActivity.class);
startActivity(i);
}
public void przejscieKalendarz(View v){ ////przejście przyciskiem do okna kalendarz
Intent i = new Intent(this,KalendarzActivity.class);
startActivity(i);
}
public void przejsciePlanuj(View v){ //przejście przyciskiem do okna konto
Intent i = new Intent(this,PlanujActivity.class);
startActivity(i);
}
public void przejscieKonto(View v){ //przejście przyciskiem do okna konto
Intent i = new Intent(this,KontoActivity.class);
startActivity(i);
}
} | //przejście przyciskiem do okna szukaj | package com.example.planerweselny;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.LinearLayout;
import android.widget.CheckBox;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
public class Ankieta extends AppCompatActivity {
private ArrayList<String> selectedItems;
private Button submitButton;
private CheckBox checkBox1, checkBox2, checkBox3, checkBox4, checkBox5, checkBox6;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_ankieta);
selectedItems = new ArrayList<>();
checkBox1 = findViewById(R.id.checkBox);
checkBox2 = findViewById(R.id.checkBox2);
checkBox3 = findViewById(R.id.checkBox3);
checkBox4 = findViewById(R.id.checkBox4);
checkBox5 = findViewById(R.id.checkBox5);
checkBox6 = findViewById(R.id.checkBox6);
submitButton = findViewById(R.id.button25);
submitButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (checkBox1.isChecked()) {
selectedItems.add(checkBox1.getText().toString());
}
if (checkBox2.isChecked()) {
selectedItems.add(checkBox2.getText().toString());
}
if (checkBox3.isChecked()) {
selectedItems.add(checkBox3.getText().toString());
}
if (checkBox4.isChecked()) {
selectedItems.add(checkBox4.getText().toString());
}
if (checkBox5.isChecked()) {
selectedItems.add(checkBox5.getText().toString());
}
if (checkBox6.isChecked()) {
selectedItems.add(checkBox6.getText().toString());
}
saveDataToFile();
Toast.makeText(Ankieta.this, "Dziękuję za wypełnienie ankiety", Toast.LENGTH_SHORT).show();
}
});
}
private void saveDataToFile() {
String fileName = "Ankieta.txt";
File file = new File(getFilesDir(), fileName);
try {
FileOutputStream fos = new FileOutputStream(file);
OutputStreamWriter osw = new OutputStreamWriter(fos);
for (String item : selectedItems) {
osw.write(item + "\n");
}
osw.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void przejscieOdliczaj(View v){ //przejście przyciskiem do okna home
Intent i = new Intent(this,HomeActivity.class);
startActivity(i);
}
public void przejscieSzukaj(View v){ //przejście przyciskiem <SUF>
Intent i = new Intent(this,SzukajActivity.class);
startActivity(i);
}
public void przejscieKalendarz(View v){ ////przejście przyciskiem do okna kalendarz
Intent i = new Intent(this,KalendarzActivity.class);
startActivity(i);
}
public void przejsciePlanuj(View v){ //przejście przyciskiem do okna konto
Intent i = new Intent(this,PlanujActivity.class);
startActivity(i);
}
public void przejscieKonto(View v){ //przejście przyciskiem do okna konto
Intent i = new Intent(this,KontoActivity.class);
startActivity(i);
}
} | t |
6219_0 | kmisztal/java_tutorial | 602 | 2017_2018/qaa/src/Point.java | /**
* Zaimplementuj klasę Point będącą obiektową reprezentacją
* punktu na płaszczyźnie.
*
* klasa ma dwa pola x i y typu double
* klasa ma konstruktor bezargumentowy tworzący punkt (0,0)
* klasa ma konstruktor przyjmujący współrzędne x i y
* zaimplementuj własną wersję metody toString(), aby punkt był wypisywany jako np. [10,-1]
* klasa ma metodę oblizającą odległość pomiedzy dwoma punktami
* statyczną metodę liczącą odległość pomiedzy dwoma obiektami klasy Point
*/
public class Point {
private double x, y;
public Point(){}
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
System.out.println("Ktoś czyta");
return x;
}
public void setX(double x) {
System.out.println("Ktoś ustawia");
this.x = x;
}
@Override
public String toString() {
return "[" + this.getX() + "," + y + ']';
}
public static double dist(Point a, Point b){
return Math.sqrt(
Math.pow(b.x - a.x, 2)
+ Math.pow(b.y - a.y, 2)
);
}
public double dist(Point b){
return Math.sqrt(
Math.pow(b.x - this.x, 2)
+ Math.pow(b.y - this.y, 2)
);
}
public static void main(String[] args) {
Point point = new Point();
System.out.println(point.x);
System.out.println(point.y);
Point point1 = new Point(1, 2);
System.out.println(point1.x + " " + point1.y);
System.out.println(point1);
System.out.println(point1.toString());
System.out.println(Point.dist(point, point1));
System.out.println(point.dist(point1));
}
}
| /**
* Zaimplementuj klasę Point będącą obiektową reprezentacją
* punktu na płaszczyźnie.
*
* klasa ma dwa pola x i y typu double
* klasa ma konstruktor bezargumentowy tworzący punkt (0,0)
* klasa ma konstruktor przyjmujący współrzędne x i y
* zaimplementuj własną wersję metody toString(), aby punkt był wypisywany jako np. [10,-1]
* klasa ma metodę oblizającą odległość pomiedzy dwoma punktami
* statyczną metodę liczącą odległość pomiedzy dwoma obiektami klasy Point
*/ | /**
* Zaimplementuj klasę Point <SUF>*/
public class Point {
private double x, y;
public Point(){}
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
System.out.println("Ktoś czyta");
return x;
}
public void setX(double x) {
System.out.println("Ktoś ustawia");
this.x = x;
}
@Override
public String toString() {
return "[" + this.getX() + "," + y + ']';
}
public static double dist(Point a, Point b){
return Math.sqrt(
Math.pow(b.x - a.x, 2)
+ Math.pow(b.y - a.y, 2)
);
}
public double dist(Point b){
return Math.sqrt(
Math.pow(b.x - this.x, 2)
+ Math.pow(b.y - this.y, 2)
);
}
public static void main(String[] args) {
Point point = new Point();
System.out.println(point.x);
System.out.println(point.y);
Point point1 = new Point(1, 2);
System.out.println(point1.x + " " + point1.y);
System.out.println(point1);
System.out.println(point1.toString());
System.out.println(Point.dist(point, point1));
System.out.println(point.dist(point1));
}
}
| t |
216_0 | kobietydokodupl/kurs-javy | 495 | src/main/java/pl/kobietydokodu/koty/domain/Kot.java | package pl.kobietydokodu.koty.domain;
import java.util.Date;
/**
* Klasa reprezentująca kota.
*/
public class Kot {
/**
* Imię kota.
*/
private String imie;
/**
* Data urodzenia kota.
*/
private Date dataUrodzenia;
/**
* Waga kota.
*/
private Float waga;
/**
* Imię opiekuna kota.
*/
private String imieOpiekuna;
/**
* Metoda, która opisuje kota pełnym zdaniem.
* @return Opis kota w postaci zdania.
*/
public String przedstawSie() {
return "Cześć, jestem "+imie+", urodziłem się "+dataUrodzenia+", ważę "+waga+", a opiekuje się mną " + imieOpiekuna;
}
public String getImie() {
return imie;
}
public void setImie(String imie) {
this.imie = imie;
}
public Date getDataUrodzenia() {
return dataUrodzenia;
}
public void setDataUrodzenia(Date dataUrodzenia) {
this.dataUrodzenia = dataUrodzenia;
}
public Float getWaga() {
return waga;
}
public void setWaga(Float waga) {
this.waga = waga;
}
public String getImieOpiekuna() {
return imieOpiekuna;
}
public void setImieOpiekuna(String imieOpiekuna) {
this.imieOpiekuna = imieOpiekuna;
}
}
| /**
* Klasa reprezentująca kota.
*/ | package pl.kobietydokodu.koty.domain;
import java.util.Date;
/**
* Klasa reprezentująca kota.
<SUF>*/
public class Kot {
/**
* Imię kota.
*/
private String imie;
/**
* Data urodzenia kota.
*/
private Date dataUrodzenia;
/**
* Waga kota.
*/
private Float waga;
/**
* Imię opiekuna kota.
*/
private String imieOpiekuna;
/**
* Metoda, która opisuje kota pełnym zdaniem.
* @return Opis kota w postaci zdania.
*/
public String przedstawSie() {
return "Cześć, jestem "+imie+", urodziłem się "+dataUrodzenia+", ważę "+waga+", a opiekuje się mną " + imieOpiekuna;
}
public String getImie() {
return imie;
}
public void setImie(String imie) {
this.imie = imie;
}
public Date getDataUrodzenia() {
return dataUrodzenia;
}
public void setDataUrodzenia(Date dataUrodzenia) {
this.dataUrodzenia = dataUrodzenia;
}
public Float getWaga() {
return waga;
}
public void setWaga(Float waga) {
this.waga = waga;
}
public String getImieOpiekuna() {
return imieOpiekuna;
}
public void setImieOpiekuna(String imieOpiekuna) {
this.imieOpiekuna = imieOpiekuna;
}
}
| t |
10269_6 | koglecki/Connect4 | 2,948 | src/Connect4/Connect4.java | package Connect4;
import sac.game.*;
import java.util.*;
public class Connect4 extends GameStateImpl {
public static int m = 6; //liczba wierszy (min 4) była final
public static int n = 7; //liczba kolumn (min 4) ta też ten 1 niżej też jest final
private static boolean startingPlayer = true; //true - rozpoczyna gracz, false - rozpoczyna AI
public static final char player = 'O', ai = 'X'; //symbole na planszy dla gracza i AI
private boolean colorRed = false;
private static boolean ceilingRule = true;
//----------------------
private char[][] board;
private int playerMove = -1; //nie zmieniać!
public void main() {
//Scanner scanner = new Scanner(System.in);
//Connect4 game = new Connect4();
GameSearchAlgorithm algo = new AlphaBetaPruning(); //AlphaBetaPruning
algo.setInitial(this); //game
GUI sketch = new GUI(this, n, m, startingPlayer, colorRed);
GUI.runSketch(new String[] {"Connect4.GUI"}, sketch);
while(!this.isWinner()) {
if(this.isDraw())
break;
if(this.isMaximizingTurnNow()) { //jeżeli tura gracza
while (true) {
System.out.println("player");
if (this.playerMove != -1) {
this.makeMove(this.playerMove);
this.setPlayerMove(-1);
break;
}
}
}
else {
algo.execute();
Map<String, Double> bestMoves = algo.getMovesScores();
for (Map.Entry<String, Double> entry : bestMoves.entrySet())
System.out.println(entry.getKey() + " -> " + entry.getValue());
String s = algo.getFirstBestMove();
int aiMove = Integer.parseInt(s);
this.makeMove(aiMove);
sketch.setAIMove(aiMove);
}
}
if(this.isDraw())
System.out.println("Draw");
else {
if (this.isMaximizingTurnNow())
System.out.println("Winner: AI");
else
System.out.println("Winner: player");
}
}
Connect4() {
board = new char[m][n];
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = '-';
this.setMaximizingTurnNow(startingPlayer); //gracz jest maksymalizujący, a AI minimalizujące
}
Connect4(int rows, int columns, boolean player, boolean color, boolean ceiling) {
m = rows;
n = columns;
startingPlayer = player;
colorRed = color;
ceilingRule = ceiling;
if(ceilingRule)
Connect4.setHFunction(new HeuristicFunctionCeiling());
else
Connect4.setHFunction(new HeuristicFunction());
board = new char[m][n];
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = '-';
this.setMaximizingTurnNow(startingPlayer);
}
Connect4(Connect4 parent) { //konstruktor kopiujący
board = new char[m][n];
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = parent.board[i][j];
this.setMaximizingTurnNow(parent.isMaximizingTurnNow());
}
public void setPlayerMove(int m) {
this.playerMove = m;
}
public char[][] getBoard() {
return board;
}
public String toString() {
StringBuilder txt = new StringBuilder();
for(int i = 0; i <= 6 * n; i++)
txt.append('-');
txt.append("\n\n\n ");
for(int i = 0; i < n; i++)
txt.append(i + " ");
txt.append("\n");
for(int i = 0; i <= 6 * n; i++)
txt.append('\u2014');
txt.append("\n");
for(int i = 0; i < m; i++) {
txt.append("|");
for (int j = 0; j < n; j++)
txt.append(" " + board[i][j] + " |");
txt.append("\n");
for (int j = 0; j <= 6 * n; j++)
txt.append('\u2014');
txt.append("\n");
}
return txt.toString();
}
public int hashCode() {
char[] boardFlat = new char[m * n];
int k = 0;
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
boardFlat[k++] = board[i][j];
return Arrays.hashCode(boardFlat);
}
boolean makeMove(int column) {
if(column < 0 || column >= n) {
return false;
}
for(int i = m-1; i >= 0; i--) {
if(board[i][column] == '-') {
if(isMaximizingTurnNow())
board[i][column] = player;
else
board[i][column] = ai;
this.setMaximizingTurnNow(!isMaximizingTurnNow());
return true;
}
}
return false;
}
public boolean isWinner() {
if (ceilingRule) {
for (int i = 0; i < n; i++) { //warunek sufitu
if (board[0][i] != '-')
return true;
}
}
for(int i = 0; i < m; i++) { //wiersze
for(int j = 0; j < n - 3; j++) {
if(board[i][j] == player && board[i][j + 1] == player && board[i][j + 2] == player && board[i][j + 3] == player)
return true;
if(board[i][j] == ai && board[i][j + 1] == ai && board[i][j + 2] == ai && board[i][j + 3] == ai)
return true;
}
}
for(int i = 0; i < m - 3; i++) { //kolumny
for(int j = 0; j < n; j++) {
if(board[i][j] == player && board[i + 1][j] == player && board[i + 2][j] == player && board[i + 3][j] == player)
return true;
if(board[i][j] == ai && board[i + 1][j] == ai && board[i + 2][j] == ai && board[i + 3][j] == ai)
return true;
}
}
for(int i = 0; i < m - 3; i++) { //ukosy góra-dół
for (int j = 0; j < n - 3; j++) {
if(board[i][j] == player && board[i + 1][j + 1] == player && board[i + 2][j + 2] == player && board[i + 3][j + 3] == player)
return true;
if(board[i][j] == ai && board[i + 1][j + 1] == ai && board[i + 2][j + 2] == ai && board[i + 3][j + 3] == ai)
return true;
}
}
for(int i = 0; i < m - 3; i++) { //ukosy dół-góra
for(int j = 3; j < n; j++) {
if(board[i][j] == player && board[i + 1][j - 1] == player && board[i + 2][j - 2] == player && board[i + 3][j - 3] == player)
return true;
if(board[i][j] == ai && board[i + 1][j - 1] == ai && board[i + 2][j - 2] == ai && board[i + 3][j - 3] == ai)
return true;
}
}
return false;
}
public boolean isDraw() {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] == '-')
return false;
}
}
return !isWinner();
}
@Override
public List<GameState> generateChildren() {
List<GameState> children = new ArrayList();
for(int i = 0; i < n; i++) {
Connect4 child = new Connect4(this);
if(child.makeMove(i)) {
child.setMoveName(Integer.toString(i));
children.add(child);
}
}
return children;
}
}
// public static void main(String args[]) {
// Scanner scanner = new Scanner(System.in);
// Connect4 game = new Connect4();
// Connect4.setHFunction(new HeuristicFunction());
// GameSearchAlgorithm algo = new MinMax(); //AlphaBetaPruning
// algo.setInitial(game);
// System.out.println(game);
//
// while(!game.isWinner()) {
// if(game.isMaximizingTurnNow()) { //jeżeli tura gracza
// System.out.print("Enter a column number (0 - " + (n - 1) + "): ");
// while (true) {
// int playerMove = scanner.nextInt();
// if (!game.makeMove(playerMove)) {
// System.out.print("Wrong number! Try again: ");
// continue;
// }
// break;
// }
// System.out.println(game);
// }
// else {
// algo.execute();
// Map<String, Double> bestMoves = algo.getMovesScores();
// for (Map.Entry<String, Double> entry : bestMoves.entrySet())
// System.out.println(entry.getKey() + " -> " + entry.getValue());
// String s = algo.getFirstBestMove();
// int aiMove = Integer.parseInt(s);
// game.makeMove(aiMove);
// System.out.println(game);
// }
// }
// System.out.print("Winner: ");
// if(game.isMaximizingTurnNow())
// System.out.println("AI");
// else
// System.out.println("player");
// } | //jeżeli tura gracza | package Connect4;
import sac.game.*;
import java.util.*;
public class Connect4 extends GameStateImpl {
public static int m = 6; //liczba wierszy (min 4) była final
public static int n = 7; //liczba kolumn (min 4) ta też ten 1 niżej też jest final
private static boolean startingPlayer = true; //true - rozpoczyna gracz, false - rozpoczyna AI
public static final char player = 'O', ai = 'X'; //symbole na planszy dla gracza i AI
private boolean colorRed = false;
private static boolean ceilingRule = true;
//----------------------
private char[][] board;
private int playerMove = -1; //nie zmieniać!
public void main() {
//Scanner scanner = new Scanner(System.in);
//Connect4 game = new Connect4();
GameSearchAlgorithm algo = new AlphaBetaPruning(); //AlphaBetaPruning
algo.setInitial(this); //game
GUI sketch = new GUI(this, n, m, startingPlayer, colorRed);
GUI.runSketch(new String[] {"Connect4.GUI"}, sketch);
while(!this.isWinner()) {
if(this.isDraw())
break;
if(this.isMaximizingTurnNow()) { //jeżeli tura <SUF>
while (true) {
System.out.println("player");
if (this.playerMove != -1) {
this.makeMove(this.playerMove);
this.setPlayerMove(-1);
break;
}
}
}
else {
algo.execute();
Map<String, Double> bestMoves = algo.getMovesScores();
for (Map.Entry<String, Double> entry : bestMoves.entrySet())
System.out.println(entry.getKey() + " -> " + entry.getValue());
String s = algo.getFirstBestMove();
int aiMove = Integer.parseInt(s);
this.makeMove(aiMove);
sketch.setAIMove(aiMove);
}
}
if(this.isDraw())
System.out.println("Draw");
else {
if (this.isMaximizingTurnNow())
System.out.println("Winner: AI");
else
System.out.println("Winner: player");
}
}
Connect4() {
board = new char[m][n];
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = '-';
this.setMaximizingTurnNow(startingPlayer); //gracz jest maksymalizujący, a AI minimalizujące
}
Connect4(int rows, int columns, boolean player, boolean color, boolean ceiling) {
m = rows;
n = columns;
startingPlayer = player;
colorRed = color;
ceilingRule = ceiling;
if(ceilingRule)
Connect4.setHFunction(new HeuristicFunctionCeiling());
else
Connect4.setHFunction(new HeuristicFunction());
board = new char[m][n];
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = '-';
this.setMaximizingTurnNow(startingPlayer);
}
Connect4(Connect4 parent) { //konstruktor kopiujący
board = new char[m][n];
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
board[i][j] = parent.board[i][j];
this.setMaximizingTurnNow(parent.isMaximizingTurnNow());
}
public void setPlayerMove(int m) {
this.playerMove = m;
}
public char[][] getBoard() {
return board;
}
public String toString() {
StringBuilder txt = new StringBuilder();
for(int i = 0; i <= 6 * n; i++)
txt.append('-');
txt.append("\n\n\n ");
for(int i = 0; i < n; i++)
txt.append(i + " ");
txt.append("\n");
for(int i = 0; i <= 6 * n; i++)
txt.append('\u2014');
txt.append("\n");
for(int i = 0; i < m; i++) {
txt.append("|");
for (int j = 0; j < n; j++)
txt.append(" " + board[i][j] + " |");
txt.append("\n");
for (int j = 0; j <= 6 * n; j++)
txt.append('\u2014');
txt.append("\n");
}
return txt.toString();
}
public int hashCode() {
char[] boardFlat = new char[m * n];
int k = 0;
for(int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
boardFlat[k++] = board[i][j];
return Arrays.hashCode(boardFlat);
}
boolean makeMove(int column) {
if(column < 0 || column >= n) {
return false;
}
for(int i = m-1; i >= 0; i--) {
if(board[i][column] == '-') {
if(isMaximizingTurnNow())
board[i][column] = player;
else
board[i][column] = ai;
this.setMaximizingTurnNow(!isMaximizingTurnNow());
return true;
}
}
return false;
}
public boolean isWinner() {
if (ceilingRule) {
for (int i = 0; i < n; i++) { //warunek sufitu
if (board[0][i] != '-')
return true;
}
}
for(int i = 0; i < m; i++) { //wiersze
for(int j = 0; j < n - 3; j++) {
if(board[i][j] == player && board[i][j + 1] == player && board[i][j + 2] == player && board[i][j + 3] == player)
return true;
if(board[i][j] == ai && board[i][j + 1] == ai && board[i][j + 2] == ai && board[i][j + 3] == ai)
return true;
}
}
for(int i = 0; i < m - 3; i++) { //kolumny
for(int j = 0; j < n; j++) {
if(board[i][j] == player && board[i + 1][j] == player && board[i + 2][j] == player && board[i + 3][j] == player)
return true;
if(board[i][j] == ai && board[i + 1][j] == ai && board[i + 2][j] == ai && board[i + 3][j] == ai)
return true;
}
}
for(int i = 0; i < m - 3; i++) { //ukosy góra-dół
for (int j = 0; j < n - 3; j++) {
if(board[i][j] == player && board[i + 1][j + 1] == player && board[i + 2][j + 2] == player && board[i + 3][j + 3] == player)
return true;
if(board[i][j] == ai && board[i + 1][j + 1] == ai && board[i + 2][j + 2] == ai && board[i + 3][j + 3] == ai)
return true;
}
}
for(int i = 0; i < m - 3; i++) { //ukosy dół-góra
for(int j = 3; j < n; j++) {
if(board[i][j] == player && board[i + 1][j - 1] == player && board[i + 2][j - 2] == player && board[i + 3][j - 3] == player)
return true;
if(board[i][j] == ai && board[i + 1][j - 1] == ai && board[i + 2][j - 2] == ai && board[i + 3][j - 3] == ai)
return true;
}
}
return false;
}
public boolean isDraw() {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] == '-')
return false;
}
}
return !isWinner();
}
@Override
public List<GameState> generateChildren() {
List<GameState> children = new ArrayList();
for(int i = 0; i < n; i++) {
Connect4 child = new Connect4(this);
if(child.makeMove(i)) {
child.setMoveName(Integer.toString(i));
children.add(child);
}
}
return children;
}
}
// public static void main(String args[]) {
// Scanner scanner = new Scanner(System.in);
// Connect4 game = new Connect4();
// Connect4.setHFunction(new HeuristicFunction());
// GameSearchAlgorithm algo = new MinMax(); //AlphaBetaPruning
// algo.setInitial(game);
// System.out.println(game);
//
// while(!game.isWinner()) {
// if(game.isMaximizingTurnNow()) { //jeżeli tura gracza
// System.out.print("Enter a column number (0 - " + (n - 1) + "): ");
// while (true) {
// int playerMove = scanner.nextInt();
// if (!game.makeMove(playerMove)) {
// System.out.print("Wrong number! Try again: ");
// continue;
// }
// break;
// }
// System.out.println(game);
// }
// else {
// algo.execute();
// Map<String, Double> bestMoves = algo.getMovesScores();
// for (Map.Entry<String, Double> entry : bestMoves.entrySet())
// System.out.println(entry.getKey() + " -> " + entry.getValue());
// String s = algo.getFirstBestMove();
// int aiMove = Integer.parseInt(s);
// game.makeMove(aiMove);
// System.out.println(game);
// }
// }
// System.out.print("Winner: ");
// if(game.isMaximizingTurnNow())
// System.out.println("AI");
// else
// System.out.println("player");
// } | t |
4988_6 | kongra/SAN | 387 | 2022 zimowy/Podstawy programowania - 1 sem./2022-10-16/Program.java | public class Program {
// Jeżeli cena pewnego produktu A maleje, to
// rośnie popyt na produkt B, który jest
// komplementarny względem A.
// Jeżeli cena Javy maleje do 0, to rośnie popyt
// na produkty komplementarny względem Javy:
// * Serwery Sun Microsystems
// * System operacyjny Solaris
// * Serwery aplikacyjne
// * Szkolenia z Javy
public static void main(String[] args) {
double x = 2.0;
double y = Math.sqrt(x);
System.out.println("Wartość pierwiastka kwadratowego z 2 wynosi " + y);
// Function<Double, Double> f = x -> x + 3;
// Function<Double, Double> g = y -> y + 3;
}
// Obiekt: BYT posiadający tożsamość
// TYP danych:
// Ω = 0.10111001101001010...
// Pytanie 1: Czy jutro będzie koniec świata?
// Pytanie 2:
// Pytanie 3:
// ...
// Procedura:
// Rachunek λ.
// f = λ x. x + 3
// g = λ y. y + 3
}
| // * System operacyjny Solaris | public class Program {
// Jeżeli cena pewnego produktu A maleje, to
// rośnie popyt na produkt B, który jest
// komplementarny względem A.
// Jeżeli cena Javy maleje do 0, to rośnie popyt
// na produkty komplementarny względem Javy:
// * Serwery Sun Microsystems
// * System operacyjny <SUF>
// * Serwery aplikacyjne
// * Szkolenia z Javy
public static void main(String[] args) {
double x = 2.0;
double y = Math.sqrt(x);
System.out.println("Wartość pierwiastka kwadratowego z 2 wynosi " + y);
// Function<Double, Double> f = x -> x + 3;
// Function<Double, Double> g = y -> y + 3;
}
// Obiekt: BYT posiadający tożsamość
// TYP danych:
// Ω = 0.10111001101001010...
// Pytanie 1: Czy jutro będzie koniec świata?
// Pytanie 2:
// Pytanie 3:
// ...
// Procedura:
// Rachunek λ.
// f = λ x. x + 3
// g = λ y. y + 3
}
| t |
10025_2 | konrad-komisarczyk/dziki_zachod | 799 | src/dzikizachod/Strategia.java | package dzikizachod;
import dzikizachod.Kolko;
import dzikizachod.gracz.PulaGracza;
import dzikizachod.WidokGracza;
import dzikizachod.Wydarzenie;
import dzikizachod.wydarzenie.*;
public abstract class Strategia {
private int nr;
public int getNr() {
return nr;
}
public void setNr(int nr) {
this.nr = nr;
}
/**
* Pokazanie wydarzenia graczowi
* @param wydarzenie właśnie wydarzające sie wydarzenie
*/
protected abstract void zobaczWydarzenie(Wydarzenie wydarzenie);
/**
*
* @param widok aktualny stan kółka graczy
* @param karty dostępne karty
* @return wydarzenie, które gracz chce wykonać
*/
protected Wydarzenie ruch(Kolko<WidokGracza> widok, PulaGracza karty) {
if (karty.contains(Akcja.ULECZ)) {
int cel = ulecz(widok, karty);
if (cel != -1) {
return new WydarzenieUlecz(nr, cel);
}
}
if (karty.contains(Akcja.ZASIEG_PLUS_DWA)) {
return new WydarzenieZasiegPlusDwa(nr);
}
if (karty.contains(Akcja.ZASIEG_PLUS_JEDEN)) {
return new WydarzenieZasiegPlusJeden(nr);
}
if (karty.contains(Akcja.STRZEL)) {
int cel = strzel(widok, karty);
if (cel != -1) {
return new WydarzenieStrzel(nr, cel);
}
}
if (karty.contains(Akcja.DYNAMIT)) {
if (dynamit(widok, karty)) {
return new WydarzenieDynamit(widok.nastepnyZywy(nr));
}
}
return null;
}
/**
* @return czy położyć dynamit
*/
protected abstract Boolean dynamit(Kolko<WidokGracza> widok, PulaGracza karty);
/**
* @return nr osoby do uleczenia / -1, gdy gracz nie chce leczyć
*/
protected int ulecz(Kolko<WidokGracza> widok, PulaGracza karty) {
return nr;
}
/**
* @return nr osoby do tórej strzelić / -1, gdy gracz ei chce strzelać
*/
protected abstract int strzel(Kolko<WidokGracza> widok, PulaGracza karty);
}
| /**
* @return czy położyć dynamit
*/ | package dzikizachod;
import dzikizachod.Kolko;
import dzikizachod.gracz.PulaGracza;
import dzikizachod.WidokGracza;
import dzikizachod.Wydarzenie;
import dzikizachod.wydarzenie.*;
public abstract class Strategia {
private int nr;
public int getNr() {
return nr;
}
public void setNr(int nr) {
this.nr = nr;
}
/**
* Pokazanie wydarzenia graczowi
* @param wydarzenie właśnie wydarzające sie wydarzenie
*/
protected abstract void zobaczWydarzenie(Wydarzenie wydarzenie);
/**
*
* @param widok aktualny stan kółka graczy
* @param karty dostępne karty
* @return wydarzenie, które gracz chce wykonać
*/
protected Wydarzenie ruch(Kolko<WidokGracza> widok, PulaGracza karty) {
if (karty.contains(Akcja.ULECZ)) {
int cel = ulecz(widok, karty);
if (cel != -1) {
return new WydarzenieUlecz(nr, cel);
}
}
if (karty.contains(Akcja.ZASIEG_PLUS_DWA)) {
return new WydarzenieZasiegPlusDwa(nr);
}
if (karty.contains(Akcja.ZASIEG_PLUS_JEDEN)) {
return new WydarzenieZasiegPlusJeden(nr);
}
if (karty.contains(Akcja.STRZEL)) {
int cel = strzel(widok, karty);
if (cel != -1) {
return new WydarzenieStrzel(nr, cel);
}
}
if (karty.contains(Akcja.DYNAMIT)) {
if (dynamit(widok, karty)) {
return new WydarzenieDynamit(widok.nastepnyZywy(nr));
}
}
return null;
}
/**
* @return czy położyć <SUF>*/
protected abstract Boolean dynamit(Kolko<WidokGracza> widok, PulaGracza karty);
/**
* @return nr osoby do uleczenia / -1, gdy gracz nie chce leczyć
*/
protected int ulecz(Kolko<WidokGracza> widok, PulaGracza karty) {
return nr;
}
/**
* @return nr osoby do tórej strzelić / -1, gdy gracz ei chce strzelać
*/
protected abstract int strzel(Kolko<WidokGracza> widok, PulaGracza karty);
}
| t |
5277_2 | konradziel/CC_Object_Oriented_Programming | 157 | lab6/src/TestBase.java | import pl.edu.uwm.zad7.Base;
import pl.edu.uwm.zad7.Child;
public class TestBase {
public static void main(String[] args) {
Base base = new Base();
Child child = new Child();
base.info();
child.info();
}
}
//Metody statyczne są związane z klasą, a nie instancją obiektu.
//Definiując metodę o tej samej nazwie w klasie potomnej nie przesyłamy metody,
//a przesłaniamy metodę z klasy bazowej.
| //a przesłaniamy metodę z klasy bazowej. | import pl.edu.uwm.zad7.Base;
import pl.edu.uwm.zad7.Child;
public class TestBase {
public static void main(String[] args) {
Base base = new Base();
Child child = new Child();
base.info();
child.info();
}
}
//Metody statyczne są związane z klasą, a nie instancją obiektu.
//Definiując metodę o tej samej nazwie w klasie potomnej nie przesyłamy metody,
//a przesłaniamy <SUF>
| t |
6860_0 | kornelorawczak/Advanced-Java-Course | 1,997 | gui_examples_Z8/src/main/java/quiz.java | import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
public class quiz {
int wrongcounter=0;
int pointcounter=0;
public void initGui(){
Display display = Display.getDefault();
final Shell shell = new Shell(display);
createContents(shell);
shell.open ();
shell.setSize(450,600);
shell.layout();
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ()) display.sleep ();
}
display.dispose ();
}
public void createContents(Composite shell) {
String pytania[] = {"Stolicą Polski jest: ", "Rzeka, która przepływa przez Wrocław to: ", "Stolicą Niemiec jest: ", "Stolicą Francji jest: ", "Stolicą województwa zachodnio-pomorskiego jest: ", "Stolicami województwa Lubuskiego są: ", "Człowiek pochodzi od: ", "Producentem sprzętu elektronicznego nie jest: ", "Stolicą USA jest: ", "Producentem konsol do gier nie jest: "};
String odpowiedzi[][] = {{"Gniezno", "Kraków", "Warszawa", "Wrocław"}, {"Warta", "Wisła", "Dunaj", "Odra"}, {"Berlin", "Monachium", "Drezno", "Hamburg"}, {"Paryż", "Luwr", "Neapol", "Monako"}, {"Gdańsk", "Szczecin", "Wrocław,", "Gorzów Wielkpolski"}, {"Gorzów Wielkopolski", "Tarnów", "Jasna Góra", "Zielona Góra"}, {"Dinozaurów", "Płazów", "Małpy", "Gadów"}, {"Razer", "Steelseries", "Sony", "Pepco"}, {"Detroit", "Waszyngton", "Nowy Orlean", "Nowy Jork"}, {"Sony", "Nintendo", "Microsoft", "Steelseries"}};
String poprawneodpowiedzi[] = {"Warszawa", "Odra", "Berlin", "Paryż", "Szczecin", "Gorzów Wielkopolski", "Małpy", "Pepco", "Waszyngton", "Steelseries"};
GridLayout gl = new GridLayout(1, true);
gl.horizontalSpacing = 20;
gl.verticalSpacing = 5;
gl.marginLeft = 0;
gl.marginRight = 0;
shell.setLayout(new FillLayout());
Label wszystkieindeksypytan[] = new Label[10];
Label wszystkiepytania[] = new Label[10];
Button wszystkieodpowiedzi[][] = new Button[10][4];
GridData idpyt = new GridData();
idpyt.widthHint=60;
GridData pyt = new GridData();
pyt.widthHint=400;
pyt.heightHint=20;
GridData odp = new GridData();
odp.widthHint=120;
GridData chk = new GridData();
chk.widthHint=500;
chk.heightHint=50;
ScrolledComposite sc = new ScrolledComposite(shell,SWT.H_SCROLL+SWT.V_SCROLL);
GridData grp = new GridData();
grp.heightHint=50;
grp.verticalAlignment=SWT.CENTER;
Composite child = new Composite(sc,SWT.NONE);
child.setLayout(gl);
for (int i = 0; i < 10; i++) {
wszystkieindeksypytan[i] = new Label(child, SWT.NONE);
wszystkieindeksypytan[i].setText("Pytanie " + (i+1) + ":");
wszystkieindeksypytan[i].setLayoutData(idpyt);
wszystkiepytania[i] = new Label(child, SWT.NONE);
wszystkiepytania[i].setText(pytania[i]);
wszystkiepytania[i].setLayoutData(pyt);
wszystkiepytania[i].setFont(new Font(Display.getDefault(),"Times New Roman",12,6));
Group gpyt = new Group(child,SWT.NONE);
gpyt.setLayout(new GridLayout(2,true));
gpyt.setLayoutData(grp);
for (int j = 0; j < 4; j++) {
wszystkieodpowiedzi[i][j] = new Button(gpyt, SWT.RADIO);
wszystkieodpowiedzi[i][j].setText(odpowiedzi[i][j]);
wszystkieodpowiedzi[i][j].setLayoutData(odp);
}
}
Button check = new Button(child, SWT.BORDER + SWT.FLAT);
check.setFocus();
Label punkty= new Label(child,SWT.BORDER);
punkty.setLayoutData(chk);
check.setText("Sprawdź quiz: ");
int wrong[]=new int[10];
String wroong="";
for (int i=0;i<=wrongcounter;i++){
wroong+=(wrong[wrongcounter]+", ");
}
String finalWroong = wroong;
check.addSelectionListener(new SelectionListener() {
@Override
public void widgetSelected(SelectionEvent selectionEvent) {
for (int i=0; i<10;i++){
for(int j=0;j<4;j++){
if(wszystkieodpowiedzi[i][j].getSelection()){
if(odpowiedzi[i][j]==poprawneodpowiedzi[i]){
pointcounter +=1;
}
else{
wrong[wrongcounter]=i+1;
wrongcounter +=1;
}
}
}
}
if((wrongcounter >0)&(wrongcounter <10)){
punkty.setText("Zdobyłeś "+ pointcounter+" punktów. Błędy w zadaniach: "+ finalWroong);
}
else if(wrongcounter==0){
punkty.setText(+pointcounter+"Gratulacje! Wszystkie odpowiedzi były poprawne!");
}
else if(wrongcounter==10){
punkty.setText("Wstyd! Wszystko źle!");
}
}
@Override
public void widgetDefaultSelected(SelectionEvent selectionEvent) {
}
});
sc.setContent(child);
sc.setMinSize(300,1600);
sc.setExpandHorizontal(true);
sc.setExpandVertical(true);
}
//odstęp między grupą a pytaniem i dlaczego nie liczy poprawnie oraz linie 97-99
public static void main(String[] args){
quiz q=new quiz();
q.initGui();
}
}
| //odstęp między grupą a pytaniem i dlaczego nie liczy poprawnie oraz linie 97-99 | import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
public class quiz {
int wrongcounter=0;
int pointcounter=0;
public void initGui(){
Display display = Display.getDefault();
final Shell shell = new Shell(display);
createContents(shell);
shell.open ();
shell.setSize(450,600);
shell.layout();
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ()) display.sleep ();
}
display.dispose ();
}
public void createContents(Composite shell) {
String pytania[] = {"Stolicą Polski jest: ", "Rzeka, która przepływa przez Wrocław to: ", "Stolicą Niemiec jest: ", "Stolicą Francji jest: ", "Stolicą województwa zachodnio-pomorskiego jest: ", "Stolicami województwa Lubuskiego są: ", "Człowiek pochodzi od: ", "Producentem sprzętu elektronicznego nie jest: ", "Stolicą USA jest: ", "Producentem konsol do gier nie jest: "};
String odpowiedzi[][] = {{"Gniezno", "Kraków", "Warszawa", "Wrocław"}, {"Warta", "Wisła", "Dunaj", "Odra"}, {"Berlin", "Monachium", "Drezno", "Hamburg"}, {"Paryż", "Luwr", "Neapol", "Monako"}, {"Gdańsk", "Szczecin", "Wrocław,", "Gorzów Wielkpolski"}, {"Gorzów Wielkopolski", "Tarnów", "Jasna Góra", "Zielona Góra"}, {"Dinozaurów", "Płazów", "Małpy", "Gadów"}, {"Razer", "Steelseries", "Sony", "Pepco"}, {"Detroit", "Waszyngton", "Nowy Orlean", "Nowy Jork"}, {"Sony", "Nintendo", "Microsoft", "Steelseries"}};
String poprawneodpowiedzi[] = {"Warszawa", "Odra", "Berlin", "Paryż", "Szczecin", "Gorzów Wielkopolski", "Małpy", "Pepco", "Waszyngton", "Steelseries"};
GridLayout gl = new GridLayout(1, true);
gl.horizontalSpacing = 20;
gl.verticalSpacing = 5;
gl.marginLeft = 0;
gl.marginRight = 0;
shell.setLayout(new FillLayout());
Label wszystkieindeksypytan[] = new Label[10];
Label wszystkiepytania[] = new Label[10];
Button wszystkieodpowiedzi[][] = new Button[10][4];
GridData idpyt = new GridData();
idpyt.widthHint=60;
GridData pyt = new GridData();
pyt.widthHint=400;
pyt.heightHint=20;
GridData odp = new GridData();
odp.widthHint=120;
GridData chk = new GridData();
chk.widthHint=500;
chk.heightHint=50;
ScrolledComposite sc = new ScrolledComposite(shell,SWT.H_SCROLL+SWT.V_SCROLL);
GridData grp = new GridData();
grp.heightHint=50;
grp.verticalAlignment=SWT.CENTER;
Composite child = new Composite(sc,SWT.NONE);
child.setLayout(gl);
for (int i = 0; i < 10; i++) {
wszystkieindeksypytan[i] = new Label(child, SWT.NONE);
wszystkieindeksypytan[i].setText("Pytanie " + (i+1) + ":");
wszystkieindeksypytan[i].setLayoutData(idpyt);
wszystkiepytania[i] = new Label(child, SWT.NONE);
wszystkiepytania[i].setText(pytania[i]);
wszystkiepytania[i].setLayoutData(pyt);
wszystkiepytania[i].setFont(new Font(Display.getDefault(),"Times New Roman",12,6));
Group gpyt = new Group(child,SWT.NONE);
gpyt.setLayout(new GridLayout(2,true));
gpyt.setLayoutData(grp);
for (int j = 0; j < 4; j++) {
wszystkieodpowiedzi[i][j] = new Button(gpyt, SWT.RADIO);
wszystkieodpowiedzi[i][j].setText(odpowiedzi[i][j]);
wszystkieodpowiedzi[i][j].setLayoutData(odp);
}
}
Button check = new Button(child, SWT.BORDER + SWT.FLAT);
check.setFocus();
Label punkty= new Label(child,SWT.BORDER);
punkty.setLayoutData(chk);
check.setText("Sprawdź quiz: ");
int wrong[]=new int[10];
String wroong="";
for (int i=0;i<=wrongcounter;i++){
wroong+=(wrong[wrongcounter]+", ");
}
String finalWroong = wroong;
check.addSelectionListener(new SelectionListener() {
@Override
public void widgetSelected(SelectionEvent selectionEvent) {
for (int i=0; i<10;i++){
for(int j=0;j<4;j++){
if(wszystkieodpowiedzi[i][j].getSelection()){
if(odpowiedzi[i][j]==poprawneodpowiedzi[i]){
pointcounter +=1;
}
else{
wrong[wrongcounter]=i+1;
wrongcounter +=1;
}
}
}
}
if((wrongcounter >0)&(wrongcounter <10)){
punkty.setText("Zdobyłeś "+ pointcounter+" punktów. Błędy w zadaniach: "+ finalWroong);
}
else if(wrongcounter==0){
punkty.setText(+pointcounter+"Gratulacje! Wszystkie odpowiedzi były poprawne!");
}
else if(wrongcounter==10){
punkty.setText("Wstyd! Wszystko źle!");
}
}
@Override
public void widgetDefaultSelected(SelectionEvent selectionEvent) {
}
});
sc.setContent(child);
sc.setMinSize(300,1600);
sc.setExpandHorizontal(true);
sc.setExpandVertical(true);
}
//odstęp między <SUF>
public static void main(String[] args){
quiz q=new quiz();
q.initGui();
}
}
| t |
5139_9 | kowalskihubert/Java-OOP-course | 997 | Advanced/lambdaFunRef/lambdaDemo.java | package lambdaFunRef;
import anonimWewLok.pszczoly.Robotnica;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.IntConsumer;
import java.util.function.Supplier;
public class lambdaDemo {
public static void main(String[] args) {
// Przydatne interfejsy funkcyjne
// Runnable - void run()
int a = 6; // zmienna lokalna, efektywnie finalna, dlatego możemy z niej skorzystać
Runnable task = () -> {
System.out.println("Nie przyjmuję argumentów, więc mogę tylko napisać coś ogólnego");
System.out.println("Wypisuję z zewnątrz: a = " + a);
};
task.run();
// Consumer - void accept(T t)
System.out.println("");
Consumer<String> consumer = (String s) -> {
s = s.toUpperCase();
System.out.println(s);
};
consumer.accept("hubert");
// Supplier - T get()
System.out.println("");
Supplier<Robotnica> supplier = () -> {
int wiek = new Random().nextInt(1, 15);
Robotnica robotnica = new Robotnica("Hermenegilda", wiek);
return robotnica;
};
Robotnica robotnica = supplier.get();
robotnica.zbierajNektar(20);
// Własny interfejs funkcyjny - MyFunction - double apply(int a, int b)
System.out.println("");
MyFunction myFunction = (x, y) -> {
return Math.cos(x) + Math.sin(y);
};
double w = myFunction.apply(0, 3);
System.out.println("Wynik działania myFunction dla a=0, b=3: " + w);
w = myFunction.apply(2, 10);
System.out.println("Wynik działania myFunction dla a=2, b=10: " + w);
// Działanie na lambdach w pętli
System.out.println("\nArgument przekazany do lambdy");
Consumer<Integer> intConsumer = (Integer x) -> {
System.out.println("Wypisuję z pętli: " + x);
}; // Tu nie korzystamy ze zmiennych zewnętrznych, a przekazujemy je jako argumenty
// Dzięki temu zmienna i może się zmieniać w pętli for
for (int i = 1; i < 6; i++) {
intConsumer.accept(i);
}
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.forEach(i -> System.out.println("Wypisuję z forEach: " + i));
// Działanie na lambdach w pętli - zmienna lokalna
System.out.println("\nZmienna lokalna z zewnątrz");
Runnable r;
for(int i = 1; i < 6; i++) {
r = () -> {
// System.out.println("Wypisuję z pętli: " + i);
// Nie działa, bo zmienna i się zmienia
};
r.run();
}
for(int i : list) {
r = () -> {
System.out.println("Wypisuję z forEach: " + i);
};
r.run();
}
}
}
| // Działanie na lambdach w pętli - zmienna lokalna | package lambdaFunRef;
import anonimWewLok.pszczoly.Robotnica;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.IntConsumer;
import java.util.function.Supplier;
public class lambdaDemo {
public static void main(String[] args) {
// Przydatne interfejsy funkcyjne
// Runnable - void run()
int a = 6; // zmienna lokalna, efektywnie finalna, dlatego możemy z niej skorzystać
Runnable task = () -> {
System.out.println("Nie przyjmuję argumentów, więc mogę tylko napisać coś ogólnego");
System.out.println("Wypisuję z zewnątrz: a = " + a);
};
task.run();
// Consumer - void accept(T t)
System.out.println("");
Consumer<String> consumer = (String s) -> {
s = s.toUpperCase();
System.out.println(s);
};
consumer.accept("hubert");
// Supplier - T get()
System.out.println("");
Supplier<Robotnica> supplier = () -> {
int wiek = new Random().nextInt(1, 15);
Robotnica robotnica = new Robotnica("Hermenegilda", wiek);
return robotnica;
};
Robotnica robotnica = supplier.get();
robotnica.zbierajNektar(20);
// Własny interfejs funkcyjny - MyFunction - double apply(int a, int b)
System.out.println("");
MyFunction myFunction = (x, y) -> {
return Math.cos(x) + Math.sin(y);
};
double w = myFunction.apply(0, 3);
System.out.println("Wynik działania myFunction dla a=0, b=3: " + w);
w = myFunction.apply(2, 10);
System.out.println("Wynik działania myFunction dla a=2, b=10: " + w);
// Działanie na lambdach w pętli
System.out.println("\nArgument przekazany do lambdy");
Consumer<Integer> intConsumer = (Integer x) -> {
System.out.println("Wypisuję z pętli: " + x);
}; // Tu nie korzystamy ze zmiennych zewnętrznych, a przekazujemy je jako argumenty
// Dzięki temu zmienna i może się zmieniać w pętli for
for (int i = 1; i < 6; i++) {
intConsumer.accept(i);
}
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.forEach(i -> System.out.println("Wypisuję z forEach: " + i));
// Działanie na <SUF>
System.out.println("\nZmienna lokalna z zewnątrz");
Runnable r;
for(int i = 1; i < 6; i++) {
r = () -> {
// System.out.println("Wypisuję z pętli: " + i);
// Nie działa, bo zmienna i się zmienia
};
r.run();
}
for(int i : list) {
r = () -> {
System.out.println("Wypisuję z forEach: " + i);
};
r.run();
}
}
}
| t |
8321_0 | kpagacz/software-engineering | 710 | programowanie-obiektowe/lab-12/src/lab12/Plansza.java | package lab12;
public class Plansza {
// class fields
private int wys;
private int szer;
private Obiekt[][] plansza; // variable object - nie jest tak naprawdę instancją Obiekt = referencja do obiektu
public Plansza(int wys, int szer) {
this.wys = wys;
this.szer = szer;
plansza = new Obiekt[wys][szer];
}
final public void drukuj() {
for(int i = 0; i < wys; i++) {
for (int j = 0; j < szer; j++) {
if (plansza[i][j] != null)
plansza[i][j].drukuj();
else
System.out.print('.');
}
System.out.println();
}
System.out.println();
}
public void dodaj(int wiersz, int kolumna, char c) {
if(wiersz < 0 || kolumna < 0 || wiersz >= this.szer || kolumna >= this.wys)
return;
switch (c) {
case 'A' -> plansza[wiersz][kolumna] = new A();
case 'B' -> plansza[wiersz][kolumna] = new B();
case 'C' -> plansza[wiersz][kolumna] = new C();
case 'D' -> plansza[wiersz][kolumna] = new D();
}
}
public void zamien(int w1, int k1, int w2, int k2) {
if(w1 >= this.wys || w1 < 0 || k1 >= this.szer || k1 < 0
|| w2 >= this.wys || w2 < 0 || k2 >= this.szer || k2 < 0)
return;
Obiekt temp = plansza[w1][k1];
plansza[w1][k1] = plansza[w2][k2];
plansza[w2][k2] = temp;
}
public void przesun(int w, int k, int dodaj_w, int dodaj_k) {
if(waliduj_wsp(w, k) && waliduj_wsp(w + dodaj_w, k + dodaj_k)) {
plansza[w + dodaj_w][k + dodaj_k] = plansza[w][k];
plansza[w][k] = null;
}
}
private boolean waliduj_wsp(int w, int k) {
return ((w >= 0) && (w < this.wys) && (k >= 0) && (k < this.szer));
}
}
| // variable object - nie jest tak naprawdę instancją Obiekt = referencja do obiektu | package lab12;
public class Plansza {
// class fields
private int wys;
private int szer;
private Obiekt[][] plansza; // variable object <SUF>
public Plansza(int wys, int szer) {
this.wys = wys;
this.szer = szer;
plansza = new Obiekt[wys][szer];
}
final public void drukuj() {
for(int i = 0; i < wys; i++) {
for (int j = 0; j < szer; j++) {
if (plansza[i][j] != null)
plansza[i][j].drukuj();
else
System.out.print('.');
}
System.out.println();
}
System.out.println();
}
public void dodaj(int wiersz, int kolumna, char c) {
if(wiersz < 0 || kolumna < 0 || wiersz >= this.szer || kolumna >= this.wys)
return;
switch (c) {
case 'A' -> plansza[wiersz][kolumna] = new A();
case 'B' -> plansza[wiersz][kolumna] = new B();
case 'C' -> plansza[wiersz][kolumna] = new C();
case 'D' -> plansza[wiersz][kolumna] = new D();
}
}
public void zamien(int w1, int k1, int w2, int k2) {
if(w1 >= this.wys || w1 < 0 || k1 >= this.szer || k1 < 0
|| w2 >= this.wys || w2 < 0 || k2 >= this.szer || k2 < 0)
return;
Obiekt temp = plansza[w1][k1];
plansza[w1][k1] = plansza[w2][k2];
plansza[w2][k2] = temp;
}
public void przesun(int w, int k, int dodaj_w, int dodaj_k) {
if(waliduj_wsp(w, k) && waliduj_wsp(w + dodaj_w, k + dodaj_k)) {
plansza[w + dodaj_w][k + dodaj_k] = plansza[w][k];
plansza[w][k] = null;
}
}
private boolean waliduj_wsp(int w, int k) {
return ((w >= 0) && (w < this.wys) && (k >= 0) && (k < this.szer));
}
}
| t |
6528_5 | kpiotrowski/GEN_TASK_java | 516 | OKProject/src/Podzadanie.java | import java.io.Serializable;
import java.util.Random;
/**
* Jedno z 2 operacji należących do zadania
* @author Kamil Piotrowski ; Michał Lewiński
*
*/
public class Podzadanie extends Blok implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* Maszyna na której jest wykonywane zadanie
*/
public final int maszyna;
/**
* Czy zadanie zostało wykonane
*/
public boolean wykonane=false;
/**
* Drugie podzadanie
* Aby łatwiej było sprawdzać stan drugiej operacji
*/
public Podzadanie brat=null;
/**
* Numer operacji 1 lub 2;
*/
public int numerOperacji;
/**
* Czas gotowości dla acalego zadania
*/
public int czasGotowosci=0;
public Podzadanie(int ma, int num, int id){
Random generator = new Random();
this.maszyna=ma;
this.numerOperacji = num;
this.czasTrwania=generator.nextInt(Main.maxZ-Main.minZ)+Main.minZ;
this.wykonane=false;
this.id=id;
}
public Podzadanie(Podzadanie op) {
this.maszyna=op.maszyna;
this.czasStartu=op.czasStartu;
this.numerOperacji=op.numerOperacji;
this.czasTrwania=op.czasTrwania;
this.czasGotowosci=op.czasGotowosci;
this.wykonane=op.wykonane;
this.czasKonca=op.czasKonca;
this.id=op.id;
}
} | /**
* Czas gotowości dla acalego zadania
*/ | import java.io.Serializable;
import java.util.Random;
/**
* Jedno z 2 operacji należących do zadania
* @author Kamil Piotrowski ; Michał Lewiński
*
*/
public class Podzadanie extends Blok implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* Maszyna na której jest wykonywane zadanie
*/
public final int maszyna;
/**
* Czy zadanie zostało wykonane
*/
public boolean wykonane=false;
/**
* Drugie podzadanie
* Aby łatwiej było sprawdzać stan drugiej operacji
*/
public Podzadanie brat=null;
/**
* Numer operacji 1 lub 2;
*/
public int numerOperacji;
/**
* Czas gotowości dla <SUF>*/
public int czasGotowosci=0;
public Podzadanie(int ma, int num, int id){
Random generator = new Random();
this.maszyna=ma;
this.numerOperacji = num;
this.czasTrwania=generator.nextInt(Main.maxZ-Main.minZ)+Main.minZ;
this.wykonane=false;
this.id=id;
}
public Podzadanie(Podzadanie op) {
this.maszyna=op.maszyna;
this.czasStartu=op.czasStartu;
this.numerOperacji=op.numerOperacji;
this.czasTrwania=op.czasTrwania;
this.czasGotowosci=op.czasGotowosci;
this.wykonane=op.wykonane;
this.czasKonca=op.czasKonca;
this.id=op.id;
}
} | t |
6278_3 | kpiotrowski/OOPProject_JAVA | 1,847 | SymulacjaSwiata_K.Piotrowski/src/DROGA/Droga.java | package DROGA;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
import MAIN.PunktMapy;
import POJAZD.Pojazd;
/**
*
* @author Kamil Piotrowski
* Klasa określająca drogę w naszym ściecie
* Zawiera punkt A oraz listę jego następników B To był jednak zły pomysł, bardzo zły :(
* Droga określa jednak tylko 1 ! odcinek między 2 punktami
* Jako drogę rozumie się najmniejszy możliwy odcinek trasy np miasto - skrzyżowanie
*
*/
public class Droga implements Serializable {
/**
* serialVersionUID
*/
private static final long serialVersionUID = -7963927998936324555L;
/**
* Punkt startowy naszej drogi
*/
private PunktMapy A;
/**
* Następnik (1) punktu A(punktu startowego drogi)
*/
private PunktMapy B;
/**
* Lista pojazdów znajdujących się na drodze
* Używane podaczas wykrywania kolizji
*/
private List<Pojazd> pojazdyNaDrodze = new LinkedList<Pojazd>();
/**
* Współczynnik kierunkowy prostej zawierającej naszą drogę
*/
private double kierunek;
/**
* Kąt a naszej prostej (kierunek = tg(katProstej))
*/
private double katProstej;
/**
* Mówi nam ile trasa (do rysowania ) jest oddalona na osi X od odcinka łączącego miasta (A - B)
*/
private int odX=0;
/**
* Mówi nam ile trasa (do rysowania ) jest oddalona na osi Y od odcinka łączącego miasta (A - B)
*/
private int odY=0;
/**
*
* @param a - punkt A
* @param b - następnik punktu a
* Droga jest tworzona na podstawie tych 2 punktów
*/
public Droga(PunktMapy a, PunktMapy b) {
this.setA(a);
this.setB(b);
this.przeliczProsta();
}
/**
* Metoda która z funkcji trygonometrycznych wylicza takie wartości jak kąt nachylenia / kierunek
* Oraz najważenijsze : odsunięcie które używamy podczas rysowania pojazdów
*/
private void przeliczProsta(){
int OdProstej=32;
if(this instanceof TrasaMorska) OdProstej=20;
int diffX=(int) (this.getB().getKoorX()-this.getA().getKoorX());
int diffY=(int) (this.getB().getKoorY()-this.getA().getKoorY());
diffY*=-1;
this.kierunek=(double)diffY/diffX;
this.katProstej=Math.toDegrees(Math.atan(Math.abs(this.getKierunek())));
// I ĆWIARTKA
if(diffX>0 && diffY> 0){
this.odX=(int) (OdProstej*Math.sin(Math.toRadians(this.katProstej)));
this.odY=(int) (OdProstej*Math.cos(Math.toRadians(this.katProstej)));
}
// II ĆWIARTKA
if(diffX<0 && diffY> 0) {
odX=(int) (OdProstej*Math.sin(Math.toRadians(this.katProstej)));
odY=(int) (-OdProstej*Math.cos(Math.toRadians(this.katProstej)));
this.katProstej=180-this.katProstej;
}
// III ĆWIARTKA
if(diffX<0 && diffY< 0) {
odX=(int) (-OdProstej*Math.sin(Math.toRadians(this.katProstej)));
odY=(int) (-OdProstej*Math.cos(Math.toRadians(this.katProstej)));
this.katProstej+=180;
}
// IV ĆWIARTKA
if(diffX>0 && diffY< 0) {
odX=(int) (-OdProstej*Math.sin(Math.toRadians(this.katProstej)));
odY=(int) (OdProstej*Math.cos(Math.toRadians(this.katProstej)));
this.katProstej=360-this.katProstej;
}
}
public double getDifferenceBPoints(){
double diffX=this.getB().getKoorX()-this.getA().getKoorX();
double diffY=this.getB().getKoorY()-this.getA().getKoorY();
diffX=Math.abs(diffX);
diffY=Math.abs(diffY);
double diffP=Math.pow(Math.pow(diffX, 2)+Math.pow(diffY, 2) , 0.5);
return diffP;
}
public PunktMapy getA() {
return this.A;
}
public void setA(PunktMapy a) {
this.A = a;
}
public PunktMapy getB() {
return this.B;
}
public void setB(PunktMapy b) {
this.B = b;
}
public double getKierunek() {
return kierunek;
}
public int getOdX() {
return odX;
}
public int getOdY() {
return odY;
}
public double getKatProstej() {
return katProstej;
}
public void setKatProstej(double katProstej) {
this.katProstej = katProstej;
}
public List<Pojazd> getPojazdyNaDrodze() {
return pojazdyNaDrodze;
}
public void setPojazdyNaDrodze(List<Pojazd> pojazdyNaDrodze) {
this.pojazdyNaDrodze = pojazdyNaDrodze;
}
}
| /**
* Następnik (1) punktu A(punktu startowego drogi)
*/ | package DROGA;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
import MAIN.PunktMapy;
import POJAZD.Pojazd;
/**
*
* @author Kamil Piotrowski
* Klasa określająca drogę w naszym ściecie
* Zawiera punkt A oraz listę jego następników B To był jednak zły pomysł, bardzo zły :(
* Droga określa jednak tylko 1 ! odcinek między 2 punktami
* Jako drogę rozumie się najmniejszy możliwy odcinek trasy np miasto - skrzyżowanie
*
*/
public class Droga implements Serializable {
/**
* serialVersionUID
*/
private static final long serialVersionUID = -7963927998936324555L;
/**
* Punkt startowy naszej drogi
*/
private PunktMapy A;
/**
* Następnik (1) punktu <SUF>*/
private PunktMapy B;
/**
* Lista pojazdów znajdujących się na drodze
* Używane podaczas wykrywania kolizji
*/
private List<Pojazd> pojazdyNaDrodze = new LinkedList<Pojazd>();
/**
* Współczynnik kierunkowy prostej zawierającej naszą drogę
*/
private double kierunek;
/**
* Kąt a naszej prostej (kierunek = tg(katProstej))
*/
private double katProstej;
/**
* Mówi nam ile trasa (do rysowania ) jest oddalona na osi X od odcinka łączącego miasta (A - B)
*/
private int odX=0;
/**
* Mówi nam ile trasa (do rysowania ) jest oddalona na osi Y od odcinka łączącego miasta (A - B)
*/
private int odY=0;
/**
*
* @param a - punkt A
* @param b - następnik punktu a
* Droga jest tworzona na podstawie tych 2 punktów
*/
public Droga(PunktMapy a, PunktMapy b) {
this.setA(a);
this.setB(b);
this.przeliczProsta();
}
/**
* Metoda która z funkcji trygonometrycznych wylicza takie wartości jak kąt nachylenia / kierunek
* Oraz najważenijsze : odsunięcie które używamy podczas rysowania pojazdów
*/
private void przeliczProsta(){
int OdProstej=32;
if(this instanceof TrasaMorska) OdProstej=20;
int diffX=(int) (this.getB().getKoorX()-this.getA().getKoorX());
int diffY=(int) (this.getB().getKoorY()-this.getA().getKoorY());
diffY*=-1;
this.kierunek=(double)diffY/diffX;
this.katProstej=Math.toDegrees(Math.atan(Math.abs(this.getKierunek())));
// I ĆWIARTKA
if(diffX>0 && diffY> 0){
this.odX=(int) (OdProstej*Math.sin(Math.toRadians(this.katProstej)));
this.odY=(int) (OdProstej*Math.cos(Math.toRadians(this.katProstej)));
}
// II ĆWIARTKA
if(diffX<0 && diffY> 0) {
odX=(int) (OdProstej*Math.sin(Math.toRadians(this.katProstej)));
odY=(int) (-OdProstej*Math.cos(Math.toRadians(this.katProstej)));
this.katProstej=180-this.katProstej;
}
// III ĆWIARTKA
if(diffX<0 && diffY< 0) {
odX=(int) (-OdProstej*Math.sin(Math.toRadians(this.katProstej)));
odY=(int) (-OdProstej*Math.cos(Math.toRadians(this.katProstej)));
this.katProstej+=180;
}
// IV ĆWIARTKA
if(diffX>0 && diffY< 0) {
odX=(int) (-OdProstej*Math.sin(Math.toRadians(this.katProstej)));
odY=(int) (OdProstej*Math.cos(Math.toRadians(this.katProstej)));
this.katProstej=360-this.katProstej;
}
}
public double getDifferenceBPoints(){
double diffX=this.getB().getKoorX()-this.getA().getKoorX();
double diffY=this.getB().getKoorY()-this.getA().getKoorY();
diffX=Math.abs(diffX);
diffY=Math.abs(diffY);
double diffP=Math.pow(Math.pow(diffX, 2)+Math.pow(diffY, 2) , 0.5);
return diffP;
}
public PunktMapy getA() {
return this.A;
}
public void setA(PunktMapy a) {
this.A = a;
}
public PunktMapy getB() {
return this.B;
}
public void setB(PunktMapy b) {
this.B = b;
}
public double getKierunek() {
return kierunek;
}
public int getOdX() {
return odX;
}
public int getOdY() {
return odY;
}
public double getKatProstej() {
return katProstej;
}
public void setKatProstej(double katProstej) {
this.katProstej = katProstej;
}
public List<Pojazd> getPojazdyNaDrodze() {
return pojazdyNaDrodze;
}
public void setPojazdyNaDrodze(List<Pojazd> pojazdyNaDrodze) {
this.pojazdyNaDrodze = pojazdyNaDrodze;
}
}
| t |
5786_2 | kracek/bipartite | 907 | ProPepGraph.java | package mscanlib.ms.mass.bipartite;
import org.graphstream.graph.Graph;
import org.graphstream.graph.NodeFactory;
import org.graphstream.graph.implementations.AbstractGraph;
import org.graphstream.graph.implementations.AdjacencyListGraph;
public class ProPepGraph extends AdjacencyListGraph {
/**
* Tworzy pusty graf.
*
* @param id
* Unikalny identyfikator grafu.
* @param strictChecking
* If true zaden non-fatal error nie rzuca wyjatkiem.
* @param autoCreate
* If true (and strict checking is false), wezly sa
* automatycznie tworzone kiedy tworzona krawedz sie do niego odnosi,
* nawet jezeli nie sa jeszcze wstawione w graf.
* @param initialNodeCapacity
* Poczatkowa pojemnosc struktur danych dla wezlow. Uzyj tego
* jesli znasz przyblizona maksymalna liczbe wezlow
* grafu.Graf moze sie rozwijac poza tym limitem, ale realokacja
* jest kosztowna operacja.
* @param initialEdgeCapacity
* Poczatkowa pojemnosc struktur danych dla krawedzi. Uzyj tego
* jesli znasz przyblizona maksymalna liczbe krawedzi
* grafu.Graf moze sie rozwijac poza tym limitem, ale realokacja
* jest kosztowna operacja.
*/
public ProPepGraph(String id, boolean strictChecking, boolean autoCreate,
int initialNodeCapacity, int initialEdgeCapacity) {
super(id, strictChecking, autoCreate, initialNodeCapacity,
initialEdgeCapacity);
// All we need to do is to change the node factory
this.setNodeFactory(new NodeFactory<ProPepNode>() {
public ProPepNode newInstance(String id, Graph graph) {
return new ProPepNode((AbstractGraph) graph, id);
}
});
}
/**
* Tworzy pusty graf z domyslna pojemnoscia krawedzi i wezlow.
*
* @param id
* Unikalny identyfikator grafu.
* @param strictChecking
* If true zaden non-fatal error nie rzuca wyjatkiem.
* @param autoCreate
* If true (and strict checking is false), wezly sa
* automatycznie tworzone kiedy tworzona krawedz sie do niego odnosi,
* nawet jezeli nie sa jeszcze wstawione w graf.
*/
public ProPepGraph(String id, boolean strictChecking, boolean autoCreate) {
this(id, strictChecking, autoCreate, DEFAULT_NODE_CAPACITY,
DEFAULT_EDGE_CAPACITY);
}
/**
* Tworzy pusty graf z strict checking i bez auto-creation.
*
* @param id
* Unikalny identyfikator grafu.
*/
public ProPepGraph(String id) {
this(id, true, false);
}
}
| /**
* Tworzy pusty graf z domyslna pojemnoscia krawedzi i wezlow.
*
* @param id
* Unikalny identyfikator grafu.
* @param strictChecking
* If true zaden non-fatal error nie rzuca wyjatkiem.
* @param autoCreate
* If true (and strict checking is false), wezly sa
* automatycznie tworzone kiedy tworzona krawedz sie do niego odnosi,
* nawet jezeli nie sa jeszcze wstawione w graf.
*/ | package mscanlib.ms.mass.bipartite;
import org.graphstream.graph.Graph;
import org.graphstream.graph.NodeFactory;
import org.graphstream.graph.implementations.AbstractGraph;
import org.graphstream.graph.implementations.AdjacencyListGraph;
public class ProPepGraph extends AdjacencyListGraph {
/**
* Tworzy pusty graf.
*
* @param id
* Unikalny identyfikator grafu.
* @param strictChecking
* If true zaden non-fatal error nie rzuca wyjatkiem.
* @param autoCreate
* If true (and strict checking is false), wezly sa
* automatycznie tworzone kiedy tworzona krawedz sie do niego odnosi,
* nawet jezeli nie sa jeszcze wstawione w graf.
* @param initialNodeCapacity
* Poczatkowa pojemnosc struktur danych dla wezlow. Uzyj tego
* jesli znasz przyblizona maksymalna liczbe wezlow
* grafu.Graf moze sie rozwijac poza tym limitem, ale realokacja
* jest kosztowna operacja.
* @param initialEdgeCapacity
* Poczatkowa pojemnosc struktur danych dla krawedzi. Uzyj tego
* jesli znasz przyblizona maksymalna liczbe krawedzi
* grafu.Graf moze sie rozwijac poza tym limitem, ale realokacja
* jest kosztowna operacja.
*/
public ProPepGraph(String id, boolean strictChecking, boolean autoCreate,
int initialNodeCapacity, int initialEdgeCapacity) {
super(id, strictChecking, autoCreate, initialNodeCapacity,
initialEdgeCapacity);
// All we need to do is to change the node factory
this.setNodeFactory(new NodeFactory<ProPepNode>() {
public ProPepNode newInstance(String id, Graph graph) {
return new ProPepNode((AbstractGraph) graph, id);
}
});
}
/**
* Tworzy pusty graf <SUF>*/
public ProPepGraph(String id, boolean strictChecking, boolean autoCreate) {
this(id, strictChecking, autoCreate, DEFAULT_NODE_CAPACITY,
DEFAULT_EDGE_CAPACITY);
}
/**
* Tworzy pusty graf z strict checking i bez auto-creation.
*
* @param id
* Unikalny identyfikator grafu.
*/
public ProPepGraph(String id) {
this(id, true, false);
}
}
| t |
10265_9 | krystian-wojtas/DzikieSpawarki | 1,304 | DSClient/src/main/java/pl/edu/agh/ftj/DSClient/simulation/Simulation.java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pl.edu.agh.ftj.DSClient.simulation;
import com.agh.StrategiaManger_Service;
import java.util.LinkedList;
import java.util.List;
import javax.xml.ws.WebServiceRef;
/**
*Na dobrą sprawę klient webserwisu, ale równocześnie fasolka która odpowiada za całą magię. Przy dostawaniu się do odpowiednich pól wywoływane są odpowiednie zapytania do webserwisu mające na celu pobranie list symulacji/parametrów.
* @author Michał Zimnicki
*/
public class Simulation
{
@WebServiceRef(wsdlLocation = "WEB-INF/wsdl/localhost_8080/StrategiaManger/StrategiaManger.wsdl")
private StrategiaManger_Service service;
private com.agh.StrategiaManger port;
private XMLParser parser;
private LinkedList<SimulationClassCore> simulationList;
private SimulationToExecute simulationToExecute;
private LinkedList<SimulationFinished> resultList;
/**
* Tworzy nową instancje klasy. Inicjalizuje wszystkie uchwyty do webserwiu.
*/
public Simulation()
{
try { // Call Web Service Operation
parser = new XMLParser();
service = new StrategiaManger_Service();
port = service.getStrategiaMangerPort();
} catch (Exception ex) {
System.err.println(ex);
}
}
/**
* Zwraca liste możliwych symulacji do wykonania
* @return liste symulacji do wykonania
*/
public LinkedList<SimulationClassCore> getSimulationList()
{
try
{
String result = port.simulationList();
System.out.println(result);
simulationList = parser.parseSimulationList(result);
} catch (Exception ex) {System.err.println(ex); }
return simulationList;
}
/**
* Wysyła do webserwisu listę parametrów wraz z ich wartościami oraz polecenie wykonania danej symulacji. Nie oczekuje na jej zakończenie.
* @return the executeSimulation
*/
public String executeSimulation()
{
try
{
port.executeSimulation(getSimulationToExecute().getName(), getSimulationToExecute().getParametersInStringFormat());
}
catch (Exception ex) { }
return "executeSimulation";
}
/**
* Zapytanie o parametry symulacji o zadanej nazwie
* @param name nazwa rodzaju symulacji
* @return gp
*/
public String SimulationParameters(String name)
{
try
{
String result = port.simulationParameters(name);
simulationToExecute = parser.parseSimulationParameters(name, result);
System.out.println(result);
}
catch (Exception ex) { }
return "gp";
}
/**
* Zwraca listę wykonanych symulacji wszystkich typów.
* @return lista wykonanych symulacji
*/
public LinkedList<SimulationFinished> getResultList()
{
try
{
String result = port.resultList();
resultList = parser.parseResult(result);
System.out.println(resultList.size());
}
catch(Exception ex)
{
System.err.println(ex);
}
return resultList;
}
/**
* Ustawia wartość parametru o zadanej nazwie na zadaną wartość w symulaji do wykonania
* @param parameterName nazwa parametru
* @param value wartość parametru
*/
public void setParameter(String parameterName, String value)
{
for(int i=0; i<this.getSimulationToExecute().getParameters().size(); i++)
{
if(this.getSimulationToExecute().getParameters().get(i).getName().equals(parameterName))
{
this.getSimulationToExecute().getParameters().get(i).setType(value);
break;
}
}
}
/**
* Zwraca symulację wraz z opisem jej parametrów by była gotowa do wykonania
* @return symulacja do wykonania
*/
public SimulationToExecute getSimulationToExecute()
{
return simulationToExecute;
}
public String shit()
{
return System.getProperty("java.io.tmpdir");
}
}
| /**
* Zwraca symulację wraz z opisem jej parametrów by była gotowa do wykonania
* @return symulacja do wykonania
*/ | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pl.edu.agh.ftj.DSClient.simulation;
import com.agh.StrategiaManger_Service;
import java.util.LinkedList;
import java.util.List;
import javax.xml.ws.WebServiceRef;
/**
*Na dobrą sprawę klient webserwisu, ale równocześnie fasolka która odpowiada za całą magię. Przy dostawaniu się do odpowiednich pól wywoływane są odpowiednie zapytania do webserwisu mające na celu pobranie list symulacji/parametrów.
* @author Michał Zimnicki
*/
public class Simulation
{
@WebServiceRef(wsdlLocation = "WEB-INF/wsdl/localhost_8080/StrategiaManger/StrategiaManger.wsdl")
private StrategiaManger_Service service;
private com.agh.StrategiaManger port;
private XMLParser parser;
private LinkedList<SimulationClassCore> simulationList;
private SimulationToExecute simulationToExecute;
private LinkedList<SimulationFinished> resultList;
/**
* Tworzy nową instancje klasy. Inicjalizuje wszystkie uchwyty do webserwiu.
*/
public Simulation()
{
try { // Call Web Service Operation
parser = new XMLParser();
service = new StrategiaManger_Service();
port = service.getStrategiaMangerPort();
} catch (Exception ex) {
System.err.println(ex);
}
}
/**
* Zwraca liste możliwych symulacji do wykonania
* @return liste symulacji do wykonania
*/
public LinkedList<SimulationClassCore> getSimulationList()
{
try
{
String result = port.simulationList();
System.out.println(result);
simulationList = parser.parseSimulationList(result);
} catch (Exception ex) {System.err.println(ex); }
return simulationList;
}
/**
* Wysyła do webserwisu listę parametrów wraz z ich wartościami oraz polecenie wykonania danej symulacji. Nie oczekuje na jej zakończenie.
* @return the executeSimulation
*/
public String executeSimulation()
{
try
{
port.executeSimulation(getSimulationToExecute().getName(), getSimulationToExecute().getParametersInStringFormat());
}
catch (Exception ex) { }
return "executeSimulation";
}
/**
* Zapytanie o parametry symulacji o zadanej nazwie
* @param name nazwa rodzaju symulacji
* @return gp
*/
public String SimulationParameters(String name)
{
try
{
String result = port.simulationParameters(name);
simulationToExecute = parser.parseSimulationParameters(name, result);
System.out.println(result);
}
catch (Exception ex) { }
return "gp";
}
/**
* Zwraca listę wykonanych symulacji wszystkich typów.
* @return lista wykonanych symulacji
*/
public LinkedList<SimulationFinished> getResultList()
{
try
{
String result = port.resultList();
resultList = parser.parseResult(result);
System.out.println(resultList.size());
}
catch(Exception ex)
{
System.err.println(ex);
}
return resultList;
}
/**
* Ustawia wartość parametru o zadanej nazwie na zadaną wartość w symulaji do wykonania
* @param parameterName nazwa parametru
* @param value wartość parametru
*/
public void setParameter(String parameterName, String value)
{
for(int i=0; i<this.getSimulationToExecute().getParameters().size(); i++)
{
if(this.getSimulationToExecute().getParameters().get(i).getName().equals(parameterName))
{
this.getSimulationToExecute().getParameters().get(i).setType(value);
break;
}
}
}
/**
* Zwraca symulację wraz <SUF>*/
public SimulationToExecute getSimulationToExecute()
{
return simulationToExecute;
}
public String shit()
{
return System.getProperty("java.io.tmpdir");
}
}
| t |
10270_11 | krzyfok/Jezioro_projekt | 2,002 | classes/src/main/java/org/example/Fish.java | package org.example;
import java.util.ArrayList;
import java.util.Random;
/**
* Fish pływa i wykonuję określone akcje
*/
public abstract class Fish implements Swim{
/** prędkosć w osi X */
protected int speedX;
/** prędkość w osi Y */
protected int speedY;
/** Współrzedna Y */
protected int coY;
/** Współrzędna X*/
protected int coX;
/** Rozmiar */
protected int size;
/** Siła */
protected int power;
/** Zwinność */
protected int agility;
/** Punkty życia */
protected int health;
/** Kierunek w osi X */
protected boolean gobackx;
/** Kierunek w osi Y */
protected boolean gobacky;
/** Zasięg rozmnażania */
protected static int breedrange = 20;
/** Zasięg ataku */
protected int attackrange;
/** głód */
protected double hunger;
/** licznik odpowiadający za możliwosć rozmnażania */
protected double dobreed;
/** limit ilości ryb */
private int maxOfIndividual = 45;
/** minimalna wartośc licznika dobreed potrzebna do rozmnażania */
private int minBreed = 30;
/** Maksymalna odległość nowej ryby od rodzica */
private int breedArea = 30;
/** minimalna wartość głodu by przeprowadzić atak */
private int minHunger = 10;
/**
* Metoda ustawia pierwszą lokalizacje ryby, uwzględniając warunek by była na mapie
* @param size rozmiar ryby
*/
public void position(int size) {
Random rand = new Random();
this.coX=((rand.nextInt(Map.size-2* Map.border-2*size))+ Map.border+size);
this.coY=((rand.nextInt(Map.size- Map.upBorder- Map.downBorder-2*size-2*Map.border))+ Map.upBorder+size+Map.border);
}
/**
* Metoda mierzy odległość między dwoma rybami
* @param fish1 ryba 1
* @param fish2 ryba 2
* @return zwracana odległość
*/
public static double distance(Fish fish1, Fish fish2) {
return (Math.sqrt((fish1.coX+fish1.size/2-fish2.coX-fish2.size/2)*(fish1.coX+fish1.size/2-fish2.coX-fish2.size/2)+(fish1.coY+fish1.size/2-fish2.coY-fish2.size/2)*(fish1.coY+fish1.size/2-fish2.coY-fish2.size/2)));
}
/**
* Metoda przeprowadza rozmnażanie ryb
* @param fish2 ryba z którą ryba na której została wywołana metoda przeprowadza rozmnażanie
*/
public void reproduct(Fish fish2) {
Random rand = new Random();
/**
* Sprawdzanie czy mogą się rozmnażać oraz ograniczenie osobników danej odmiany
*/
if(this.dobreed<=minBreed || fish2.dobreed<=minBreed)
return;
if(this.numberOfFish()>=maxOfIndividual)
return;
/**
* Sprawdzanie czy dystans między rybami jest mniejszy niż breedrange
*/
if (distance(this, fish2) <= breedrange) {
if (this instanceof GreenFish)
Map.tableOfFish.add(new GreenFish());
else if (this instanceof RedFish)
Map.tableOfFish.add(new RedFish());
else if (this instanceof YellowFish)
Map.tableOfFish.add(new YellowFish());
/**
* Ustawienie współrzędnych nowych ryb oraz ewentulana korekta położenia ryby
*/
if(!(this instanceof YellowFish)) {
Map.tableOfFish.get(Map.tableOfFish.size() - 1).coX = this.coX - rand.nextInt() % breedArea;
Map.tableOfFish.get(Map.tableOfFish.size() - 1).coY = this.coY - rand.nextInt() % breedArea;
if(this.coY<=Map.upBorder+Map.border) {
this.coY+=2*this.size;
this.gobacky=true;
}
if(this.coY>=Map.size-Map.downBorder-Map.border-this.size) {
this.coY-=2*this.size;
this.gobacky=false;
}
}
/**
* Zablokowanie możliwości rozmnażania ryb przez określony czas
*/
this.dobreed = 0;
fish2.dobreed = 0;
}
}
/**
* Metoda przeprowadza akcję ataku między dwoma rybami, słabsza ryba traci punkty życia
* @param fish2 2 ryba która jest atakowana przez rybę na której została wywołana metoda
*/
public void attack(Fish fish2) {
if(this.hunger<minHunger)
return;
if (distance(this, fish2) <= this.attackrange)
if (this.power > fish2.power) {
fish2.health -= this.power;
this.hunger = 0;
}
}
/**
* Metoda sprawdza czy któraś z ryb jest martwa, jeżeli tak zostaje usunięta z tablicy
* @param table tablica ryb
* @return jeżeli ryba umiera zwracana jest wartość 1, jeżeli nie to 0
*/
public int die(ArrayList table) {
if (this.health<=0) {
table.remove(this);
return 1;
}
else
return 0;
}
/**
* Metoda liczy ryby w tabeli tableOfFish
* @return zwracana jest liczba ryb w tabeli
*/
public int numberOfFish() {
int number=0;
for(int i=0; i<Map.tableOfFish.size(); i++)
if(Map.tableOfFish.get(i).getClass() == this.getClass())
number++;
return number;
}
/**
* Metoda zwraca współrzędną X
*/
public int give_coX()
{
return coX;
}
/**
* Metoda zwraca współrzędną Y
*/
public int give_coY()
{
return coY;
}
/**
* Metoda zwraca rozmiar
*/
public int give_size()
{
return size;
}
/**
* Metoda zwraca attackrange
*/
public int give_attackrange()
{
return attackrange;
}
/**
* Metoda zwraca punkty życia
*/
public int give_health()
{
return health;
}
}
| /**
* Metoda ustawia pierwszą lokalizacje ryby, uwzględniając warunek by była na mapie
* @param size rozmiar ryby
*/ | package org.example;
import java.util.ArrayList;
import java.util.Random;
/**
* Fish pływa i wykonuję określone akcje
*/
public abstract class Fish implements Swim{
/** prędkosć w osi X */
protected int speedX;
/** prędkość w osi Y */
protected int speedY;
/** Współrzedna Y */
protected int coY;
/** Współrzędna X*/
protected int coX;
/** Rozmiar */
protected int size;
/** Siła */
protected int power;
/** Zwinność */
protected int agility;
/** Punkty życia */
protected int health;
/** Kierunek w osi X */
protected boolean gobackx;
/** Kierunek w osi Y */
protected boolean gobacky;
/** Zasięg rozmnażania */
protected static int breedrange = 20;
/** Zasięg ataku */
protected int attackrange;
/** głód */
protected double hunger;
/** licznik odpowiadający za możliwosć rozmnażania */
protected double dobreed;
/** limit ilości ryb */
private int maxOfIndividual = 45;
/** minimalna wartośc licznika dobreed potrzebna do rozmnażania */
private int minBreed = 30;
/** Maksymalna odległość nowej ryby od rodzica */
private int breedArea = 30;
/** minimalna wartość głodu by przeprowadzić atak */
private int minHunger = 10;
/**
* Metoda ustawia pierwszą <SUF>*/
public void position(int size) {
Random rand = new Random();
this.coX=((rand.nextInt(Map.size-2* Map.border-2*size))+ Map.border+size);
this.coY=((rand.nextInt(Map.size- Map.upBorder- Map.downBorder-2*size-2*Map.border))+ Map.upBorder+size+Map.border);
}
/**
* Metoda mierzy odległość między dwoma rybami
* @param fish1 ryba 1
* @param fish2 ryba 2
* @return zwracana odległość
*/
public static double distance(Fish fish1, Fish fish2) {
return (Math.sqrt((fish1.coX+fish1.size/2-fish2.coX-fish2.size/2)*(fish1.coX+fish1.size/2-fish2.coX-fish2.size/2)+(fish1.coY+fish1.size/2-fish2.coY-fish2.size/2)*(fish1.coY+fish1.size/2-fish2.coY-fish2.size/2)));
}
/**
* Metoda przeprowadza rozmnażanie ryb
* @param fish2 ryba z którą ryba na której została wywołana metoda przeprowadza rozmnażanie
*/
public void reproduct(Fish fish2) {
Random rand = new Random();
/**
* Sprawdzanie czy mogą się rozmnażać oraz ograniczenie osobników danej odmiany
*/
if(this.dobreed<=minBreed || fish2.dobreed<=minBreed)
return;
if(this.numberOfFish()>=maxOfIndividual)
return;
/**
* Sprawdzanie czy dystans między rybami jest mniejszy niż breedrange
*/
if (distance(this, fish2) <= breedrange) {
if (this instanceof GreenFish)
Map.tableOfFish.add(new GreenFish());
else if (this instanceof RedFish)
Map.tableOfFish.add(new RedFish());
else if (this instanceof YellowFish)
Map.tableOfFish.add(new YellowFish());
/**
* Ustawienie współrzędnych nowych ryb oraz ewentulana korekta położenia ryby
*/
if(!(this instanceof YellowFish)) {
Map.tableOfFish.get(Map.tableOfFish.size() - 1).coX = this.coX - rand.nextInt() % breedArea;
Map.tableOfFish.get(Map.tableOfFish.size() - 1).coY = this.coY - rand.nextInt() % breedArea;
if(this.coY<=Map.upBorder+Map.border) {
this.coY+=2*this.size;
this.gobacky=true;
}
if(this.coY>=Map.size-Map.downBorder-Map.border-this.size) {
this.coY-=2*this.size;
this.gobacky=false;
}
}
/**
* Zablokowanie możliwości rozmnażania ryb przez określony czas
*/
this.dobreed = 0;
fish2.dobreed = 0;
}
}
/**
* Metoda przeprowadza akcję ataku między dwoma rybami, słabsza ryba traci punkty życia
* @param fish2 2 ryba która jest atakowana przez rybę na której została wywołana metoda
*/
public void attack(Fish fish2) {
if(this.hunger<minHunger)
return;
if (distance(this, fish2) <= this.attackrange)
if (this.power > fish2.power) {
fish2.health -= this.power;
this.hunger = 0;
}
}
/**
* Metoda sprawdza czy któraś z ryb jest martwa, jeżeli tak zostaje usunięta z tablicy
* @param table tablica ryb
* @return jeżeli ryba umiera zwracana jest wartość 1, jeżeli nie to 0
*/
public int die(ArrayList table) {
if (this.health<=0) {
table.remove(this);
return 1;
}
else
return 0;
}
/**
* Metoda liczy ryby w tabeli tableOfFish
* @return zwracana jest liczba ryb w tabeli
*/
public int numberOfFish() {
int number=0;
for(int i=0; i<Map.tableOfFish.size(); i++)
if(Map.tableOfFish.get(i).getClass() == this.getClass())
number++;
return number;
}
/**
* Metoda zwraca współrzędną X
*/
public int give_coX()
{
return coX;
}
/**
* Metoda zwraca współrzędną Y
*/
public int give_coY()
{
return coY;
}
/**
* Metoda zwraca rozmiar
*/
public int give_size()
{
return size;
}
/**
* Metoda zwraca attackrange
*/
public int give_attackrange()
{
return attackrange;
}
/**
* Metoda zwraca punkty życia
*/
public int give_health()
{
return health;
}
}
| t |
3831_4 | krzysztofjuszczyk/JavaCodeWithMosh | 464 | src/HashTables.java |
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class HashTables {
public static void main(String[] args) {
// ex.1 find first non-repeatable character
String test = "a green apple";
System.out.println(firstNonRepeatable(test));
System.out.println(firstRepeated(test));
}
public static char firstNonRepeatable (String input){
Map<Character, Integer> hashMap = new HashMap<>();
input = input.replaceAll(" ", "");
//rozw. 1 tworzymy mapę char / ilość wystąpień
// można poprawić wywołaniem raz toCharArray i operatorem trójarg.
for (var i: input.toCharArray()
) {
if (hashMap.containsKey(i)){
int value = hashMap.get(i);
hashMap.put(i, ++value);
}
else {
hashMap.put(i, 1);
}
}
// iterujemy jeszcze raz i zwracamy pierwsze wystąpienie
for (var i :
input.toCharArray()) {
if (hashMap.get(i)==1) return i;
}
throw new IllegalStateException(); // albo coś innego
}
//ex. 2 first Repeated - SET
public static char firstRepeated (String input){
Set<Character> characterSet = new HashSet<>();
for (var i :input.toCharArray()
) {
if (characterSet.contains(i)) return i;
characterSet.add(i);
}
throw new IllegalStateException(); // albo coś innego
}
}
| // albo coś innego |
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class HashTables {
public static void main(String[] args) {
// ex.1 find first non-repeatable character
String test = "a green apple";
System.out.println(firstNonRepeatable(test));
System.out.println(firstRepeated(test));
}
public static char firstNonRepeatable (String input){
Map<Character, Integer> hashMap = new HashMap<>();
input = input.replaceAll(" ", "");
//rozw. 1 tworzymy mapę char / ilość wystąpień
// można poprawić wywołaniem raz toCharArray i operatorem trójarg.
for (var i: input.toCharArray()
) {
if (hashMap.containsKey(i)){
int value = hashMap.get(i);
hashMap.put(i, ++value);
}
else {
hashMap.put(i, 1);
}
}
// iterujemy jeszcze raz i zwracamy pierwsze wystąpienie
for (var i :
input.toCharArray()) {
if (hashMap.get(i)==1) return i;
}
throw new IllegalStateException(); // albo coś <SUF>
}
//ex. 2 first Repeated - SET
public static char firstRepeated (String input){
Set<Character> characterSet = new HashSet<>();
for (var i :input.toCharArray()
) {
if (characterSet.contains(i)) return i;
characterSet.add(i);
}
throw new IllegalStateException(); // albo coś innego
}
}
| t |
6294_3 | ktanska/MathBubble | 3,982 | MathBubble.java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package kingatan;
import java.io.File;
import java.util.Random;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
/**
* Klasa tworząca działania
* na różnych poziomach trudności
* @author DELL
*/
public class MathBubble {
/* działania w formie napisu, przygotowane do wyświetlenia */
public static String[] wynik = {"","","","","","","","","","","",""};
/* zmienna określająca popraność działania */
public static int czy_poprawne;
/* status działania: 0-poprawne, 1-niepoprawne, 2-kliknięte i jest za nie punkt, 3-kliknięte bez punktu */
public static int czy_w[];
/* zmienna reprezentująca liczbę wchodzącą w działanie */
public static int a;
/* zmienna reprezentująca liczbę wchodzącą w działanie */
public static int b;
/* zmienna obliczona jako wynik działania */
public static int suma;
/* zmienna obliczona jako wynik działania */
public static int roznica;
/* zmienna obliczona jako wynik działania */
public static int iloczyn;
/* ilość poprawnych działań dla poziomu */
public static int ilosc_poprawnych=0;
/* ilość niepoprawnych działań dla poziomu */
public static int ilosc_niepoprawnych=0;
/* ilość punktów - ilość niepoprawnych działań w całej grze */
public static int suma_pkt;
/* współrzędna kliknięcia */
public static int x1=GamePanel.wspol1;
/* współrzędna kliknięcia */
public static int y2=GamePanel.wspol2;
/* ilość żyć w całej grze */
public static int ilosc_zyc=3;
/**
* Metoda losująca działania w zależności od poziomu gry
*/
public static void losuj(){
wynik = new String[12];
czy_w = new int [12];
for(int i=0;i<12;i++){
Random rand=new Random();
czy_poprawne=rand.nextInt(2);
if(GameStatus.level==1){
a=rand.nextInt(50)+1;
b=rand.nextInt(50)+1;
if(czy_poprawne==1){
suma=a+b;
ilosc_poprawnych++;
czy_w[i]=0;
}
else {
suma=a+b+rand.nextInt(20)+10;
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
else if(GameStatus.level==2){
a=rand.nextInt(50);
b=rand.nextInt(50);
if(czy_poprawne==1){
if(a>=b)roznica=a-b;
if (b>a) roznica=b-a;
ilosc_poprawnych++;
czy_w[i]=0;
}
else {
if(a>=b)roznica=a-b-(rand.nextInt(5)+5);
if (b>a) roznica=b-a-(rand.nextInt(5)+5);
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
else if(GameStatus.level==3){
a=rand.nextInt(20)+1;
b=rand.nextInt(10)+1;
if(czy_poprawne==1){
iloczyn=a*b;
ilosc_poprawnych++;
czy_w[i]=0;
}
else{
iloczyn=(a*b)+rand.nextInt(5)+2;
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
else if(GameStatus.level==4){
a=rand.nextInt(200)+1;
b=rand.nextInt(100)+1;
if(czy_poprawne==1){
suma=a+b;
ilosc_poprawnych++;
czy_w[i]=0;
}
else{
suma=(a+b)+rand.nextInt(5)+2;
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
String str1=Integer.toString(a);
String str2=Integer.toString(b);
if(GameStatus.level==1){
String str3=Integer.toString(suma);
wynik[i]=str1+" + "+str2+ " = "+str3;
}
if(GameStatus.level==2){
if(a>=b){
String str3=Integer.toString(roznica);
wynik[i]=str1+" - "+str2+ " = "+str3;
}
else{
String str3=Integer.toString(roznica);
wynik[i]=str2+" - "+str1+ " = "+str3;
}
}
if(GameStatus.level==3){
String str3=Integer.toString(iloczyn);
wynik[i]=str1+" * "+str2+ " = "+str3;
}
if(GameStatus.level==4){
String str3=Integer.toString(suma);
wynik[i]=str1+" + "+str2+ " = "+str3;
}
}
}
/**
* metoda sprawdzająca czy kliknięty jest wyłącznie obszar bąbelka
* @param x współrzędna kliknięcia
* @param y współrzędna kliknięcia
* @return 1 gdy tak, 0 gdy nie
*/
public static boolean containsPoint(int x, int y) {
for(int i=0;i<12;i++){
for(y2=30;y2<900;y2=(y2+GamePanel.odleglosc)){
for(x1=100;x1<900;x1=(x1+GamePanel.odleglosc)){
if(x>=x1 && x<(x1+150)){
if(y>=y2 && y<(y2+150)){
return true;
}
}
}
}
}
return false;
}
/**
* metoda sprawdzająca czy kliknięto poprawne czy niepoprawne działanie
* zmieniająca parametr czy_w, dodająca punkty w zależności od kliknięcia
* odtwarzająca dźwięk w zależności czy punkt był przyznany czy nie
* @param x współrzędna kliknięcia
* @param y współrzędna kliknięcia
* @return 1 gdy przyznany punkt, 0 gdy nie
*/
public static boolean czy_wynik(int x, int y){
if(x<250 && y<200) {
if(czy_w[0]==1){
czy_w[0]=2;
playSound(new File("sounds/tap-crisp.aif"));
ilosc_niepoprawnych--;
return true;
}
else{
czy_w[0]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x<250 && y>200 && y<400) {
if(czy_w[4]==1){
czy_w[4]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[4]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x<250 && y>400 && y<600) {
if(czy_w[8]==1){
czy_w[8]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[8]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>250 && x<500 && y<200) {
if(czy_w[1]==1){
czy_w[1]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[1]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>250 && x<500 && y>200 && y<400) {
if(czy_w[5]==1){
czy_w[5]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[5]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>250 && x<500 && y>400 && y<600) {
if(czy_w[9]==1){
czy_w[9]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[9]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>500 && x<750 && y<200) {
if(czy_w[2]==1){
czy_w[2]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[2]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>500 && x<750 && y>200 && y<400) {
if(czy_w[6]==1){
czy_w[6]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[6]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>500 && x<750 && y>400 && y<600) {
if(czy_w[10]==1){
czy_w[10]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[10]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>750 && x<1000 && y<200) {
if(czy_w[3]==1){
czy_w[3]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[3]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>750 && x<1000 && y>200 && y<400){
if(czy_w[7]==1){
czy_w[7]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[7]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>750 && x<1000 && y>400 && y<600) {
if(czy_w[11]==1){
czy_w[11]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[11]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
return false;
}
/**
* Funkcja służąca do odtworzenia dźwięku z pliku
* @param f plik dźwiękowy - obiekt klasy File
*/
public static synchronized void playSound(final File f){
new Thread(new Runnable(){
@Override
public void run() {
try{
Clip clip=AudioSystem.getClip();
AudioInputStream inputStream = AudioSystem.getAudioInputStream(f);
clip.open(inputStream);
clip.start();
}
catch(Exception e){
System.err.println(e.getMessage());
}
}
}).start();
}
} | /* zmienna określająca popraność działania */ | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package kingatan;
import java.io.File;
import java.util.Random;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
/**
* Klasa tworząca działania
* na różnych poziomach trudności
* @author DELL
*/
public class MathBubble {
/* działania w formie napisu, przygotowane do wyświetlenia */
public static String[] wynik = {"","","","","","","","","","","",""};
/* zmienna określająca popraność <SUF>*/
public static int czy_poprawne;
/* status działania: 0-poprawne, 1-niepoprawne, 2-kliknięte i jest za nie punkt, 3-kliknięte bez punktu */
public static int czy_w[];
/* zmienna reprezentująca liczbę wchodzącą w działanie */
public static int a;
/* zmienna reprezentująca liczbę wchodzącą w działanie */
public static int b;
/* zmienna obliczona jako wynik działania */
public static int suma;
/* zmienna obliczona jako wynik działania */
public static int roznica;
/* zmienna obliczona jako wynik działania */
public static int iloczyn;
/* ilość poprawnych działań dla poziomu */
public static int ilosc_poprawnych=0;
/* ilość niepoprawnych działań dla poziomu */
public static int ilosc_niepoprawnych=0;
/* ilość punktów - ilość niepoprawnych działań w całej grze */
public static int suma_pkt;
/* współrzędna kliknięcia */
public static int x1=GamePanel.wspol1;
/* współrzędna kliknięcia */
public static int y2=GamePanel.wspol2;
/* ilość żyć w całej grze */
public static int ilosc_zyc=3;
/**
* Metoda losująca działania w zależności od poziomu gry
*/
public static void losuj(){
wynik = new String[12];
czy_w = new int [12];
for(int i=0;i<12;i++){
Random rand=new Random();
czy_poprawne=rand.nextInt(2);
if(GameStatus.level==1){
a=rand.nextInt(50)+1;
b=rand.nextInt(50)+1;
if(czy_poprawne==1){
suma=a+b;
ilosc_poprawnych++;
czy_w[i]=0;
}
else {
suma=a+b+rand.nextInt(20)+10;
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
else if(GameStatus.level==2){
a=rand.nextInt(50);
b=rand.nextInt(50);
if(czy_poprawne==1){
if(a>=b)roznica=a-b;
if (b>a) roznica=b-a;
ilosc_poprawnych++;
czy_w[i]=0;
}
else {
if(a>=b)roznica=a-b-(rand.nextInt(5)+5);
if (b>a) roznica=b-a-(rand.nextInt(5)+5);
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
else if(GameStatus.level==3){
a=rand.nextInt(20)+1;
b=rand.nextInt(10)+1;
if(czy_poprawne==1){
iloczyn=a*b;
ilosc_poprawnych++;
czy_w[i]=0;
}
else{
iloczyn=(a*b)+rand.nextInt(5)+2;
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
else if(GameStatus.level==4){
a=rand.nextInt(200)+1;
b=rand.nextInt(100)+1;
if(czy_poprawne==1){
suma=a+b;
ilosc_poprawnych++;
czy_w[i]=0;
}
else{
suma=(a+b)+rand.nextInt(5)+2;
ilosc_niepoprawnych++;
suma_pkt++;
czy_w[i]=1;
}
}
String str1=Integer.toString(a);
String str2=Integer.toString(b);
if(GameStatus.level==1){
String str3=Integer.toString(suma);
wynik[i]=str1+" + "+str2+ " = "+str3;
}
if(GameStatus.level==2){
if(a>=b){
String str3=Integer.toString(roznica);
wynik[i]=str1+" - "+str2+ " = "+str3;
}
else{
String str3=Integer.toString(roznica);
wynik[i]=str2+" - "+str1+ " = "+str3;
}
}
if(GameStatus.level==3){
String str3=Integer.toString(iloczyn);
wynik[i]=str1+" * "+str2+ " = "+str3;
}
if(GameStatus.level==4){
String str3=Integer.toString(suma);
wynik[i]=str1+" + "+str2+ " = "+str3;
}
}
}
/**
* metoda sprawdzająca czy kliknięty jest wyłącznie obszar bąbelka
* @param x współrzędna kliknięcia
* @param y współrzędna kliknięcia
* @return 1 gdy tak, 0 gdy nie
*/
public static boolean containsPoint(int x, int y) {
for(int i=0;i<12;i++){
for(y2=30;y2<900;y2=(y2+GamePanel.odleglosc)){
for(x1=100;x1<900;x1=(x1+GamePanel.odleglosc)){
if(x>=x1 && x<(x1+150)){
if(y>=y2 && y<(y2+150)){
return true;
}
}
}
}
}
return false;
}
/**
* metoda sprawdzająca czy kliknięto poprawne czy niepoprawne działanie
* zmieniająca parametr czy_w, dodająca punkty w zależności od kliknięcia
* odtwarzająca dźwięk w zależności czy punkt był przyznany czy nie
* @param x współrzędna kliknięcia
* @param y współrzędna kliknięcia
* @return 1 gdy przyznany punkt, 0 gdy nie
*/
public static boolean czy_wynik(int x, int y){
if(x<250 && y<200) {
if(czy_w[0]==1){
czy_w[0]=2;
playSound(new File("sounds/tap-crisp.aif"));
ilosc_niepoprawnych--;
return true;
}
else{
czy_w[0]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x<250 && y>200 && y<400) {
if(czy_w[4]==1){
czy_w[4]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[4]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x<250 && y>400 && y<600) {
if(czy_w[8]==1){
czy_w[8]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[8]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>250 && x<500 && y<200) {
if(czy_w[1]==1){
czy_w[1]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[1]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>250 && x<500 && y>200 && y<400) {
if(czy_w[5]==1){
czy_w[5]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[5]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>250 && x<500 && y>400 && y<600) {
if(czy_w[9]==1){
czy_w[9]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[9]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>500 && x<750 && y<200) {
if(czy_w[2]==1){
czy_w[2]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[2]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>500 && x<750 && y>200 && y<400) {
if(czy_w[6]==1){
czy_w[6]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[6]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>500 && x<750 && y>400 && y<600) {
if(czy_w[10]==1){
czy_w[10]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[10]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>750 && x<1000 && y<200) {
if(czy_w[3]==1){
czy_w[3]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[3]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>750 && x<1000 && y>200 && y<400){
if(czy_w[7]==1){
czy_w[7]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[7]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
else if (x>750 && x<1000 && y>400 && y<600) {
if(czy_w[11]==1){
czy_w[11]=2;
ilosc_niepoprawnych--;
playSound(new File("sounds/tap-crisp.aif"));
return true;
}
else{
czy_w[11]=3;
ilosc_zyc--;
playSound(new File("sounds/slide-magic.aif"));
}
}
return false;
}
/**
* Funkcja służąca do odtworzenia dźwięku z pliku
* @param f plik dźwiękowy - obiekt klasy File
*/
public static synchronized void playSound(final File f){
new Thread(new Runnable(){
@Override
public void run() {
try{
Clip clip=AudioSystem.getClip();
AudioInputStream inputStream = AudioSystem.getAudioInputStream(f);
clip.open(inputStream);
clip.start();
}
catch(Exception e){
System.err.println(e.getMessage());
}
}
}).start();
}
} | t |
3673_14 | ktoso/TravelingSalesman-NBP | 4,027 | Algorithms/src/pl/edu/netbeans/algorithms/genetic/Chromosom.java | /*
* Klasa reprezentująca chromosom w algorytmie ewolucyjnym
*/
package pl.edu.netbeans.algorithms.genetic;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Random;
import pl.edu.netbeans.algorithms.exception.WrongGraphTypeException;
import prefuse.data.Edge;
import prefuse.data.Graph;
/**
*
* @author bartek
*/
public class Chromosom extends LinkedList<Integer> implements Comparable<Chromosom> {
Random generator = new Random();
Graph graph;
/**
* Tworzymy chromosom wypiełniony numerami wezłów w losowej kolejnosci.
*
* @param length Ilość wezłów w grafie - długośc najdłużeszego cyklu hamiltona
*/
public Chromosom(int length, Graph g) {
this.graph = g;
for (int i = 0; i < length; ++i) {
add(-1);
}
}
public void create() throws WrongGraphTypeException {
create(false);
}
/**
* Utwórz nowy chromosom
* @param greedy Czy korzystać z algorytmu zachłannego przy tworzeniu chromosomu
* @throws WrongGraphTypeException
*/
public void create(boolean greedy) throws WrongGraphTypeException {
int length = size();
if (greedy) {
LinkedList<Integer> unused = new LinkedList<Integer>();
for (int i = 0; i < length; ++i) {
unused.add(i);
}
int start = generator.nextInt(length);
int it = 0;
set(it++, start);
unused.remove(start);
for (; it < length; it++) {
int closest = getClosestNeighbor(start, unused);
if (closest == -1) {
throw new WrongGraphTypeException("Graf został źle zbudowany");
}
set(it, closest);
unused.remove(Integer.valueOf(closest));
start = closest;
}
} else {
for (int i = 0; i < length; ++i) {
int num = generator.nextInt(length);
while (indexOf(num) != -1) {
num = generator.nextInt(length);
}
set(i, num);
}
}
}
/**
* Znajdź indeks danego miasta
* @param elem Szukane miasto
* @return Indeks danego miasta
*/
public int find(int elem) {
for (int i = 0; i < size(); ++i) {
if (get(i) == elem) {
return i;
}
}
return -1;
}
/**
* Krzyżowanie wg. wybranego wcześniej typu
* @param ch Drugi rodzic
* @param type Typ krzyżowania
* @return Para potomków
* @throws WrongGraphTypeException
*/
public ChromosomPair crossover(Chromosom ch, String type) throws WrongGraphTypeException {
if (type.equals("Heurystyczne")) {
return new ChromosomPair(this.heuristicCrossover(ch), ch.heuristicCrossover(this));
} else {
return OXcrossover(ch);
}
}
/**
* Krzyżowanie typu OX
* @param ch Drugi rodzic
* @return Para potomków
*/
public ChromosomPair OXcrossover(Chromosom ch) {
//Próba krzyżowania chromosomów o róznych długościach
if (size() != ch.size()) {
throw new RuntimeException("Niezgodnośc rozmiarów chromosomów");
}
int length = size();
//Tworzenie pustych dzieci
Chromosom child1 = new Chromosom(length, this.graph);
Chromosom child2 = new Chromosom(length, this.graph);
// Wybierz dwa losowe punkty przecięcia
int from = generator.nextInt(length);
int to = from + generator.nextInt(length - 1);
//Przenieś do dzieci miasta z pomiedzy punktów cięć
for (int i = from; i < to; ++i) {
child1.set(i, get(i));
child2.set(i, ch.get(i));
}
//Uzupełnij pozostałe pozycje
int ch1pos = to;
int ch2pos = to;
for (int i = 0; i < length; ++i) {
if (child1.indexOf(ch.get(to + i)) == -1) {
child1.set(ch1pos, ch.get(to + i));
++ch1pos;
}
if (child2.indexOf(get(to + i)) == -1) {
child2.set(ch2pos, get(to + i));
++ch2pos;
}
}
return new ChromosomPair(child1, child2);
}
/**
* Krzyżowanie heurystyczne
* @param ch Drugi rodzic
* @return Jeden potomek
* @throws WrongGraphTypeException
*/
public Chromosom heuristicCrossover(Chromosom ch) throws WrongGraphTypeException {
//Gdyby przypadkiem chcały się mutować osobniki z różnych symulacji
if (size() != ch.size()) {
throw new WrongGraphTypeException("Niezgodnośc rozmiarów chromosomów");
}
int length = size();
Chromosom child = new Chromosom(length, this.graph);
//Tworzę liste nie użytych jeszcze miast
LinkedList<Integer> unused = new LinkedList<Integer>();
for (int i = 0; i < length; ++i) {
unused.add(i);
}
//Wybieram losowo początek krzyżowania
int start = generator.nextInt(length);
int from = get(start);
int to1 = get(start + 1);
int to2 = ch.get(ch.find(from) + 1);
//Dodaje wartość na początek potomka i usuwiam miasto z "nie użytych"
child.set(0, from);
unused.remove(Integer.valueOf(from));
// System.out.println("--- Heurystyka ---");
//Pętla w celu uzupełnienia kolejnych genów potomka
for (int i = 1; i < length; ++i) {
int to;
//Pobieram długości krawędzi z wybranego miasta do kolejnego u obu rodziców
double ew1 = getEdgeWeight(from, to1);
double ew2 = ch.getEdgeWeight(from, to2);
if (ew1 < ew2) { //Jeśli ta wartość jest mniejsza u pierwszego rodzica
if (unused.contains(to1)) { //Jeśli nie jest użyta to ją wybieram
to = to1;
} else if (unused.contains(to2)) { //Jeśli którsza wartość jest użyta wybieram dłuższą
to = to2;
} else { //Jeśli i dłuższa jest użyta, wybieram najmniej oddaloną z pozostałych
to = getClosestNeighbor(from, unused);
}
} else { // Jeśli wartość jest mniejsza u drugiego z rodziców
if (unused.contains(to2)) { //Jeśli nie jest użyta to ją wybieram
to = to2;
} else if (unused.contains(to1)) { //Jeśli którsza wartość jest użyta wybieram dłuższą
to = to1;
} else { //Jeśli i dłuższa jest użyta, wybieram najmniej oddaloną z pozostałych
to = getClosestNeighbor(from, unused);
}
}
// Testowanie metody heurystycznej - może sie przydać
// System.out.println("from: " + from + " | to1: " + to1 + " | to2: " + to2 + " | to: " + to + " | ew1: " + ew1 + " | ew2: " + ew2);
// Iterator<Integer> iter = unused.iterator();
// while(iter.hasNext()) {
// System.out.print(iter.next() + ", ");
// }
// System.out.println();
//Dodaje miasto do potomka i usuwam z "nie użytych"
child.set(i, to);
unused.remove(Integer.valueOf(to));
//Przesuwam wskaźniki:
// /from/ na ostatnie miasto w potomku
from = to;
// /to1/ na kolejne miasto u pierwszego rodzica
to1 = get(find(to) + 1);
// /to2/ na kolejne miasto u drugiego rodzica
to2 = ch.get(ch.find(to) + 1);
}
// System.out.println(child);
// System.out.println();
return child;
}
/**
* Funkcja mutująca dany chromosom przez zamiane dwóch miast ze sobą
* @param mutationSize liczba z przedziału (0, 1) określająca rozmiar mutacji
* @return Zmutowany chromosom
*/
public Chromosom mutation() {
int length = size();
Chromosom child = new Chromosom(length, this.graph);
for (int i = 0; i < length; ++i) {
child.set(i, get(i));
}
int from = generator.nextInt(length);
int with = from + generator.nextInt(length - 1);
int tmp = child.get(from);
child.set(from, child.get(with));
child.set(with, tmp);
return child;
}
@Override
public Integer get(int i) {
return super.get(i % size());
}
@Override
public Integer set(int index, Integer element) {
return super.set(index % size(), element);
}
/**
* Reprezentacja chromosomu w postaci napisu
* @return Napis w postaci: miasto1 -> miasto2 ... miaston (fitness)
*/
@Override
public String toString() {
StringBuilder b = new StringBuilder();
for (Integer i : this) {
try {
b.append(this.graph.getNode(i).get("name"));
} catch (ArrayIndexOutOfBoundsException ex) {
b.append(" null ");
}
// b.append(i).append(", ");
if (i != this.getLast()) {
b.append(" -> ");
}
}
b.append(" (" + fitness() + ")");
return b.toString();
}
/**
* Pobiera wagę sciezki i-tego miasta do masta i+1-ego
* @param i numer miasta w tablicy porządku
* @return waga scieżki do kolejnego miasta
*/
private double getEdgeWeight(int i) {
if (i < 0) {
return Double.MAX_VALUE;
}
int source = get(i);
int target = get(i + 1);
return getEdgeWeight(source, target);
}
/**
* Wartość krawędzi miedzy podanymi miastami (krawędź powinna istnieć zawsze - operujemy na klikach)
* @param s Miasto źródłowe
* @param t Miasto docelowe
* @return Wartość ścieżki
*/
private double getEdgeWeight(int s, int t) {
if (s < 0 || s > size() || t < 0 || t > size()) {
return Double.MAX_VALUE;
}
Edge e = graph.getEdge(graph.getEdge(s, t));
if (e == null) {
e = graph.getEdge(graph.getEdge(t, s));
}
if (e != null) {
return e.getDouble("weight");
}
return 0;
}
/**
* Dopasowanie chromosomu - długość trasy przezeń reprezentowanej
* @return Dopasowanie chromosomu
*/
public double fitness() {
double f = 0;
for (int i = 0; i < size(); ++i) {
f += getEdgeWeight(i);
}
return f;
}
/**
* Ustawia scieżce reprezentowanej przez siebie parametr marked=mark
* @param mark wartosc parametru marked dla reprezentowanej scieżki
*/
public void mark(int mark) {
for (int i = 0; i < size(); ++i) {
int source = get(i);
int target = get(i + 1);
Edge e = this.graph.getEdge(this.graph.getEdge(source, target));
if (e == null) {
e = this.graph.getEdge(this.graph.getEdge(target, source));
}
if (e != null) {
e.setInt("marked", mark);
}
}
}
public int compareTo(Chromosom ch) {
return (int) (fitness() - ch.fitness());
}
public boolean equals(Chromosom ch) {
for (int i = 0; i < size(); ++i) {
if (get(i) != ch.get(i)) {
return false;
}
}
return true;
}
/**
* Znajdź najbliższego sąsiada danego miasta spośród nie użytych miast
* @param from Miasta dla którego szukamy najbliższego sąsiada
* @param unused Lista dostępnych miast (dziedzina poszukiwań)
* @return Najbliższe miasto (-1 gdy nie znaleziono)
*/
private int getClosestNeighbor(int from, LinkedList<Integer> unused) {
if (unused.isEmpty()) {
return -1;
}
int closest = unused.getFirst();
double min = getEdgeWeight(from, closest);
Iterator<Integer> it = unused.iterator();
while (it.hasNext()) {
int act = it.next();
if (getEdgeWeight(from, act) < getEdgeWeight(from, closest)) {
min = getEdgeWeight(from, act);
closest = act;
}
}
return closest;
}
}
| //Tworzę liste nie użytych jeszcze miast | /*
* Klasa reprezentująca chromosom w algorytmie ewolucyjnym
*/
package pl.edu.netbeans.algorithms.genetic;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Random;
import pl.edu.netbeans.algorithms.exception.WrongGraphTypeException;
import prefuse.data.Edge;
import prefuse.data.Graph;
/**
*
* @author bartek
*/
public class Chromosom extends LinkedList<Integer> implements Comparable<Chromosom> {
Random generator = new Random();
Graph graph;
/**
* Tworzymy chromosom wypiełniony numerami wezłów w losowej kolejnosci.
*
* @param length Ilość wezłów w grafie - długośc najdłużeszego cyklu hamiltona
*/
public Chromosom(int length, Graph g) {
this.graph = g;
for (int i = 0; i < length; ++i) {
add(-1);
}
}
public void create() throws WrongGraphTypeException {
create(false);
}
/**
* Utwórz nowy chromosom
* @param greedy Czy korzystać z algorytmu zachłannego przy tworzeniu chromosomu
* @throws WrongGraphTypeException
*/
public void create(boolean greedy) throws WrongGraphTypeException {
int length = size();
if (greedy) {
LinkedList<Integer> unused = new LinkedList<Integer>();
for (int i = 0; i < length; ++i) {
unused.add(i);
}
int start = generator.nextInt(length);
int it = 0;
set(it++, start);
unused.remove(start);
for (; it < length; it++) {
int closest = getClosestNeighbor(start, unused);
if (closest == -1) {
throw new WrongGraphTypeException("Graf został źle zbudowany");
}
set(it, closest);
unused.remove(Integer.valueOf(closest));
start = closest;
}
} else {
for (int i = 0; i < length; ++i) {
int num = generator.nextInt(length);
while (indexOf(num) != -1) {
num = generator.nextInt(length);
}
set(i, num);
}
}
}
/**
* Znajdź indeks danego miasta
* @param elem Szukane miasto
* @return Indeks danego miasta
*/
public int find(int elem) {
for (int i = 0; i < size(); ++i) {
if (get(i) == elem) {
return i;
}
}
return -1;
}
/**
* Krzyżowanie wg. wybranego wcześniej typu
* @param ch Drugi rodzic
* @param type Typ krzyżowania
* @return Para potomków
* @throws WrongGraphTypeException
*/
public ChromosomPair crossover(Chromosom ch, String type) throws WrongGraphTypeException {
if (type.equals("Heurystyczne")) {
return new ChromosomPair(this.heuristicCrossover(ch), ch.heuristicCrossover(this));
} else {
return OXcrossover(ch);
}
}
/**
* Krzyżowanie typu OX
* @param ch Drugi rodzic
* @return Para potomków
*/
public ChromosomPair OXcrossover(Chromosom ch) {
//Próba krzyżowania chromosomów o róznych długościach
if (size() != ch.size()) {
throw new RuntimeException("Niezgodnośc rozmiarów chromosomów");
}
int length = size();
//Tworzenie pustych dzieci
Chromosom child1 = new Chromosom(length, this.graph);
Chromosom child2 = new Chromosom(length, this.graph);
// Wybierz dwa losowe punkty przecięcia
int from = generator.nextInt(length);
int to = from + generator.nextInt(length - 1);
//Przenieś do dzieci miasta z pomiedzy punktów cięć
for (int i = from; i < to; ++i) {
child1.set(i, get(i));
child2.set(i, ch.get(i));
}
//Uzupełnij pozostałe pozycje
int ch1pos = to;
int ch2pos = to;
for (int i = 0; i < length; ++i) {
if (child1.indexOf(ch.get(to + i)) == -1) {
child1.set(ch1pos, ch.get(to + i));
++ch1pos;
}
if (child2.indexOf(get(to + i)) == -1) {
child2.set(ch2pos, get(to + i));
++ch2pos;
}
}
return new ChromosomPair(child1, child2);
}
/**
* Krzyżowanie heurystyczne
* @param ch Drugi rodzic
* @return Jeden potomek
* @throws WrongGraphTypeException
*/
public Chromosom heuristicCrossover(Chromosom ch) throws WrongGraphTypeException {
//Gdyby przypadkiem chcały się mutować osobniki z różnych symulacji
if (size() != ch.size()) {
throw new WrongGraphTypeException("Niezgodnośc rozmiarów chromosomów");
}
int length = size();
Chromosom child = new Chromosom(length, this.graph);
//Tworzę liste <SUF>
LinkedList<Integer> unused = new LinkedList<Integer>();
for (int i = 0; i < length; ++i) {
unused.add(i);
}
//Wybieram losowo początek krzyżowania
int start = generator.nextInt(length);
int from = get(start);
int to1 = get(start + 1);
int to2 = ch.get(ch.find(from) + 1);
//Dodaje wartość na początek potomka i usuwiam miasto z "nie użytych"
child.set(0, from);
unused.remove(Integer.valueOf(from));
// System.out.println("--- Heurystyka ---");
//Pętla w celu uzupełnienia kolejnych genów potomka
for (int i = 1; i < length; ++i) {
int to;
//Pobieram długości krawędzi z wybranego miasta do kolejnego u obu rodziców
double ew1 = getEdgeWeight(from, to1);
double ew2 = ch.getEdgeWeight(from, to2);
if (ew1 < ew2) { //Jeśli ta wartość jest mniejsza u pierwszego rodzica
if (unused.contains(to1)) { //Jeśli nie jest użyta to ją wybieram
to = to1;
} else if (unused.contains(to2)) { //Jeśli którsza wartość jest użyta wybieram dłuższą
to = to2;
} else { //Jeśli i dłuższa jest użyta, wybieram najmniej oddaloną z pozostałych
to = getClosestNeighbor(from, unused);
}
} else { // Jeśli wartość jest mniejsza u drugiego z rodziców
if (unused.contains(to2)) { //Jeśli nie jest użyta to ją wybieram
to = to2;
} else if (unused.contains(to1)) { //Jeśli którsza wartość jest użyta wybieram dłuższą
to = to1;
} else { //Jeśli i dłuższa jest użyta, wybieram najmniej oddaloną z pozostałych
to = getClosestNeighbor(from, unused);
}
}
// Testowanie metody heurystycznej - może sie przydać
// System.out.println("from: " + from + " | to1: " + to1 + " | to2: " + to2 + " | to: " + to + " | ew1: " + ew1 + " | ew2: " + ew2);
// Iterator<Integer> iter = unused.iterator();
// while(iter.hasNext()) {
// System.out.print(iter.next() + ", ");
// }
// System.out.println();
//Dodaje miasto do potomka i usuwam z "nie użytych"
child.set(i, to);
unused.remove(Integer.valueOf(to));
//Przesuwam wskaźniki:
// /from/ na ostatnie miasto w potomku
from = to;
// /to1/ na kolejne miasto u pierwszego rodzica
to1 = get(find(to) + 1);
// /to2/ na kolejne miasto u drugiego rodzica
to2 = ch.get(ch.find(to) + 1);
}
// System.out.println(child);
// System.out.println();
return child;
}
/**
* Funkcja mutująca dany chromosom przez zamiane dwóch miast ze sobą
* @param mutationSize liczba z przedziału (0, 1) określająca rozmiar mutacji
* @return Zmutowany chromosom
*/
public Chromosom mutation() {
int length = size();
Chromosom child = new Chromosom(length, this.graph);
for (int i = 0; i < length; ++i) {
child.set(i, get(i));
}
int from = generator.nextInt(length);
int with = from + generator.nextInt(length - 1);
int tmp = child.get(from);
child.set(from, child.get(with));
child.set(with, tmp);
return child;
}
@Override
public Integer get(int i) {
return super.get(i % size());
}
@Override
public Integer set(int index, Integer element) {
return super.set(index % size(), element);
}
/**
* Reprezentacja chromosomu w postaci napisu
* @return Napis w postaci: miasto1 -> miasto2 ... miaston (fitness)
*/
@Override
public String toString() {
StringBuilder b = new StringBuilder();
for (Integer i : this) {
try {
b.append(this.graph.getNode(i).get("name"));
} catch (ArrayIndexOutOfBoundsException ex) {
b.append(" null ");
}
// b.append(i).append(", ");
if (i != this.getLast()) {
b.append(" -> ");
}
}
b.append(" (" + fitness() + ")");
return b.toString();
}
/**
* Pobiera wagę sciezki i-tego miasta do masta i+1-ego
* @param i numer miasta w tablicy porządku
* @return waga scieżki do kolejnego miasta
*/
private double getEdgeWeight(int i) {
if (i < 0) {
return Double.MAX_VALUE;
}
int source = get(i);
int target = get(i + 1);
return getEdgeWeight(source, target);
}
/**
* Wartość krawędzi miedzy podanymi miastami (krawędź powinna istnieć zawsze - operujemy na klikach)
* @param s Miasto źródłowe
* @param t Miasto docelowe
* @return Wartość ścieżki
*/
private double getEdgeWeight(int s, int t) {
if (s < 0 || s > size() || t < 0 || t > size()) {
return Double.MAX_VALUE;
}
Edge e = graph.getEdge(graph.getEdge(s, t));
if (e == null) {
e = graph.getEdge(graph.getEdge(t, s));
}
if (e != null) {
return e.getDouble("weight");
}
return 0;
}
/**
* Dopasowanie chromosomu - długość trasy przezeń reprezentowanej
* @return Dopasowanie chromosomu
*/
public double fitness() {
double f = 0;
for (int i = 0; i < size(); ++i) {
f += getEdgeWeight(i);
}
return f;
}
/**
* Ustawia scieżce reprezentowanej przez siebie parametr marked=mark
* @param mark wartosc parametru marked dla reprezentowanej scieżki
*/
public void mark(int mark) {
for (int i = 0; i < size(); ++i) {
int source = get(i);
int target = get(i + 1);
Edge e = this.graph.getEdge(this.graph.getEdge(source, target));
if (e == null) {
e = this.graph.getEdge(this.graph.getEdge(target, source));
}
if (e != null) {
e.setInt("marked", mark);
}
}
}
public int compareTo(Chromosom ch) {
return (int) (fitness() - ch.fitness());
}
public boolean equals(Chromosom ch) {
for (int i = 0; i < size(); ++i) {
if (get(i) != ch.get(i)) {
return false;
}
}
return true;
}
/**
* Znajdź najbliższego sąsiada danego miasta spośród nie użytych miast
* @param from Miasta dla którego szukamy najbliższego sąsiada
* @param unused Lista dostępnych miast (dziedzina poszukiwań)
* @return Najbliższe miasto (-1 gdy nie znaleziono)
*/
private int getClosestNeighbor(int from, LinkedList<Integer> unused) {
if (unused.isEmpty()) {
return -1;
}
int closest = unused.getFirst();
double min = getEdgeWeight(from, closest);
Iterator<Integer> it = unused.iterator();
while (it.hasNext()) {
int act = it.next();
if (getEdgeWeight(from, act) < getEdgeWeight(from, closest)) {
min = getEdgeWeight(from, act);
closest = act;
}
}
return closest;
}
}
| t |
5930_2 | kuba3351/KultURalia | 1,051 | app/src/main/java/pl/edu/ur/kulturalia/Intro.java | package pl.edu.ur.kulturalia;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.support.v4.app.NotificationCompat;
import android.support.v7.app.AppCompatActivity;
import android.view.MotionEvent;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.Toast;
public class Intro extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
//Notyfikacja:
Intent intent;
PendingIntent pIntent;
Context context = getApplicationContext();
intent = new Intent(context, Harmonogram.class);
pIntent = PendingIntent.getActivity(context, 1, intent, 0);
NotificationCompat.Builder mBuilder;
mBuilder = new NotificationCompat.Builder(getApplicationContext());
mBuilder.setSmallIcon(R.drawable.logourz);
mBuilder.setContentTitle("KultURalia");
mBuilder.setContentText("Zobacz co przygotowaliśmy dzisiaj dla Ciebie!");
mBuilder.build();
Bitmap largeIcon = BitmapFactory.decodeResource(getResources(),R.drawable.logourz);
mBuilder.setLargeIcon(largeIcon);
mBuilder.addAction(R.drawable.ic_kulturalia,"Zobacz więcej", pIntent );
mBuilder.setAutoCancel(true);
int mNotificationId = 001;
NotificationManager mNotifyMgr = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
mNotifyMgr.notify(mNotificationId,mBuilder.build());
//Powiadomienie, które pojawia się po włączeniu aplikacji.
super.onCreate(savedInstanceState);
this.getSupportActionBar().hide(); //ukrywamy górny pasek tytułu
setContentView(R.layout.intro);
Runnable runnable = new Runnable() { //robię nowy wątek który po pewnym czasie wystartuje menu
@Override
public void run() {
try {
ImageView logo = (ImageView) findViewById(R.id.logo);
ImageView logo_ssur = (ImageView) findViewById(R.id.logo_ssur);
ImageView logo_urz = (ImageView) findViewById(R.id.logo_urz);
Animation FadeInAnimation = AnimationUtils.loadAnimation(Intro.this, R.anim.fade_logo);
Animation FadeInAnimation2 = AnimationUtils.loadAnimation(Intro.this, R.anim.fade_bottom_logo);
logo.startAnimation(FadeInAnimation);
logo_ssur.startAnimation(FadeInAnimation2);
logo_urz.startAnimation(FadeInAnimation2);
Thread.sleep(4500); //opóźnienie startu menu w milisekundach
}
catch(Exception e)
{
Toast.makeText(getApplicationContext(),e.toString(), Toast.LENGTH_LONG).show();
}
Intent intent = new Intent(getApplicationContext(), MainActivity.class); //1
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); //2
getApplicationContext().startActivity(intent); //3
//1 2 3 przechodzimy do menu głównego
finish();
}
};
Thread thread = new Thread(runnable); //4
thread.start(); //5
//4 5 robię nowy wątek i startuję go
}
@Override
public boolean onTouchEvent(MotionEvent e) {
Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
getApplicationContext().startActivity(intent);
finish();
return true;
}
}
| //robię nowy wątek który po pewnym czasie wystartuje menu | package pl.edu.ur.kulturalia;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.support.v4.app.NotificationCompat;
import android.support.v7.app.AppCompatActivity;
import android.view.MotionEvent;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.Toast;
public class Intro extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
//Notyfikacja:
Intent intent;
PendingIntent pIntent;
Context context = getApplicationContext();
intent = new Intent(context, Harmonogram.class);
pIntent = PendingIntent.getActivity(context, 1, intent, 0);
NotificationCompat.Builder mBuilder;
mBuilder = new NotificationCompat.Builder(getApplicationContext());
mBuilder.setSmallIcon(R.drawable.logourz);
mBuilder.setContentTitle("KultURalia");
mBuilder.setContentText("Zobacz co przygotowaliśmy dzisiaj dla Ciebie!");
mBuilder.build();
Bitmap largeIcon = BitmapFactory.decodeResource(getResources(),R.drawable.logourz);
mBuilder.setLargeIcon(largeIcon);
mBuilder.addAction(R.drawable.ic_kulturalia,"Zobacz więcej", pIntent );
mBuilder.setAutoCancel(true);
int mNotificationId = 001;
NotificationManager mNotifyMgr = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
mNotifyMgr.notify(mNotificationId,mBuilder.build());
//Powiadomienie, które pojawia się po włączeniu aplikacji.
super.onCreate(savedInstanceState);
this.getSupportActionBar().hide(); //ukrywamy górny pasek tytułu
setContentView(R.layout.intro);
Runnable runnable = new Runnable() { //robię nowy <SUF>
@Override
public void run() {
try {
ImageView logo = (ImageView) findViewById(R.id.logo);
ImageView logo_ssur = (ImageView) findViewById(R.id.logo_ssur);
ImageView logo_urz = (ImageView) findViewById(R.id.logo_urz);
Animation FadeInAnimation = AnimationUtils.loadAnimation(Intro.this, R.anim.fade_logo);
Animation FadeInAnimation2 = AnimationUtils.loadAnimation(Intro.this, R.anim.fade_bottom_logo);
logo.startAnimation(FadeInAnimation);
logo_ssur.startAnimation(FadeInAnimation2);
logo_urz.startAnimation(FadeInAnimation2);
Thread.sleep(4500); //opóźnienie startu menu w milisekundach
}
catch(Exception e)
{
Toast.makeText(getApplicationContext(),e.toString(), Toast.LENGTH_LONG).show();
}
Intent intent = new Intent(getApplicationContext(), MainActivity.class); //1
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); //2
getApplicationContext().startActivity(intent); //3
//1 2 3 przechodzimy do menu głównego
finish();
}
};
Thread thread = new Thread(runnable); //4
thread.start(); //5
//4 5 robię nowy wątek i startuję go
}
@Override
public boolean onTouchEvent(MotionEvent e) {
Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
getApplicationContext().startActivity(intent);
finish();
return true;
}
}
| t |
3700_4 | kubahamerlik/hangman | 543 | RandomWord.java | import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Random;
import java.io.IOException;
import java.util.Scanner;
public class RandomWord {
private static boolean correct;
private char diff;
Scanner skaner = new Scanner(System.in);
public RandomWord(char difficulty) {
while((difficulty != 'E') && (difficulty != 'M') && (difficulty != 'H')){
System.out.println("WPROWADŹ POZIOM TRUDNOŚCI JESZCZE RAZ!");
difficulty = skaner.next().charAt(0);
}
diff = difficulty;
}
public String randomword() throws IOException {
String word = switch (diff) {
case 'E' -> randomLineFromFile("easy");
case 'M' -> randomLineFromFile("medium");
case 'H' -> randomLineFromFile("hard");
default -> null;
};
return word;
}
public String randomLineFromFile(String filename) throws IOException{
BufferedReader reader = new BufferedReader(new FileReader(filename));
int lineCount = 0;
Random random = new Random();
// Zliczanie liczby linii w pliku
while (reader.readLine() != null) {
lineCount++;
}
// Losowanie liczby od 1 do liczby linii w pliku
int randomLineNumber = random.nextInt(lineCount) + 1;
// Ponowne otwarcie pliku do odczytu
reader.close();
reader = new BufferedReader(new FileReader(filename));
// Przejście przez plik i zatrzymanie się na losowej linii
String line;
int currentLine = 0;
while ((line = reader.readLine()) != null) {
currentLine++;
if (currentLine == randomLineNumber) {
reader.close();
return line;
}
}
// Jeśli np. plik był pusty
reader.close();
return null;
}
}
| // Jeśli np. plik był pusty | import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Random;
import java.io.IOException;
import java.util.Scanner;
public class RandomWord {
private static boolean correct;
private char diff;
Scanner skaner = new Scanner(System.in);
public RandomWord(char difficulty) {
while((difficulty != 'E') && (difficulty != 'M') && (difficulty != 'H')){
System.out.println("WPROWADŹ POZIOM TRUDNOŚCI JESZCZE RAZ!");
difficulty = skaner.next().charAt(0);
}
diff = difficulty;
}
public String randomword() throws IOException {
String word = switch (diff) {
case 'E' -> randomLineFromFile("easy");
case 'M' -> randomLineFromFile("medium");
case 'H' -> randomLineFromFile("hard");
default -> null;
};
return word;
}
public String randomLineFromFile(String filename) throws IOException{
BufferedReader reader = new BufferedReader(new FileReader(filename));
int lineCount = 0;
Random random = new Random();
// Zliczanie liczby linii w pliku
while (reader.readLine() != null) {
lineCount++;
}
// Losowanie liczby od 1 do liczby linii w pliku
int randomLineNumber = random.nextInt(lineCount) + 1;
// Ponowne otwarcie pliku do odczytu
reader.close();
reader = new BufferedReader(new FileReader(filename));
// Przejście przez plik i zatrzymanie się na losowej linii
String line;
int currentLine = 0;
while ((line = reader.readLine()) != null) {
currentLine++;
if (currentLine == randomLineNumber) {
reader.close();
return line;
}
}
// Jeśli np. <SUF>
reader.close();
return null;
}
}
| t |
3499_6 | kubukoz/java-fast-workshop | 403 | src/main/java/com/kubukoz/fast/Anatomia.java | //pakiet
package com.kubukoz.fast;
/*importy - "include once"*/
import java.util.Arrays;
import java.util.List;
//to jest komentarz jednoliniowy
/*
to wieloliniowy
*/
/**
* To komentarz dokumentacji - javadoc
* @author kubukoz
* @since 1.0
* Publiczna klasa
* - tylko jedna w pliku
* - jeśli plik ma być uruchamialny to musi mieć metodę main (jak niżej)
*/
public class Anatomia {
//tu moga byc deklaracje zmiennych (także z przypisaniem), ale statementy typu przypisanie, pętla, if już nie:
int age = 19;
int lel;
// lel = 5; //błąd kompilacji
//Statyczna i publiczna metoda main
public static void main(String[] args) {
//statementy
//stała
final List<Integer> ints = Arrays.asList(1, 2, 3, 4);
//pętla to też statement
for (int i = 0; i < ints.size(); i++) {
//zmienna
int j = i + 1;
System.out.println("Element: " + i + ", element + 1: " + j);
}
System.exit(0);
}
}
/*Inne klasy - o tym później*/ | //Statyczna i publiczna metoda main | //pakiet
package com.kubukoz.fast;
/*importy - "include once"*/
import java.util.Arrays;
import java.util.List;
//to jest komentarz jednoliniowy
/*
to wieloliniowy
*/
/**
* To komentarz dokumentacji - javadoc
* @author kubukoz
* @since 1.0
* Publiczna klasa
* - tylko jedna w pliku
* - jeśli plik ma być uruchamialny to musi mieć metodę main (jak niżej)
*/
public class Anatomia {
//tu moga byc deklaracje zmiennych (także z przypisaniem), ale statementy typu przypisanie, pętla, if już nie:
int age = 19;
int lel;
// lel = 5; //błąd kompilacji
//Statyczna i <SUF>
public static void main(String[] args) {
//statementy
//stała
final List<Integer> ints = Arrays.asList(1, 2, 3, 4);
//pętla to też statement
for (int i = 0; i < ints.size(); i++) {
//zmienna
int j = i + 1;
System.out.println("Element: " + i + ", element + 1: " + j);
}
System.exit(0);
}
}
/*Inne klasy - o tym później*/ | t |
4604_0 | kubw19/Sokoban | 1,653 | src/com/Level.java | package com;
import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import fIgures.*;
/**
* Klasa opisująca poziom gry
*/
public class Level {
private int winCondition;
private Vector2d startingPoint;
private ArrayList<Square> objects;
private Game game;
private String id;
/**
* konstruktor Level tworzący obiekt klasy Level
* @param game panel gry w którym ma być wyświetlany poziom
* @param id numer poziomu używany jako nazwa pliku (id+".xtx")
* @throws IOException
*/
public Level(Game game, String id)throws IOException{
this.id = id;
objects = new ArrayList<>();
this.game = game;
winCondition=0;
this.build();
}
/**
* konstruktor Level tworzący obiekt klasy Level
* @param game panel gry w którym ma być wyświetlany poziom
*/
public Level(Game game){
this.game=game;
winCondition=0;
objects = new ArrayList<>();
startingPoint=Game.getNormalizedPosition(0,0);
}
/**
* metoda dodająca obiekty do listy objects poziomu
* obiekty dodawane są z pliku (id+".txt")
* @throws IOException
*/
private void build() throws IOException{
BufferedReader reader;
reader = new BufferedReader(new FileReader("./levels/"+id + ".txt"));
String line;
line=reader.readLine();
String[] parts = line.split(";");
startingPoint=new Vector2d(Integer.valueOf(parts[0]), Integer.valueOf(parts[1]));
while((line =reader.readLine()) != null){
parts = line.split(";");
switch(parts[0]){
case "W":
objects.add(new Brick(game.getBrickSize(), new Vector2d(Integer.valueOf(parts[1]), Integer.valueOf(parts[2])),game));
break;
case "B":
objects.add(new Box(game.getBrickSize(), new Vector2d(Integer.valueOf(parts[1]), Integer.valueOf(parts[2])),game));
break;
case "T":
objects.add(new Target(game.getBrickSize(), new Vector2d(Integer.valueOf(parts[1]), Integer.valueOf(parts[2])),game));
winCondition++;
break;
}
}
}
/**
* zwraca liczbę skrzyń jaka musi być na polach Target żeby zakończyć poziom
* @return
*/
public int getWinCondition(){
return winCondition;
}
/**
* rysuje wszystkie obiekty poziomu
* @param gr
*/
public void draw(Graphics gr) {
for (Square square : objects) {
square.draw(gr);
}
}
/**
* @return startingPoint jako obiekt klasy Vector2d
*/
public Vector2d getStartingPoint(){
return startingPoint;
}
/**
*
* @return lista(ArrayList) obiektów należączych do danego poziomu
*/
public ArrayList<Square> getObjects(){return objects;}
/**
* dodanie elementu do listy objects poziomu
* @param square dodawany element
*/
public void addElement(Square square){
objects.add(square);
}
/**
* usuwa element o wskazanej pozycji
* @param position pozycja elementu który ma zostać usunięty
*/
public void removeElement(Vector2d position){
Square removed=null;
for(Square square:objects){
if(square.getX()==position.getX()&&square.getY()==position.getY())removed=square;
}
if(removed!=null)
objects.remove(removed);
}
/**
* ustawienie pozycji początkowej gracza
* @param position pozycja początkowa gracza
*/
public void setStartingPoint(Vector2d position){
startingPoint=position;
}
/**
* zapisanie poziomu do pliku o pierwszym wolnym indeksie
* ograniczenie liczby istniejących poziomów 100
*/
public void saveLevel(){
BufferedReader reader;
for(int i=1;i<100;i++) {
try {
reader = new BufferedReader(new FileReader("./levels/"+i + ".txt"));
try {reader.close(); } catch (IOException e1){}
} catch (FileNotFoundException e) {
try {
File file=new File("./levels/"+i+".txt");
file.createNewFile();
} catch (IOException e1) { }
BufferedWriter writer = null;
try { writer = new BufferedWriter(new FileWriter("./levels/"+i + ".txt")); } catch (IOException e1) { }
try { writer.write(startingPoint.getX()+";"+startingPoint.getY()); } catch (IOException e1) { }
for(Square square:objects){
try {
if(square instanceof Target){
writer.newLine();
writer.write("T;"+square.getX()+";"+square.getY());
}
}catch (IOException e1) { }
}
for(Square square:objects){
try {
if(square instanceof Brick){
writer.newLine();
writer.write("W;"+square.getX()+";"+square.getY());
}
}catch (IOException e1) { }
}
for(Square square:objects){
try {
if(square instanceof Box){
writer.newLine();
writer.write("B;"+square.getX()+";"+square.getY());
}
}catch (IOException e1) { }
}
try { writer.close(); } catch (IOException e1) { }
return;
}
}
}
}
| /**
* Klasa opisująca poziom gry
*/ | package com;
import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import fIgures.*;
/**
* Klasa opisująca poziom <SUF>*/
public class Level {
private int winCondition;
private Vector2d startingPoint;
private ArrayList<Square> objects;
private Game game;
private String id;
/**
* konstruktor Level tworzący obiekt klasy Level
* @param game panel gry w którym ma być wyświetlany poziom
* @param id numer poziomu używany jako nazwa pliku (id+".xtx")
* @throws IOException
*/
public Level(Game game, String id)throws IOException{
this.id = id;
objects = new ArrayList<>();
this.game = game;
winCondition=0;
this.build();
}
/**
* konstruktor Level tworzący obiekt klasy Level
* @param game panel gry w którym ma być wyświetlany poziom
*/
public Level(Game game){
this.game=game;
winCondition=0;
objects = new ArrayList<>();
startingPoint=Game.getNormalizedPosition(0,0);
}
/**
* metoda dodająca obiekty do listy objects poziomu
* obiekty dodawane są z pliku (id+".txt")
* @throws IOException
*/
private void build() throws IOException{
BufferedReader reader;
reader = new BufferedReader(new FileReader("./levels/"+id + ".txt"));
String line;
line=reader.readLine();
String[] parts = line.split(";");
startingPoint=new Vector2d(Integer.valueOf(parts[0]), Integer.valueOf(parts[1]));
while((line =reader.readLine()) != null){
parts = line.split(";");
switch(parts[0]){
case "W":
objects.add(new Brick(game.getBrickSize(), new Vector2d(Integer.valueOf(parts[1]), Integer.valueOf(parts[2])),game));
break;
case "B":
objects.add(new Box(game.getBrickSize(), new Vector2d(Integer.valueOf(parts[1]), Integer.valueOf(parts[2])),game));
break;
case "T":
objects.add(new Target(game.getBrickSize(), new Vector2d(Integer.valueOf(parts[1]), Integer.valueOf(parts[2])),game));
winCondition++;
break;
}
}
}
/**
* zwraca liczbę skrzyń jaka musi być na polach Target żeby zakończyć poziom
* @return
*/
public int getWinCondition(){
return winCondition;
}
/**
* rysuje wszystkie obiekty poziomu
* @param gr
*/
public void draw(Graphics gr) {
for (Square square : objects) {
square.draw(gr);
}
}
/**
* @return startingPoint jako obiekt klasy Vector2d
*/
public Vector2d getStartingPoint(){
return startingPoint;
}
/**
*
* @return lista(ArrayList) obiektów należączych do danego poziomu
*/
public ArrayList<Square> getObjects(){return objects;}
/**
* dodanie elementu do listy objects poziomu
* @param square dodawany element
*/
public void addElement(Square square){
objects.add(square);
}
/**
* usuwa element o wskazanej pozycji
* @param position pozycja elementu który ma zostać usunięty
*/
public void removeElement(Vector2d position){
Square removed=null;
for(Square square:objects){
if(square.getX()==position.getX()&&square.getY()==position.getY())removed=square;
}
if(removed!=null)
objects.remove(removed);
}
/**
* ustawienie pozycji początkowej gracza
* @param position pozycja początkowa gracza
*/
public void setStartingPoint(Vector2d position){
startingPoint=position;
}
/**
* zapisanie poziomu do pliku o pierwszym wolnym indeksie
* ograniczenie liczby istniejących poziomów 100
*/
public void saveLevel(){
BufferedReader reader;
for(int i=1;i<100;i++) {
try {
reader = new BufferedReader(new FileReader("./levels/"+i + ".txt"));
try {reader.close(); } catch (IOException e1){}
} catch (FileNotFoundException e) {
try {
File file=new File("./levels/"+i+".txt");
file.createNewFile();
} catch (IOException e1) { }
BufferedWriter writer = null;
try { writer = new BufferedWriter(new FileWriter("./levels/"+i + ".txt")); } catch (IOException e1) { }
try { writer.write(startingPoint.getX()+";"+startingPoint.getY()); } catch (IOException e1) { }
for(Square square:objects){
try {
if(square instanceof Target){
writer.newLine();
writer.write("T;"+square.getX()+";"+square.getY());
}
}catch (IOException e1) { }
}
for(Square square:objects){
try {
if(square instanceof Brick){
writer.newLine();
writer.write("W;"+square.getX()+";"+square.getY());
}
}catch (IOException e1) { }
}
for(Square square:objects){
try {
if(square instanceof Box){
writer.newLine();
writer.write("B;"+square.getX()+";"+square.getY());
}
}catch (IOException e1) { }
}
try { writer.close(); } catch (IOException e1) { }
return;
}
}
}
}
| t |
3689_3 | kukoz25/Jobtask | 893 | src/Wall.java | import java.util.*;
/* że interfejs CompositeBlock rozszerza interfejs Block i zawiera dodatkową metodę getBlocks().
To sugeruje, że bloki mogą być zagnieżdżone.
Oznacza to, że podczas przeszukiwania bloków musimy uwzględnić możliwość zagnieżdżenia bloków wewnątrz innych bloków.
Należy użyć rekurencji, aby poprawnie przeszukać wszystkie bloki.
*/
public class Wall implements Structure {
private List<Block> blocks;
public Wall(List<Block> blocks) { // konstruktor klasy, potrzebny, by kod działał
this.blocks = blocks;
}
@Override
public Optional<Block> findBlockByColor(String color) {
for (Block block : blocks) {
Optional<Block> result = findBlockByColor(block, color);
if (result.isPresent()) {
return result;
}
}
return Optional.empty();
}
/*
Prywatna metoda wyszukująca blok o podanym kolorze.
Przeszukuje rekurencyjnie bloki i bloki zagnieżdżone (jeśli istnieją).
*/
private Optional<Block> findBlockByColor(Block block, String color) {
if (block.getColor().equals(color)) {
return Optional.of(block);
}
if (block instanceof CompositeBlock) {
for (Block innerBlock : ((CompositeBlock) block).getBlocks()) {
Optional<Block> result = findBlockByColor(innerBlock, color);
if (result.isPresent()) {
return result;
}
}
}
return Optional.empty();
}
@Override
public List<Block> findBlocksByMaterial(String material) {
List<Block> result = new ArrayList<>();
for (Block block : blocks) {
findBlocksByMaterial(block, material, result);
}
return result;
}
/*
Prywatna metoda dodająca do listy wynikowej wszystkie bloki o podanym materiale.
Przeszukuje rekurencyjnie bloki i bloki zagnieżdżone (jeśli istnieją).
*/
private void findBlocksByMaterial(Block block, String material, List<Block> result) {
if (block.getMaterial().equals(material)) {
result.add(block);
}
if (block instanceof CompositeBlock) {
for (Block innerBlock : ((CompositeBlock) block).getBlocks()) {
findBlocksByMaterial(innerBlock, material, result);
}
}
}
@Override
public int count() {
int count = 0;
for (Block block : blocks) {
count += count(block);
}
return count;
}
//Prywatna metoda zliczająca wszystkie bloki w strukturze (łącznie z blokami zagnieżdżonymi, jeśli istnieją, ale nie wliczamy ich jako osobne bloki)
private int count(Block block) {
int count = 0;
if (block instanceof CompositeBlock) {
for (Block innerBlock : ((CompositeBlock) block).getBlocks()) {
count += count(innerBlock);
}
} else {
count = 1;
}
return count;
}
} | /*
Prywatna metoda dodająca do listy wynikowej wszystkie bloki o podanym materiale.
Przeszukuje rekurencyjnie bloki i bloki zagnieżdżone (jeśli istnieją).
*/ | import java.util.*;
/* że interfejs CompositeBlock rozszerza interfejs Block i zawiera dodatkową metodę getBlocks().
To sugeruje, że bloki mogą być zagnieżdżone.
Oznacza to, że podczas przeszukiwania bloków musimy uwzględnić możliwość zagnieżdżenia bloków wewnątrz innych bloków.
Należy użyć rekurencji, aby poprawnie przeszukać wszystkie bloki.
*/
public class Wall implements Structure {
private List<Block> blocks;
public Wall(List<Block> blocks) { // konstruktor klasy, potrzebny, by kod działał
this.blocks = blocks;
}
@Override
public Optional<Block> findBlockByColor(String color) {
for (Block block : blocks) {
Optional<Block> result = findBlockByColor(block, color);
if (result.isPresent()) {
return result;
}
}
return Optional.empty();
}
/*
Prywatna metoda wyszukująca blok o podanym kolorze.
Przeszukuje rekurencyjnie bloki i bloki zagnieżdżone (jeśli istnieją).
*/
private Optional<Block> findBlockByColor(Block block, String color) {
if (block.getColor().equals(color)) {
return Optional.of(block);
}
if (block instanceof CompositeBlock) {
for (Block innerBlock : ((CompositeBlock) block).getBlocks()) {
Optional<Block> result = findBlockByColor(innerBlock, color);
if (result.isPresent()) {
return result;
}
}
}
return Optional.empty();
}
@Override
public List<Block> findBlocksByMaterial(String material) {
List<Block> result = new ArrayList<>();
for (Block block : blocks) {
findBlocksByMaterial(block, material, result);
}
return result;
}
/*
Prywatna metoda dodająca <SUF>*/
private void findBlocksByMaterial(Block block, String material, List<Block> result) {
if (block.getMaterial().equals(material)) {
result.add(block);
}
if (block instanceof CompositeBlock) {
for (Block innerBlock : ((CompositeBlock) block).getBlocks()) {
findBlocksByMaterial(innerBlock, material, result);
}
}
}
@Override
public int count() {
int count = 0;
for (Block block : blocks) {
count += count(block);
}
return count;
}
//Prywatna metoda zliczająca wszystkie bloki w strukturze (łącznie z blokami zagnieżdżonymi, jeśli istnieją, ale nie wliczamy ich jako osobne bloki)
private int count(Block block) {
int count = 0;
if (block instanceof CompositeBlock) {
for (Block innerBlock : ((CompositeBlock) block).getBlocks()) {
count += count(innerBlock);
}
} else {
count = 1;
}
return count;
}
} | t |
10361_16 | kungpandafu/_studio_nagran | 2,719 | src/main/java/com/example/_studio_nagran/addProductsController.java | package com.example._studio_nagran;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.stage.FileChooser;
import java.io.File;
import java.net.URL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ResourceBundle;
public class addProductsController implements Initializable {
// inicjuje połączenie z bazą danych
private final DatabaseController conn = new DatabaseController();
// definiuje potrzebnę elementy GUI
@FXML
private GridPane formGrid;
@FXML
private ComboBox<String> comboBox;
private Button handleActionBtn;
private Button sendAvatarBtn;
private TextField authorname;
private TextField diskName;
private TextField songName;
@FXML
private ImageView userAvatar;
@FXML
private Label successerrlabel;
private File selectedFile = null;
// nadpisuje metodę initalize
@Override
public void initialize(URL url, ResourceBundle resourceBundle) {
// tworzę pole wyboru - którego wartość będzie definiowało - które elementy UI się pojawią wypełniam je zawartością oraz
// inicjuje potrzebne elementy.
comboBox.setItems(FXCollections.observableArrayList("Wybierz Opcję", "Autor", "Utwór", "Płyta"));
comboBox.getSelectionModel().selectFirst();
sendAvatarBtn = new Button();
sendAvatarBtn.setText("Prześlij Grafikę");
sendAvatarBtn.getStyleClass().add("sendAvatarBtn");
handleActionBtn = new Button();
handleActionBtn.getStyleClass().add("handleActionBtn");
authorname = new TextField();
authorname.getStyleClass().add("formfield");
handleActionBtn.setText("Dodaj rekord do Bazy Danych");
TextField diskName = new TextField();
TextField songName = new TextField();
diskName.getStyleClass().add("formfield");
songName.getStyleClass().add("formfield");
// dodaje EventListener do pola wyboru
comboBox.valueProperty().addListener(new ChangeListener<String>() {
// nadpisuję metodę Changed, która będzie wywoływana przy każdej zmianie w polu wyboru "ComboBox"
@Override
public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
// sprawdzam czy wybrana wartość to Autor, następnie wyświetlam odpowiednie elementy UI
if (newValue.equals("Autor")) {
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
authorname.setPromptText("Wprowadź nazwę Autora");
formGrid.add(authorname, 0, 0);
formGrid.add(sendAvatarBtn, 0, 1);
formGrid.add(handleActionBtn, 0, 2);
System.out.println("Selected value : " + newValue);
// sprawdzam czy wybrana wartość to Płyta, następnie wyświetlam odpowiednie elementy UI
} else if (newValue.equals("Płyta")) {
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
diskName.setPromptText("Wprowadź Nazwę Płyty");
// authorname = new TextField();
// authorname.setPromptText("Wprowadź Nazwę Autora");
System.out.println("Selected value : " + newValue);
formGrid.add(diskName, 0, 0);
// formGrid.add(authorname, 0,1);
formGrid.add(sendAvatarBtn, 0, 1);
formGrid.add(handleActionBtn, 0, 2);
//System.out.println("Selected value : " + newValue);
// sprawdzam czy wybrana wartość to Utwór, następnie wyświetlam odpowiednie elementy UI
} else if (newValue.equals("Utwór")) {
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
songName.setPromptText("Wprowadź Nazwę Utworu");
diskName.setPromptText("Podaj nazwę płyty - przypisz do płyty");
authorname.setPromptText("Podaj autora - przypisz autora do utworu");
// System.out.println("Selected value : " + newValue);
formGrid.add(songName, 0, 0);
formGrid.add(diskName, 0, 1);
formGrid.add(authorname, 0, 2);
formGrid.add(sendAvatarBtn, 0, 3);
formGrid.add(handleActionBtn, 0, 4);
}
else{
// Jeżeli wartość pola wyboru jest inna niż trzy powyższe tj. wynosi ona np. "Wybierz Opcję" - usuwam wszystkie elementy formularza.
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
}
}
});
//definiuje FileChooser, dzięki któremu będę mógł przesłać obraz do dalszego przetworzenia.
FileChooser fileChooser = new FileChooser();
fileChooser.getExtensionFilters().addAll(
new FileChooser.ExtensionFilter("JPG Files", "*.jpg"),
new FileChooser.ExtensionFilter("JPEG Files", "*.jpeg")
, new FileChooser.ExtensionFilter("PNG Files", "*.png")
);
sendAvatarBtn.setOnAction(e -> {
selectedFile = fileChooser.showOpenDialog(sendAvatarBtn.getScene().getWindow());
if (selectedFile != null) {
String imagepath = selectedFile.getPath();
System.out.println("file:" + imagepath);
System.out.println("file2:" + selectedFile);
Image image = new Image(imagepath);
// wyświetlam przesłany obrazek na podglądzie.
userAvatar.setImage(image);
}
});
// przypisuję Event Handler do przycisku
handleActionBtn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
// wywołuję kontroler odpowiedzialny za operacje zw. z przesłaniem danych do Bazy
handleNewProductsController performAction = new handleNewProductsController();
// sprawdzam wartość pola Wyboru, następnie na jej podstawię definiuje, którą metodę wywołać w handleNewProductsController.
if (comboBox.getValue() == "Autor") {
if (performAction.InsertAuthor(authorname.getText(), selectedFile)) {
// jeżeli sukces - wyświetlam stosowną informację
successerrlabel.setText("Operacja zakończona sukcesem!");
successerrlabel.setTextFill(Color.GREEN);
} else {
// jeżeli błąd - wyświetlam informacje, że wystąpił błąd.
successerrlabel.setText("Wystąpił Błąd! Sprawdź Czy Autor już nie występuje w bazie danych!");
successerrlabel.setTextFill(Color.RED);
}
// System.out.println(authorname.getText());
// System.out.println(selectedFile);
} else if (comboBox.getValue() == "Płyta") {
if (diskName.getText().isBlank() || selectedFile == null) {
successerrlabel.setText("Wystąpił Błąd! Nazwa Płyty nie może być pusta, grafika musi zostać wybrana!");
successerrlabel.setTextFill(Color.RED);
}
if (performAction.InsertDisk(diskName.getText(), selectedFile)) {
successerrlabel.setText("Operacja zakończona sukcesem!");
successerrlabel.setTextFill(Color.GREEN);
} else {
successerrlabel.setText("Wystąpił Błąd! Sprawdź Czy Płyta już nie występuje w bazie danych!");
successerrlabel.setTextFill(Color.RED);
}
} else if (comboBox.getValue() == "Utwór") {
if (songName.getText().isBlank() || selectedFile == null || authorname.getText().isBlank()) {
successerrlabel.setText("Wystąpił Błąd! Nazwa Utworu nie może być pusta, grafika musi zostać wybrana!");
successerrlabel.setTextFill(Color.RED);
}
if (performAction.InsertSongs(songName.getText(), selectedFile, authorname.getText(), diskName.getText())) {
successerrlabel.setText("Operacja zakończona sukcesem!");
successerrlabel.setTextFill(Color.GREEN);
} else {
successerrlabel.setText("Wystąpił Błąd! Sprawdź Czy Utwór już nie występuje w bazie danych!");
successerrlabel.setTextFill(Color.RED);
}
}
}
});
}
}
| // wyświetlam przesłany obrazek na podglądzie. | package com.example._studio_nagran;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.stage.FileChooser;
import java.io.File;
import java.net.URL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ResourceBundle;
public class addProductsController implements Initializable {
// inicjuje połączenie z bazą danych
private final DatabaseController conn = new DatabaseController();
// definiuje potrzebnę elementy GUI
@FXML
private GridPane formGrid;
@FXML
private ComboBox<String> comboBox;
private Button handleActionBtn;
private Button sendAvatarBtn;
private TextField authorname;
private TextField diskName;
private TextField songName;
@FXML
private ImageView userAvatar;
@FXML
private Label successerrlabel;
private File selectedFile = null;
// nadpisuje metodę initalize
@Override
public void initialize(URL url, ResourceBundle resourceBundle) {
// tworzę pole wyboru - którego wartość będzie definiowało - które elementy UI się pojawią wypełniam je zawartością oraz
// inicjuje potrzebne elementy.
comboBox.setItems(FXCollections.observableArrayList("Wybierz Opcję", "Autor", "Utwór", "Płyta"));
comboBox.getSelectionModel().selectFirst();
sendAvatarBtn = new Button();
sendAvatarBtn.setText("Prześlij Grafikę");
sendAvatarBtn.getStyleClass().add("sendAvatarBtn");
handleActionBtn = new Button();
handleActionBtn.getStyleClass().add("handleActionBtn");
authorname = new TextField();
authorname.getStyleClass().add("formfield");
handleActionBtn.setText("Dodaj rekord do Bazy Danych");
TextField diskName = new TextField();
TextField songName = new TextField();
diskName.getStyleClass().add("formfield");
songName.getStyleClass().add("formfield");
// dodaje EventListener do pola wyboru
comboBox.valueProperty().addListener(new ChangeListener<String>() {
// nadpisuję metodę Changed, która będzie wywoływana przy każdej zmianie w polu wyboru "ComboBox"
@Override
public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
// sprawdzam czy wybrana wartość to Autor, następnie wyświetlam odpowiednie elementy UI
if (newValue.equals("Autor")) {
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
authorname.setPromptText("Wprowadź nazwę Autora");
formGrid.add(authorname, 0, 0);
formGrid.add(sendAvatarBtn, 0, 1);
formGrid.add(handleActionBtn, 0, 2);
System.out.println("Selected value : " + newValue);
// sprawdzam czy wybrana wartość to Płyta, następnie wyświetlam odpowiednie elementy UI
} else if (newValue.equals("Płyta")) {
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
diskName.setPromptText("Wprowadź Nazwę Płyty");
// authorname = new TextField();
// authorname.setPromptText("Wprowadź Nazwę Autora");
System.out.println("Selected value : " + newValue);
formGrid.add(diskName, 0, 0);
// formGrid.add(authorname, 0,1);
formGrid.add(sendAvatarBtn, 0, 1);
formGrid.add(handleActionBtn, 0, 2);
//System.out.println("Selected value : " + newValue);
// sprawdzam czy wybrana wartość to Utwór, następnie wyświetlam odpowiednie elementy UI
} else if (newValue.equals("Utwór")) {
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
songName.setPromptText("Wprowadź Nazwę Utworu");
diskName.setPromptText("Podaj nazwę płyty - przypisz do płyty");
authorname.setPromptText("Podaj autora - przypisz autora do utworu");
// System.out.println("Selected value : " + newValue);
formGrid.add(songName, 0, 0);
formGrid.add(diskName, 0, 1);
formGrid.add(authorname, 0, 2);
formGrid.add(sendAvatarBtn, 0, 3);
formGrid.add(handleActionBtn, 0, 4);
}
else{
// Jeżeli wartość pola wyboru jest inna niż trzy powyższe tj. wynosi ona np. "Wybierz Opcję" - usuwam wszystkie elementy formularza.
formGrid.getChildren().retainAll(formGrid.getChildren().get(0));
}
}
});
//definiuje FileChooser, dzięki któremu będę mógł przesłać obraz do dalszego przetworzenia.
FileChooser fileChooser = new FileChooser();
fileChooser.getExtensionFilters().addAll(
new FileChooser.ExtensionFilter("JPG Files", "*.jpg"),
new FileChooser.ExtensionFilter("JPEG Files", "*.jpeg")
, new FileChooser.ExtensionFilter("PNG Files", "*.png")
);
sendAvatarBtn.setOnAction(e -> {
selectedFile = fileChooser.showOpenDialog(sendAvatarBtn.getScene().getWindow());
if (selectedFile != null) {
String imagepath = selectedFile.getPath();
System.out.println("file:" + imagepath);
System.out.println("file2:" + selectedFile);
Image image = new Image(imagepath);
// wyświetlam przesłany <SUF>
userAvatar.setImage(image);
}
});
// przypisuję Event Handler do przycisku
handleActionBtn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
// wywołuję kontroler odpowiedzialny za operacje zw. z przesłaniem danych do Bazy
handleNewProductsController performAction = new handleNewProductsController();
// sprawdzam wartość pola Wyboru, następnie na jej podstawię definiuje, którą metodę wywołać w handleNewProductsController.
if (comboBox.getValue() == "Autor") {
if (performAction.InsertAuthor(authorname.getText(), selectedFile)) {
// jeżeli sukces - wyświetlam stosowną informację
successerrlabel.setText("Operacja zakończona sukcesem!");
successerrlabel.setTextFill(Color.GREEN);
} else {
// jeżeli błąd - wyświetlam informacje, że wystąpił błąd.
successerrlabel.setText("Wystąpił Błąd! Sprawdź Czy Autor już nie występuje w bazie danych!");
successerrlabel.setTextFill(Color.RED);
}
// System.out.println(authorname.getText());
// System.out.println(selectedFile);
} else if (comboBox.getValue() == "Płyta") {
if (diskName.getText().isBlank() || selectedFile == null) {
successerrlabel.setText("Wystąpił Błąd! Nazwa Płyty nie może być pusta, grafika musi zostać wybrana!");
successerrlabel.setTextFill(Color.RED);
}
if (performAction.InsertDisk(diskName.getText(), selectedFile)) {
successerrlabel.setText("Operacja zakończona sukcesem!");
successerrlabel.setTextFill(Color.GREEN);
} else {
successerrlabel.setText("Wystąpił Błąd! Sprawdź Czy Płyta już nie występuje w bazie danych!");
successerrlabel.setTextFill(Color.RED);
}
} else if (comboBox.getValue() == "Utwór") {
if (songName.getText().isBlank() || selectedFile == null || authorname.getText().isBlank()) {
successerrlabel.setText("Wystąpił Błąd! Nazwa Utworu nie może być pusta, grafika musi zostać wybrana!");
successerrlabel.setTextFill(Color.RED);
}
if (performAction.InsertSongs(songName.getText(), selectedFile, authorname.getText(), diskName.getText())) {
successerrlabel.setText("Operacja zakończona sukcesem!");
successerrlabel.setTextFill(Color.GREEN);
} else {
successerrlabel.setText("Wystąpił Błąd! Sprawdź Czy Utwór już nie występuje w bazie danych!");
successerrlabel.setTextFill(Color.RED);
}
}
}
});
}
}
| t |
3921_1 | kwitnacy/bigOS | 773 | FileModule/Directory.java | package FileModule;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
*
* @author Weronika Kowalska
*/
public class Directory {
public String name;
public List<File> root;
public Directory() {
this.name = "root";
this.root = new LinkedList<>();
}
public boolean checkExistance(String fileName){
for(File f : root){
if(f.getName().equals(fileName)) return true; //w katalogu jest plik o podanej nazwie
}
return false; //w katalogu nie ma pliku o podanej nazwie
}
public boolean addToRoot(File file){ //dodawanie pliku do katalogu
for(File f : root){
if(this.checkExistance(file.getName()) == true){
return false; //podany plik istnieje więc nie dodajemy
}
}
this.root.add(file);
//System.out.println("[File Module]: File " + file.getName() + " added to the root.");
return true; //dodanie do katalogu
}
public boolean deleteFromRoot(String fileName){ //usuwanie pliku o podanej nazwie z katalogu
for(File f : root){
if(checkExistance(fileName) == true && f.getName().equals(fileName)){
root.remove(f);
return true; //poprawna nazwa i usunięcie FCB z katalogu
}
}
System.out.println("[File Module]: File " + fileName + " not found in the root.");
return false; //niepoprawna nazwa
}
public File getFileByName(String fName){
if(checkExistance(fName) == true){
for(File f : root){
if(f.getName().equals(fName)) return f; //zwraca żądany plik
}
}
return null;
}
public void replacebyName (File newFile){
for(int i = 0; i < root.size(); i++){
if(newFile.getName().equals(root.get(i).getName())){
root.set(i, newFile); //podmienia plik na ten podnay w argumenice
}
}
}
public void printRoot(){
for(int i = 0; i < root.size(); i++){
System.out.print(root.get(i).getName() + " ");
}
System.out.println();
}
public Map<String,String> getRoot()
{
Map<String,String> output= new TreeMap<>();
for (int i=0; i<root.size(); i++)
{
output.put(root.get(i).getName(),root.get(i).getUserName());
}
return output;
}
}
| //w katalogu jest plik o podanej nazwie | package FileModule;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
*
* @author Weronika Kowalska
*/
public class Directory {
public String name;
public List<File> root;
public Directory() {
this.name = "root";
this.root = new LinkedList<>();
}
public boolean checkExistance(String fileName){
for(File f : root){
if(f.getName().equals(fileName)) return true; //w katalogu <SUF>
}
return false; //w katalogu nie ma pliku o podanej nazwie
}
public boolean addToRoot(File file){ //dodawanie pliku do katalogu
for(File f : root){
if(this.checkExistance(file.getName()) == true){
return false; //podany plik istnieje więc nie dodajemy
}
}
this.root.add(file);
//System.out.println("[File Module]: File " + file.getName() + " added to the root.");
return true; //dodanie do katalogu
}
public boolean deleteFromRoot(String fileName){ //usuwanie pliku o podanej nazwie z katalogu
for(File f : root){
if(checkExistance(fileName) == true && f.getName().equals(fileName)){
root.remove(f);
return true; //poprawna nazwa i usunięcie FCB z katalogu
}
}
System.out.println("[File Module]: File " + fileName + " not found in the root.");
return false; //niepoprawna nazwa
}
public File getFileByName(String fName){
if(checkExistance(fName) == true){
for(File f : root){
if(f.getName().equals(fName)) return f; //zwraca żądany plik
}
}
return null;
}
public void replacebyName (File newFile){
for(int i = 0; i < root.size(); i++){
if(newFile.getName().equals(root.get(i).getName())){
root.set(i, newFile); //podmienia plik na ten podnay w argumenice
}
}
}
public void printRoot(){
for(int i = 0; i < root.size(); i++){
System.out.print(root.get(i).getName() + " ");
}
System.out.println();
}
public Map<String,String> getRoot()
{
Map<String,String> output= new TreeMap<>();
for (int i=0; i<root.size(); i++)
{
output.put(root.get(i).getName(),root.get(i).getUserName());
}
return output;
}
}
| t |
8182_0 | lechoPl/Gomoku | 1,945 | src/gui/Ramka.java | package gui;
import game.Computer;
import game.Gomoku;
import game.PLAYER;
import game.STAN_GRY;
import game.Wsp;
import java.awt.*;
import java.awt.event.MouseEvent;
import javax.swing.*;
import javax.swing.event.*;
/*
* Twoja gra powinna być maksymalnie odporna na niedoświadczonego użytkownika. Akcje związane z rozpoczęciem
nowej gry i z zakończeniem działania całej aplikacji mają mieć przypisane skróty klawiaturowe
(KeyStroke) postaci odpowiednio ctrl-N i ctrl-X. Zadbaj też o estetyczny wygląd aplikacji!
*/
public class Ramka extends JFrame{
private GMenuBar menuBar = new GMenuBar(this);
private Plansza plansza;
private JLabel napis;
private Gomoku game;
private Computer comp;
private PLAYER player_start = PLAYER.P_HUMAN;
public void setStartPlayer(PLAYER p) { player_start = p; }
private MouseInputListener mausList = new MouseInputAdapter(){
@Override
public void mousePressed(MouseEvent e) {
if(game.get_stan_gry() != STAN_GRY.S_MOVE) return;
Wsp test = (( Plansza )( e.getSource() )).getField( e.getX(), e.getY() );
if(test == null) return;
if(game.get_current_Player() != PLAYER.P_HUMAN) return;
if(! game.Move(test.get_y(), test.get_x()) ) return;
//((Plansza)(e.getSource())).repaint();
RPPlansza();
if(game.SprawdzKoniecGry()) {
setWinNapis();
return;
}
game.ZmienGracza();
setNextPlayerNapis();
//dodaj chile prerwy
Wsp temp = comp.WykonajRuch();
game.Move(temp.get_x(), temp.get_y());
RPPlansza();
if(game.SprawdzKoniecGry()) {
setWinNapis();
return;
}
game.ZmienGracza();
setNextPlayerNapis();
}
};
private void setNextPlayerNapis() {
napis.setText(
"Ruch wykonuje: " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") );
}
private void setWinNapis() {
String str_temp = "";
switch(game.get_stan_gry()){
case S_DRAW:
str_temp = "REMIS !";
break;
case S_WON:
str_temp = "WYGRYWA " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") + " !";
break;
}
napis.setText(str_temp);
JOptionPane.showMessageDialog(this, str_temp, "Konie gry", JOptionPane.PLAIN_MESSAGE);
}
public Ramka(){
super("Gomoku Game");
NowaGra();
//game = new Gomoku(player_start);
//comp = new Computer(game.get_Plansza(), game.getCompField(), game.getIleW());
int szer = 600;
int wys = 600;
this.setSize(szer, wys);
this.setMaximumSize(new Dimension(100,100));
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation((d.width - szer)/2, (d.height - wys)/2);
this.setLayout(new BorderLayout());
//------- MENU ------
this.add(menuBar, BorderLayout.NORTH);
//----- PLANSZA -------
//plansza = new Plansza(game.get_Plansza());
//plansza.addMouseListener(mausList);
this.add(plansza, BorderLayout.CENTER);
//----- INFO ----------
JPanel panel_2 = new JPanel();
this.add(panel_2, BorderLayout.SOUTH);
panel_2.setLayout(new FlowLayout());
/*napis = new JLabel("Ruch wykonuje: " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") );
*/
panel_2.add(napis);
//------- END -------
/*if(game.get_current_Player() == PLAYER.P_COMP){
Wsp temp = comp.WykonajRuch();
game.Move(temp.get_x(), temp.get_y());
game.ZmienGracza();
setNextPlayerNapis();
}*/
this.setVisible(true);
//new UstawieniaKoloru(this, new Color(255,0,0));
}
public Gomoku getGame(){
return game;
}
public void NowaGra(){
game = new Gomoku(player_start);
comp = new Computer(game.get_Plansza(), game.getCompField(), game.getIleW());
if(plansza != null) {
plansza.setPlansza(game.get_Plansza());
plansza.setGame(game);
}
else{
plansza = new Plansza(game.get_Plansza(), game);
plansza.addMouseListener(mausList);
}
if(napis != null) setNextPlayerNapis();
else {
napis = new JLabel("Ruch wykonuje: " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") );
}
if(game.get_current_Player() == PLAYER.P_COMP){
/*try
{
Thread.sleep(100);
}
catch(InterruptedException e)
{
}*/
Wsp temp = comp.WykonajRuch();
game.Move(temp.get_x(), temp.get_y());
game.ZmienGracza();
setNextPlayerNapis();
}
this.RPPlansza();
}
public void RPPlansza(){
plansza.repaint();
}
public void setOznaczenia(boolean b) { plansza.setOznaczeniaON(b); }
public Plansza getPlansza(){ return plansza; }
}
| /*
* Twoja gra powinna być maksymalnie odporna na niedoświadczonego użytkownika. Akcje związane z rozpoczęciem
nowej gry i z zakończeniem działania całej aplikacji mają mieć przypisane skróty klawiaturowe
(KeyStroke) postaci odpowiednio ctrl-N i ctrl-X. Zadbaj też o estetyczny wygląd aplikacji!
*/ | package gui;
import game.Computer;
import game.Gomoku;
import game.PLAYER;
import game.STAN_GRY;
import game.Wsp;
import java.awt.*;
import java.awt.event.MouseEvent;
import javax.swing.*;
import javax.swing.event.*;
/*
* Twoja gra powinna <SUF>*/
public class Ramka extends JFrame{
private GMenuBar menuBar = new GMenuBar(this);
private Plansza plansza;
private JLabel napis;
private Gomoku game;
private Computer comp;
private PLAYER player_start = PLAYER.P_HUMAN;
public void setStartPlayer(PLAYER p) { player_start = p; }
private MouseInputListener mausList = new MouseInputAdapter(){
@Override
public void mousePressed(MouseEvent e) {
if(game.get_stan_gry() != STAN_GRY.S_MOVE) return;
Wsp test = (( Plansza )( e.getSource() )).getField( e.getX(), e.getY() );
if(test == null) return;
if(game.get_current_Player() != PLAYER.P_HUMAN) return;
if(! game.Move(test.get_y(), test.get_x()) ) return;
//((Plansza)(e.getSource())).repaint();
RPPlansza();
if(game.SprawdzKoniecGry()) {
setWinNapis();
return;
}
game.ZmienGracza();
setNextPlayerNapis();
//dodaj chile prerwy
Wsp temp = comp.WykonajRuch();
game.Move(temp.get_x(), temp.get_y());
RPPlansza();
if(game.SprawdzKoniecGry()) {
setWinNapis();
return;
}
game.ZmienGracza();
setNextPlayerNapis();
}
};
private void setNextPlayerNapis() {
napis.setText(
"Ruch wykonuje: " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") );
}
private void setWinNapis() {
String str_temp = "";
switch(game.get_stan_gry()){
case S_DRAW:
str_temp = "REMIS !";
break;
case S_WON:
str_temp = "WYGRYWA " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") + " !";
break;
}
napis.setText(str_temp);
JOptionPane.showMessageDialog(this, str_temp, "Konie gry", JOptionPane.PLAIN_MESSAGE);
}
public Ramka(){
super("Gomoku Game");
NowaGra();
//game = new Gomoku(player_start);
//comp = new Computer(game.get_Plansza(), game.getCompField(), game.getIleW());
int szer = 600;
int wys = 600;
this.setSize(szer, wys);
this.setMaximumSize(new Dimension(100,100));
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation((d.width - szer)/2, (d.height - wys)/2);
this.setLayout(new BorderLayout());
//------- MENU ------
this.add(menuBar, BorderLayout.NORTH);
//----- PLANSZA -------
//plansza = new Plansza(game.get_Plansza());
//plansza.addMouseListener(mausList);
this.add(plansza, BorderLayout.CENTER);
//----- INFO ----------
JPanel panel_2 = new JPanel();
this.add(panel_2, BorderLayout.SOUTH);
panel_2.setLayout(new FlowLayout());
/*napis = new JLabel("Ruch wykonuje: " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") );
*/
panel_2.add(napis);
//------- END -------
/*if(game.get_current_Player() == PLAYER.P_COMP){
Wsp temp = comp.WykonajRuch();
game.Move(temp.get_x(), temp.get_y());
game.ZmienGracza();
setNextPlayerNapis();
}*/
this.setVisible(true);
//new UstawieniaKoloru(this, new Color(255,0,0));
}
public Gomoku getGame(){
return game;
}
public void NowaGra(){
game = new Gomoku(player_start);
comp = new Computer(game.get_Plansza(), game.getCompField(), game.getIleW());
if(plansza != null) {
plansza.setPlansza(game.get_Plansza());
plansza.setGame(game);
}
else{
plansza = new Plansza(game.get_Plansza(), game);
plansza.addMouseListener(mausList);
}
if(napis != null) setNextPlayerNapis();
else {
napis = new JLabel("Ruch wykonuje: " +
(game.get_current_Player() == PLAYER.P_COMP ?
"KOMPUTER" : "GRACZ") );
}
if(game.get_current_Player() == PLAYER.P_COMP){
/*try
{
Thread.sleep(100);
}
catch(InterruptedException e)
{
}*/
Wsp temp = comp.WykonajRuch();
game.Move(temp.get_x(), temp.get_y());
game.ZmienGracza();
setNextPlayerNapis();
}
this.RPPlansza();
}
public void RPPlansza(){
plansza.repaint();
}
public void setOznaczenia(boolean b) { plansza.setOznaczeniaON(b); }
public Plansza getPlansza(){ return plansza; }
}
| t |
7310_3 | legacyfighter/cabs-java | 168 | src/main/java/io/legacyfighter/cabs/contracts/legacy/OOParadigm.java | package io.legacyfighter.cabs.contracts.legacy;
abstract class OOParadigm {
//2. enkapsulacja - ukrycie impl
private Object filed;
//1. abstrakcja - agent odbierający sygnały
public void method(){
//do sth
}
//3. polimorfizm - zmienne zachowania
protected abstract void abstractStep();
}
//4. dziedziczenie - technika wspierająca polimorizm
class ConcreteType extends OOParadigm{
@Override
protected void abstractStep() {
}
}
| //4. dziedziczenie - technika wspierająca polimorizm | package io.legacyfighter.cabs.contracts.legacy;
abstract class OOParadigm {
//2. enkapsulacja - ukrycie impl
private Object filed;
//1. abstrakcja - agent odbierający sygnały
public void method(){
//do sth
}
//3. polimorfizm - zmienne zachowania
protected abstract void abstractStep();
}
//4. dziedziczenie <SUF>
class ConcreteType extends OOParadigm{
@Override
protected void abstractStep() {
}
}
| t |
7054_0 | lewandowski-jan/Calculator-java | 278 | src/Plik/ZPliku.java | package Plik;
import View.Wypisz;
import java.io.*;
public class ZPliku {
public static String czytaj(String filePath) {
try {
File file = new File(filePath);
FileReader fileReader = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileReader);
StringBuilder stringBuilder = new StringBuilder();
String line = bufferedReader.readLine();
stringBuilder.append(line);
fileReader.close();
return stringBuilder.toString();
} catch (FileNotFoundException e) {
Wypisz.wypiszBlad("Nie istnieje plik o takiej ścieżce");
return "0";
}
catch (IOException e ){
e.printStackTrace();
return "0";
}
}
public static void main(String[] args) {
czytaj("src/dzialanie.txt");//tu wpisujemy argument metody - sciezke do pliku. Do każdego slasha "\" należy dodać jeszcze jeden slash "\\"
}
}
| //tu wpisujemy argument metody - sciezke do pliku. Do każdego slasha "\" należy dodać jeszcze jeden slash "\\" | package Plik;
import View.Wypisz;
import java.io.*;
public class ZPliku {
public static String czytaj(String filePath) {
try {
File file = new File(filePath);
FileReader fileReader = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileReader);
StringBuilder stringBuilder = new StringBuilder();
String line = bufferedReader.readLine();
stringBuilder.append(line);
fileReader.close();
return stringBuilder.toString();
} catch (FileNotFoundException e) {
Wypisz.wypiszBlad("Nie istnieje plik o takiej ścieżce");
return "0";
}
catch (IOException e ){
e.printStackTrace();
return "0";
}
}
public static void main(String[] args) {
czytaj("src/dzialanie.txt");//tu wpisujemy <SUF>
}
}
| t |
2751_5 | lightsidecode/kata-java | 796 | tasks/evenAndOdd.java | /** Wątki, które oddzielają liczby parzyste od nieparzystych. */
/*
Wątek (ang. Thread) - część programu wykonywana współbieżnie w obrębie jednego procesu.
W jednym procesie może istnieć wiele wątków.
Różnica między zwykłym procesem a wątkiem polega na współdzieleniu przez wszystkie
wątki działające w danym procesie przestrzeni adresowej oraz wszystkich innych struktur
systemowych (np. listy otwartych plików, gniazd itp.) – z kolei procesy posiadają niezależne zasoby.
*/
import java.util.ArrayList;
import java.util.List;
enum Find {
EVEN, ODD
}
// Możemy implementować interfejs Runnable lub dziedziczyć po klasie Thread
class NumberSplitter implements Runnable {
private List<Integer> digits;
private List<Integer> resultDigits;
private Find find;
NumberSplitter(List<Integer> digits, Find find) {
this.digits = digits;
this.resultDigits = new ArrayList<>();
this.find = find;
}
public void run() {
if(find == Find.EVEN) {
this.saveEvenNumbers();
} else if(find == Find.ODD) {
this.saveOddNumbers();
}
}
private void saveEvenNumbers() {
resultDigits.addAll(digits.stream().filter(digit -> digit % 2 == 0).toList());
}
private void saveOddNumbers() {
resultDigits.addAll(digits.stream().filter(digit -> digit % 2 != 0).toList());
}
List<Integer> result() {
return this.resultDigits;
}
}
class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
NumberSplitter evenSplitter = new NumberSplitter(numbers, Find.EVEN);
NumberSplitter oddSplitter = new NumberSplitter(numbers, Find.ODD);
Thread evenThread = new Thread(evenSplitter); // wątek odpowiedzialny za wydzielenie liczb parzystych
Thread oddThread = new Thread(oddSplitter); // wątek odpowiedzialny za wydzielenie liczb nieparzystych
evenThread.start();
oddThread.start();
try {
evenThread.join(); // czekamy na zakończenie działania wątku, potrzebujemy danych
oddThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("Even: %s \n", evenSplitter.result().toString());
System.out.printf("Odd : %s \n", oddSplitter.result().toString());
}
}
| // czekamy na zakończenie działania wątku, potrzebujemy danych | /** Wątki, które oddzielają liczby parzyste od nieparzystych. */
/*
Wątek (ang. Thread) - część programu wykonywana współbieżnie w obrębie jednego procesu.
W jednym procesie może istnieć wiele wątków.
Różnica między zwykłym procesem a wątkiem polega na współdzieleniu przez wszystkie
wątki działające w danym procesie przestrzeni adresowej oraz wszystkich innych struktur
systemowych (np. listy otwartych plików, gniazd itp.) – z kolei procesy posiadają niezależne zasoby.
*/
import java.util.ArrayList;
import java.util.List;
enum Find {
EVEN, ODD
}
// Możemy implementować interfejs Runnable lub dziedziczyć po klasie Thread
class NumberSplitter implements Runnable {
private List<Integer> digits;
private List<Integer> resultDigits;
private Find find;
NumberSplitter(List<Integer> digits, Find find) {
this.digits = digits;
this.resultDigits = new ArrayList<>();
this.find = find;
}
public void run() {
if(find == Find.EVEN) {
this.saveEvenNumbers();
} else if(find == Find.ODD) {
this.saveOddNumbers();
}
}
private void saveEvenNumbers() {
resultDigits.addAll(digits.stream().filter(digit -> digit % 2 == 0).toList());
}
private void saveOddNumbers() {
resultDigits.addAll(digits.stream().filter(digit -> digit % 2 != 0).toList());
}
List<Integer> result() {
return this.resultDigits;
}
}
class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
NumberSplitter evenSplitter = new NumberSplitter(numbers, Find.EVEN);
NumberSplitter oddSplitter = new NumberSplitter(numbers, Find.ODD);
Thread evenThread = new Thread(evenSplitter); // wątek odpowiedzialny za wydzielenie liczb parzystych
Thread oddThread = new Thread(oddSplitter); // wątek odpowiedzialny za wydzielenie liczb nieparzystych
evenThread.start();
oddThread.start();
try {
evenThread.join(); // czekamy na <SUF>
oddThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("Even: %s \n", evenSplitter.result().toString());
System.out.printf("Odd : %s \n", oddSplitter.result().toString());
}
}
| t |
3639_0 | loomchild/segment | 1,640 | segment/src/main/java/net/loomchild/segment/srx/legacy/AccurateSrxTextIterator.java | package net.loomchild.segment.srx.legacy;
import java.util.*;
import net.loomchild.segment.AbstractTextIterator;
import net.loomchild.segment.srx.*;
import net.loomchild.segment.util.IORuntimeException;
import net.loomchild.segment.util.Util;
import static net.loomchild.segment.util.Util.getParameter;
/**
* Reprezentuje splitter dzielący na podstawie reguł zawartych w pliku srx.
*
* @author loomchild
*/
public class AccurateSrxTextIterator extends AbstractTextIterator {
private List<LanguageRule> languageRuleList;
private CharSequence text;
private String segment;
private List<RuleMatcher> ruleMatcherList;
private int startPosition, endPosition;
/**
* Creates text iterator that obtains language rules form given document
* using given language code. To retrieve language rules calls
* {@link SrxDocument#getLanguageRuleList(String)}.
*
* @param document document containing language rules
* @param languageCode language code to select the rules
* @param text
*/
public AccurateSrxTextIterator(SrxDocument document, String languageCode,
CharSequence text, Map<String, Object> parameterMap) {
this.languageRuleList = document.getLanguageRuleList(languageCode);
this.text = text;
this.segment = null;
this.startPosition = 0;
this.endPosition = 0;
int maxLookbehindConstructLength = getParameter(parameterMap
.get(SrxTextIterator.MAX_LOOKBEHIND_CONSTRUCT_LENGTH_PARAMETER),
SrxTextIterator.DEFAULT_MAX_LOOKBEHIND_CONSTRUCT_LENGTH);
this.ruleMatcherList = new LinkedList<RuleMatcher>();
for (LanguageRule languageRule : languageRuleList) {
for (Rule rule : languageRule.getRuleList()) {
if (!rule.isBreak()) {
rule = new Rule(rule.isBreak(), Util.createLookbehindPattern(rule.getBeforePattern(), maxLookbehindConstructLength), rule.getAfterPattern());
}
RuleMatcher matcher = new RuleMatcher(document, rule, text);
ruleMatcherList.add(matcher);
}
}
}
public AccurateSrxTextIterator(SrxDocument document, String languageCode, CharSequence text) {
this(document, languageCode, text, new HashMap<String, Object>());
}
/**
* Wyszukuje następne dopasowanie.
* @return Zwraca następny segment albo null jeśli nie istnieje
* @throws IORuntimeException Zgłaszany gdy nastąpi błąd przy odczycie strumienia
*/
public String next() {
if (hasNext()) {
// Initialize matchers before first search.
if (segment == null) {
initMatchers();
}
boolean found = false;
while ((ruleMatcherList.size() > 0) && !found) {
RuleMatcher minMatcher = getMinMatcher();
endPosition = minMatcher.getBreakPosition();
if (minMatcher.getRule().isBreak() &&
endPosition > startPosition) {
found = true;
cutMatchers();
}
moveMatchers();
}
if (!found) {
endPosition = text.length();
}
segment = text.subSequence(startPosition, endPosition).toString();
startPosition = endPosition;
return segment;
} else {
return null;
}
}
/**
* @return Zwraca true gdy są dostępne kolejne segmenty
*/
public boolean hasNext() {
return (startPosition < text.length());
}
private void initMatchers() {
for (Iterator<RuleMatcher> i = ruleMatcherList.iterator(); i.hasNext();) {
RuleMatcher matcher = i.next();
matcher.find();
if (matcher.hitEnd()) {
i.remove();
}
}
}
/**
* Przesuwa iteratory na kolejną pozycje jeśli to konieczne.
*/
private void moveMatchers() {
for (Iterator<RuleMatcher> i = ruleMatcherList.iterator(); i.hasNext();) {
RuleMatcher matcher = i.next();
while (matcher.getBreakPosition() <= endPosition) {
matcher.find();
if (matcher.hitEnd()) {
i.remove();
break;
}
}
}
}
/**
* Move matchers that start before previous segment end.
*/
private void cutMatchers() {
for (Iterator<RuleMatcher> i = ruleMatcherList.iterator(); i.hasNext();) {
RuleMatcher matcher = i.next();
if (matcher.getStartPosition() < endPosition) {
matcher.find(endPosition);
if (matcher.hitEnd()) {
i.remove();
}
}
}
}
/**
* @return Zwraca iterator pierwszego trafionego dopasowania
*/
private RuleMatcher getMinMatcher() {
int minPosition = Integer.MAX_VALUE;
RuleMatcher minMatcher = null;
for (RuleMatcher matcher : ruleMatcherList) {
if (matcher.getBreakPosition() < minPosition) {
minPosition = matcher.getBreakPosition();
minMatcher = matcher;
}
}
return minMatcher;
}
}
| /**
* Reprezentuje splitter dzielący na podstawie reguł zawartych w pliku srx.
*
* @author loomchild
*/ | package net.loomchild.segment.srx.legacy;
import java.util.*;
import net.loomchild.segment.AbstractTextIterator;
import net.loomchild.segment.srx.*;
import net.loomchild.segment.util.IORuntimeException;
import net.loomchild.segment.util.Util;
import static net.loomchild.segment.util.Util.getParameter;
/**
* Reprezentuje splitter dzielący <SUF>*/
public class AccurateSrxTextIterator extends AbstractTextIterator {
private List<LanguageRule> languageRuleList;
private CharSequence text;
private String segment;
private List<RuleMatcher> ruleMatcherList;
private int startPosition, endPosition;
/**
* Creates text iterator that obtains language rules form given document
* using given language code. To retrieve language rules calls
* {@link SrxDocument#getLanguageRuleList(String)}.
*
* @param document document containing language rules
* @param languageCode language code to select the rules
* @param text
*/
public AccurateSrxTextIterator(SrxDocument document, String languageCode,
CharSequence text, Map<String, Object> parameterMap) {
this.languageRuleList = document.getLanguageRuleList(languageCode);
this.text = text;
this.segment = null;
this.startPosition = 0;
this.endPosition = 0;
int maxLookbehindConstructLength = getParameter(parameterMap
.get(SrxTextIterator.MAX_LOOKBEHIND_CONSTRUCT_LENGTH_PARAMETER),
SrxTextIterator.DEFAULT_MAX_LOOKBEHIND_CONSTRUCT_LENGTH);
this.ruleMatcherList = new LinkedList<RuleMatcher>();
for (LanguageRule languageRule : languageRuleList) {
for (Rule rule : languageRule.getRuleList()) {
if (!rule.isBreak()) {
rule = new Rule(rule.isBreak(), Util.createLookbehindPattern(rule.getBeforePattern(), maxLookbehindConstructLength), rule.getAfterPattern());
}
RuleMatcher matcher = new RuleMatcher(document, rule, text);
ruleMatcherList.add(matcher);
}
}
}
public AccurateSrxTextIterator(SrxDocument document, String languageCode, CharSequence text) {
this(document, languageCode, text, new HashMap<String, Object>());
}
/**
* Wyszukuje następne dopasowanie.
* @return Zwraca następny segment albo null jeśli nie istnieje
* @throws IORuntimeException Zgłaszany gdy nastąpi błąd przy odczycie strumienia
*/
public String next() {
if (hasNext()) {
// Initialize matchers before first search.
if (segment == null) {
initMatchers();
}
boolean found = false;
while ((ruleMatcherList.size() > 0) && !found) {
RuleMatcher minMatcher = getMinMatcher();
endPosition = minMatcher.getBreakPosition();
if (minMatcher.getRule().isBreak() &&
endPosition > startPosition) {
found = true;
cutMatchers();
}
moveMatchers();
}
if (!found) {
endPosition = text.length();
}
segment = text.subSequence(startPosition, endPosition).toString();
startPosition = endPosition;
return segment;
} else {
return null;
}
}
/**
* @return Zwraca true gdy są dostępne kolejne segmenty
*/
public boolean hasNext() {
return (startPosition < text.length());
}
private void initMatchers() {
for (Iterator<RuleMatcher> i = ruleMatcherList.iterator(); i.hasNext();) {
RuleMatcher matcher = i.next();
matcher.find();
if (matcher.hitEnd()) {
i.remove();
}
}
}
/**
* Przesuwa iteratory na kolejną pozycje jeśli to konieczne.
*/
private void moveMatchers() {
for (Iterator<RuleMatcher> i = ruleMatcherList.iterator(); i.hasNext();) {
RuleMatcher matcher = i.next();
while (matcher.getBreakPosition() <= endPosition) {
matcher.find();
if (matcher.hitEnd()) {
i.remove();
break;
}
}
}
}
/**
* Move matchers that start before previous segment end.
*/
private void cutMatchers() {
for (Iterator<RuleMatcher> i = ruleMatcherList.iterator(); i.hasNext();) {
RuleMatcher matcher = i.next();
if (matcher.getStartPosition() < endPosition) {
matcher.find(endPosition);
if (matcher.hitEnd()) {
i.remove();
}
}
}
}
/**
* @return Zwraca iterator pierwszego trafionego dopasowania
*/
private RuleMatcher getMinMatcher() {
int minPosition = Integer.MAX_VALUE;
RuleMatcher minMatcher = null;
for (RuleMatcher matcher : ruleMatcherList) {
if (matcher.getBreakPosition() < minPosition) {
minPosition = matcher.getBreakPosition();
minMatcher = matcher;
}
}
return minMatcher;
}
}
| t |
6159_3 | lpolech/hkplusplus | 2,210 | src/dendrogram/ClusterisationStatistics.java | package dendrogram;
import java.util.HashMap;
import data.DataPoint;
import data.DataStatistics;
import data.Parameters;
public class ClusterisationStatistics {
private int numberOfClasses;
private int[] eachClassNumberOfInstancesWithInheritance;
private double[] eachClassMaxFMeasure;
private double flatClusterisationFMeasure;
private HashMap<String, Integer> classNameAndItsId;
//miary dla dendrogramu DO TEGO POZIOMU WLACZNIE (do poziomu ktory posiada TEN obiekt clusterisation statistics)
private double incrementalHierarchicalFMeasure;
private double adaptedFmeasureWithInheritance;
private double adaptedFmeasureWithOUTInheritance;
private double standardFmeasure;
private double partialOrderFscore;
public ClusterisationStatistics(DataStatistics dataStatistics)//TODO: prawdopodobnie to ze obracamy sobie tym obiektem w programie, powoduje zjadanie pamieci!
{
this.flatClusterisationFMeasure = Double.NaN;
this.numberOfClasses = dataStatistics.getClassNameAndItsId().size();
this.eachClassNumberOfInstancesWithInheritance = dataStatistics.getEachClassNumberOfInstanceWithInheritance();
this.classNameAndItsId = dataStatistics.getClassNameAndItsId();
}
//this F-measure assume inheritance property (children belongs to its father)
public void computeFlatClusterisationFMeasure(DendrogramLevel clusterisation) {
if(Parameters.isClassAttribute())
{
flatClusterisationFMeasure = 0.0;
int numberOfClusters = clusterisation.getClusters().length;
int[] eachClusterNumberOfInstances = new int[numberOfClusters];
int[][] eachClassToClusterNumberOfInstances = new int[numberOfClasses][numberOfClusters];//liczba zgodnych obiektow w kazdym klastrze dla kastej klasy
for(int cluster = 0; cluster < numberOfClusters; cluster++)
{
eachClusterNumberOfInstances[cluster] = clusterisation.getClusters()[cluster].getNumberOfPoints();
for(DataPoint p: clusterisation.getClusters()[cluster].getPoints())
{
if(!p.getClassAttribute().contains("Noise"))
{
String classAttrib = p.getClassAttribute();
eachClassToClusterNumberOfInstances[classNameAndItsId.get(p.getClassAttribute())][cluster]++;
for(String potentialParentClass: classNameAndItsId.keySet())
{
if(potentialParentClass.length() < classAttrib.length()
&& classAttrib.startsWith(potentialParentClass + basic_hierarchy.common.Constants.HIERARCHY_BRANCH_SEPARATOR))
{
eachClassToClusterNumberOfInstances[classNameAndItsId.get(potentialParentClass)][cluster]++;
}
}
}
}
}
//precision and recall nad F-measure
double[][] classToClusterPrecision = new double[numberOfClasses][numberOfClusters];//[class][cluster]
double[][] classToClusterRecall = new double[numberOfClasses][numberOfClusters];
double[][] classToClusterFMeasure = new double[numberOfClasses][numberOfClusters];
eachClassMaxFMeasure = new double[numberOfClasses];
int normalizingFactor = 0;
for(int num: eachClassNumberOfInstancesWithInheritance)
{
normalizingFactor += num;
}
for(int classNum = 0; classNum < numberOfClasses; classNum++)
{
for(int clusterNum = 0; clusterNum < numberOfClusters; clusterNum++)
{
if(!clusterisation.getClusters()[clusterNum].isStaticCenter()) //If true that means that this cluster was already computed in
{ //the upper level with proper inheritance
classToClusterPrecision[classNum][clusterNum] = eachClassToClusterNumberOfInstances[classNum][clusterNum]/(double)eachClusterNumberOfInstances[clusterNum];
classToClusterRecall[classNum][clusterNum] = eachClassToClusterNumberOfInstances[classNum][clusterNum]/(double)eachClassNumberOfInstancesWithInheritance[classNum];
classToClusterFMeasure[classNum][clusterNum] = (2.0*classToClusterRecall[classNum][clusterNum]*classToClusterPrecision[classNum][clusterNum])
/(classToClusterRecall[classNum][clusterNum] + classToClusterPrecision[classNum][clusterNum]);
if(Double.isNaN(classToClusterFMeasure[classNum][clusterNum]))
{
classToClusterFMeasure[classNum][clusterNum] = 0.0;
}
if(classToClusterFMeasure[classNum][clusterNum] > eachClassMaxFMeasure[classNum])
{
eachClassMaxFMeasure[classNum] = classToClusterFMeasure[classNum][clusterNum];
// TODO: jezeli chcemy zachowac informacje, ktory klaster maxymalizuje FMeasure dla klasy, to trze TO ZROBIC TUTAJ!
}
}
}
//flat f-measure for this level, wartosc ta jest w pewien sposob przeklamana, bo bierze pod uwage liczbe wszystkich instancji a w danej klasteryzajci mozeby byc obecna tylko czesc
flatClusterisationFMeasure += (eachClassNumberOfInstancesWithInheritance[classNum]/(double)normalizingFactor)*eachClassMaxFMeasure[classNum];
}
}
}
public double[] getEachClassMaxFMeasure() {
return eachClassMaxFMeasure;
}
public double getFlatClusterisationFMeasure() {
return flatClusterisationFMeasure;
}
public double getIncrementalHierarchicalFMeasure() {
return incrementalHierarchicalFMeasure;
}
public void setIncrementalHierarchicalFMeasure(
double incrementalHierarchicalFMeasure) {
this.incrementalHierarchicalFMeasure = incrementalHierarchicalFMeasure;
}
public double getAdaptedFmeasureWithInheritance() {
return adaptedFmeasureWithInheritance;
}
public void setAdaptedFmeasureWithInheritance(double adaptedFmeasureWithInheritance) {
this.adaptedFmeasureWithInheritance = adaptedFmeasureWithInheritance;
}
public double getAdaptedFmeasureWithOUTInheritance() {
return adaptedFmeasureWithOUTInheritance;
}
public void setAdaptedFmeasureWithOUTInheritance(double adaptedFmeasureWithOUTInheritance) {
this.adaptedFmeasureWithOUTInheritance = adaptedFmeasureWithOUTInheritance;
}
public double getStandardFmeasure() {
return standardFmeasure;
}
public void setStandardFmeasure(double standardFmeasure) {
this.standardFmeasure = standardFmeasure;
}
public double getPartialOrderFscore() {
return partialOrderFscore;
}
public void setPartialOrderFscore(double partialOrderFscore) {
this.partialOrderFscore = partialOrderFscore;
}
}
| //liczba zgodnych obiektow w kazdym klastrze dla kastej klasy | package dendrogram;
import java.util.HashMap;
import data.DataPoint;
import data.DataStatistics;
import data.Parameters;
public class ClusterisationStatistics {
private int numberOfClasses;
private int[] eachClassNumberOfInstancesWithInheritance;
private double[] eachClassMaxFMeasure;
private double flatClusterisationFMeasure;
private HashMap<String, Integer> classNameAndItsId;
//miary dla dendrogramu DO TEGO POZIOMU WLACZNIE (do poziomu ktory posiada TEN obiekt clusterisation statistics)
private double incrementalHierarchicalFMeasure;
private double adaptedFmeasureWithInheritance;
private double adaptedFmeasureWithOUTInheritance;
private double standardFmeasure;
private double partialOrderFscore;
public ClusterisationStatistics(DataStatistics dataStatistics)//TODO: prawdopodobnie to ze obracamy sobie tym obiektem w programie, powoduje zjadanie pamieci!
{
this.flatClusterisationFMeasure = Double.NaN;
this.numberOfClasses = dataStatistics.getClassNameAndItsId().size();
this.eachClassNumberOfInstancesWithInheritance = dataStatistics.getEachClassNumberOfInstanceWithInheritance();
this.classNameAndItsId = dataStatistics.getClassNameAndItsId();
}
//this F-measure assume inheritance property (children belongs to its father)
public void computeFlatClusterisationFMeasure(DendrogramLevel clusterisation) {
if(Parameters.isClassAttribute())
{
flatClusterisationFMeasure = 0.0;
int numberOfClusters = clusterisation.getClusters().length;
int[] eachClusterNumberOfInstances = new int[numberOfClusters];
int[][] eachClassToClusterNumberOfInstances = new int[numberOfClasses][numberOfClusters];//liczba zgodnych <SUF>
for(int cluster = 0; cluster < numberOfClusters; cluster++)
{
eachClusterNumberOfInstances[cluster] = clusterisation.getClusters()[cluster].getNumberOfPoints();
for(DataPoint p: clusterisation.getClusters()[cluster].getPoints())
{
if(!p.getClassAttribute().contains("Noise"))
{
String classAttrib = p.getClassAttribute();
eachClassToClusterNumberOfInstances[classNameAndItsId.get(p.getClassAttribute())][cluster]++;
for(String potentialParentClass: classNameAndItsId.keySet())
{
if(potentialParentClass.length() < classAttrib.length()
&& classAttrib.startsWith(potentialParentClass + basic_hierarchy.common.Constants.HIERARCHY_BRANCH_SEPARATOR))
{
eachClassToClusterNumberOfInstances[classNameAndItsId.get(potentialParentClass)][cluster]++;
}
}
}
}
}
//precision and recall nad F-measure
double[][] classToClusterPrecision = new double[numberOfClasses][numberOfClusters];//[class][cluster]
double[][] classToClusterRecall = new double[numberOfClasses][numberOfClusters];
double[][] classToClusterFMeasure = new double[numberOfClasses][numberOfClusters];
eachClassMaxFMeasure = new double[numberOfClasses];
int normalizingFactor = 0;
for(int num: eachClassNumberOfInstancesWithInheritance)
{
normalizingFactor += num;
}
for(int classNum = 0; classNum < numberOfClasses; classNum++)
{
for(int clusterNum = 0; clusterNum < numberOfClusters; clusterNum++)
{
if(!clusterisation.getClusters()[clusterNum].isStaticCenter()) //If true that means that this cluster was already computed in
{ //the upper level with proper inheritance
classToClusterPrecision[classNum][clusterNum] = eachClassToClusterNumberOfInstances[classNum][clusterNum]/(double)eachClusterNumberOfInstances[clusterNum];
classToClusterRecall[classNum][clusterNum] = eachClassToClusterNumberOfInstances[classNum][clusterNum]/(double)eachClassNumberOfInstancesWithInheritance[classNum];
classToClusterFMeasure[classNum][clusterNum] = (2.0*classToClusterRecall[classNum][clusterNum]*classToClusterPrecision[classNum][clusterNum])
/(classToClusterRecall[classNum][clusterNum] + classToClusterPrecision[classNum][clusterNum]);
if(Double.isNaN(classToClusterFMeasure[classNum][clusterNum]))
{
classToClusterFMeasure[classNum][clusterNum] = 0.0;
}
if(classToClusterFMeasure[classNum][clusterNum] > eachClassMaxFMeasure[classNum])
{
eachClassMaxFMeasure[classNum] = classToClusterFMeasure[classNum][clusterNum];
// TODO: jezeli chcemy zachowac informacje, ktory klaster maxymalizuje FMeasure dla klasy, to trze TO ZROBIC TUTAJ!
}
}
}
//flat f-measure for this level, wartosc ta jest w pewien sposob przeklamana, bo bierze pod uwage liczbe wszystkich instancji a w danej klasteryzajci mozeby byc obecna tylko czesc
flatClusterisationFMeasure += (eachClassNumberOfInstancesWithInheritance[classNum]/(double)normalizingFactor)*eachClassMaxFMeasure[classNum];
}
}
}
public double[] getEachClassMaxFMeasure() {
return eachClassMaxFMeasure;
}
public double getFlatClusterisationFMeasure() {
return flatClusterisationFMeasure;
}
public double getIncrementalHierarchicalFMeasure() {
return incrementalHierarchicalFMeasure;
}
public void setIncrementalHierarchicalFMeasure(
double incrementalHierarchicalFMeasure) {
this.incrementalHierarchicalFMeasure = incrementalHierarchicalFMeasure;
}
public double getAdaptedFmeasureWithInheritance() {
return adaptedFmeasureWithInheritance;
}
public void setAdaptedFmeasureWithInheritance(double adaptedFmeasureWithInheritance) {
this.adaptedFmeasureWithInheritance = adaptedFmeasureWithInheritance;
}
public double getAdaptedFmeasureWithOUTInheritance() {
return adaptedFmeasureWithOUTInheritance;
}
public void setAdaptedFmeasureWithOUTInheritance(double adaptedFmeasureWithOUTInheritance) {
this.adaptedFmeasureWithOUTInheritance = adaptedFmeasureWithOUTInheritance;
}
public double getStandardFmeasure() {
return standardFmeasure;
}
public void setStandardFmeasure(double standardFmeasure) {
this.standardFmeasure = standardFmeasure;
}
public double getPartialOrderFscore() {
return partialOrderFscore;
}
public void setPartialOrderFscore(double partialOrderFscore) {
this.partialOrderFscore = partialOrderFscore;
}
}
| t |
10035_21 | ludwiktrammer/ludproxy | 2,619 | src/pl/trammer/ludwik/ludproxy/MessageBody.java | package pl.trammer.ludwik.ludproxy;
import java.io.*;
import pl.trammer.ludwik.ludproxy.errors.*;
/**
* Klasa reprezentująca "ciało" wiadomości HTTP.
*
* @author Ludwik Trammer
*
*/
public class MessageBody implements java.io.Serializable {
private static final long serialVersionUID = 8059937303887036643L;
private final byte[] body;
/**
* Tworzy nowy obiekt "ciała" wiadomości HTTP, której treścią jest przekazana
* tablica bajtów.
* @param bytes treść wiadomości HTTP
*/
public MessageBody(byte[] bytes) {
body = bytes;
}
/**
* Odczytuje treść "ciała" wiadomości HTTP ze strumienia wejściowego, jednocześnie na bierząco
* przekazując ją na strumień wyjściowy.
* <p>
* Metoda przyjmuje obiekty nagłówków, które wykorzystywane są do stwierdzenia kiedy należy
* przestać czytać strumień wejściowy, wg. następującego algorytmu:
* <p>
* <ol>
* <li> Jeśli wiadomość jest odpowiedzią na nagłówek HEAD lub ma status 1xx, 203 lub 304 to
* "ciało" wiadomości jest puste.
* <li> Jeśli wiadomość jest zakodowana przy pomocy Content Encoding {@code chunked} to
* będzie odczytywana w "porcjach" zdefiniowanych przez to kodowanie.
* <li> Jeśli wiadomość posiada nagłówek {@code Content-Length} to określa on ile
* bajtów należy odczytać ze strumienia wejściowego.
* <li> Jeśli żadne z powyższych stwierdzeń nie jest prawdziwe, a wiadomość
* przekazywana jest przy pomocy nietrwałego połączenia HTTP to jej koniec
* będzie oznaczony przez zamknięcie połączenia przez drugą stronę.
* </ol>
* <p>
* Jeśli odbieramy dane z serwera, który wykorzystuje sposób numer 3,
* a musi przesłać je do klienta przy pomocy trwałego połączenia HTTP
* metoda automatycznie zaczyna kodować dane w locie jako "chunked".
* <p>
* Niezależnie od sytuacji i formatu odbieranych danych, dane zawsze zapisywane są
* wewnątrz obiektu w formie "ciągłej", ze "zdjętym" Transfer Encoding.
*
* @param in strumień wejściowy z którego będą odczytywane dane
* @param header nagłówek wiadomości, której "ciało" chcemy odczytać ze strumienia
* @param out strumień wyjściowy na który na bierząco będą przekazywane odczytywane dane
* @param request nagłówek wiadomości na którą odpowiedzią jest właśnie odczytywana
* wiadomość, lub {@code null} jeśli nie dotyczy.
*/
public MessageBody(LudInputStream in, Header header, OutputStream out, RequestHeader request) throws HttpError, IOException {
boolean noBody = false;
if(header instanceof ResponseHeader) {
// Odpowiedzi na zapytanie typu HEAD
// oraz odpowiedzi 1xx, 204, 304 nie mają ciała
ResponseHeader rh = (ResponseHeader) header;
if((request!=null && request.getMethod().equals("HEAD"))
|| rh.getStatus()/100==1
|| rh.getStatus()==204
|| rh.getStatus()==304) {
noBody = true;
}
}
if(noBody) {
body = new byte[]{};
header.setField("Content-Length", 0+"");
} else if(header.containsField("Transfer-Encoding") && !header.fieldContainsValue("Transfer-Encoding", "identity")) {
// treść "pokawałkowana" (chunked)
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
int chunkLen;
byte[] bytes;
String chunkHeader="";
try {
do {
// Odczytujemy nagłówek fragmentu, mówiący ile danych
// mamy do odczytania w danym fragmencie
while((chunkHeader = in.readLine()) != null && chunkHeader.equals("")) {};
if(chunkHeader==null) break; //połączenie zakończone
/*
* W nagłówku fragmentu, po liczbie bajtów do odczytania mogą być oddzielone
* średnikiem rozszerzenia. Nas interesuje wyłącznie liczba.
*/
chunkLen = Integer.parseInt(chunkHeader.split("\\s*;")[0], 16);
// odczytujemy dokładnie tyle bajtów ile nam pozwolił nagłówek fragmentu
bytes = in.forwardAndRead(chunkLen, out, true);
if(bytes==null) break; //połączenie zakończone
tmp.write(bytes);
} while(chunkLen > 0);
// wyślij nagłówek końca wiadomości typu chunked:
if(out!=null) out.write((0 + "\r\n\r\n").getBytes());
// Po treści mogą być dodatkowe nagłówki ("trailing headers"):
if(header.containsField("Trailer")) header.getFieldsFromStream(in);
body = tmp.toByteArray();
// dostosuj nagłówek do tego w jakiej postaci właśnie zapisaliśmy ciało:
header.removeField("Trailer");
header.removeField("Transfer-Encoding");
header.setField("Content-Length", body.length+"");
} catch(NumberFormatException e) {
throw new HttpBadGateway("Długość danych określona w nagłówkach chunked nie jest poprawną liczbą (?!)");
}
} else if(header.containsField("Content-Length")) {
// Pobieramy z strumienia dokładnie tyle ile określono w Content-Length
try {
body = in.forwardAndRead(Integer.parseInt(header.getField("Content-Length")), out);
} catch(NumberFormatException e) {
throw new HttpBadGateway("Długość danych określona w nagłówku nie jest poprawną liczbą (?!)");
}
} else if(header instanceof ResponseHeader && (
header.fieldContainsValue("Connection", "close") || (!header.containsField("Connection") && header.getProtocolVersion().equals("1.0")))) {
// Ojoj. Jaki nieczytelny ten if().
// Chodzi o to, że jest to odpowiedź w nietrwałym połączeniu,
// więc o końcu wiadomości można zorientować się po tym, że serwer zamknął połączenie
// Jeśli używamy trwałego połączenia z klietem to trzeba będzie mu to przekazać jako chunked
boolean usingChunked = (request!=null && request.keepAlive());
body = in.forwardAndRead(-1, out, usingChunked);
// wyślij nagłówek końca wiadomości typu chunked:
if(usingChunked && out!=null) out.write((0 + "\r\n\r\n").getBytes());
// teraz już znamy długość, więc zapiszmy ją w nagłówku!
header.setField("Content-Length", body.length+"");
} else if(header instanceof RequestHeader){
// zapytanie bez ciała, ok
body = new byte[]{};
header.setField("Content-Length", 0+"");
} else {
throw new HttpBadGateway("Otrzymano za mało informacji żeby stwierdzić długość odpowiedzi");
}
}
/**
* Zwraca "ciało" wiadomości jako tablicę bajtów.
* @return tablica bajtów
*/
public byte[] getBytes() {
return body;
}
/**
* Zwraca długość wiadomości (w bajtach)
* @return długość wiadomości
*/
public int length() {
return body.length;
}
}
| /**
* Zwraca "ciało" wiadomości jako tablicę bajtów.
* @return tablica bajtów
*/ | package pl.trammer.ludwik.ludproxy;
import java.io.*;
import pl.trammer.ludwik.ludproxy.errors.*;
/**
* Klasa reprezentująca "ciało" wiadomości HTTP.
*
* @author Ludwik Trammer
*
*/
public class MessageBody implements java.io.Serializable {
private static final long serialVersionUID = 8059937303887036643L;
private final byte[] body;
/**
* Tworzy nowy obiekt "ciała" wiadomości HTTP, której treścią jest przekazana
* tablica bajtów.
* @param bytes treść wiadomości HTTP
*/
public MessageBody(byte[] bytes) {
body = bytes;
}
/**
* Odczytuje treść "ciała" wiadomości HTTP ze strumienia wejściowego, jednocześnie na bierząco
* przekazując ją na strumień wyjściowy.
* <p>
* Metoda przyjmuje obiekty nagłówków, które wykorzystywane są do stwierdzenia kiedy należy
* przestać czytać strumień wejściowy, wg. następującego algorytmu:
* <p>
* <ol>
* <li> Jeśli wiadomość jest odpowiedzią na nagłówek HEAD lub ma status 1xx, 203 lub 304 to
* "ciało" wiadomości jest puste.
* <li> Jeśli wiadomość jest zakodowana przy pomocy Content Encoding {@code chunked} to
* będzie odczytywana w "porcjach" zdefiniowanych przez to kodowanie.
* <li> Jeśli wiadomość posiada nagłówek {@code Content-Length} to określa on ile
* bajtów należy odczytać ze strumienia wejściowego.
* <li> Jeśli żadne z powyższych stwierdzeń nie jest prawdziwe, a wiadomość
* przekazywana jest przy pomocy nietrwałego połączenia HTTP to jej koniec
* będzie oznaczony przez zamknięcie połączenia przez drugą stronę.
* </ol>
* <p>
* Jeśli odbieramy dane z serwera, który wykorzystuje sposób numer 3,
* a musi przesłać je do klienta przy pomocy trwałego połączenia HTTP
* metoda automatycznie zaczyna kodować dane w locie jako "chunked".
* <p>
* Niezależnie od sytuacji i formatu odbieranych danych, dane zawsze zapisywane są
* wewnątrz obiektu w formie "ciągłej", ze "zdjętym" Transfer Encoding.
*
* @param in strumień wejściowy z którego będą odczytywane dane
* @param header nagłówek wiadomości, której "ciało" chcemy odczytać ze strumienia
* @param out strumień wyjściowy na który na bierząco będą przekazywane odczytywane dane
* @param request nagłówek wiadomości na którą odpowiedzią jest właśnie odczytywana
* wiadomość, lub {@code null} jeśli nie dotyczy.
*/
public MessageBody(LudInputStream in, Header header, OutputStream out, RequestHeader request) throws HttpError, IOException {
boolean noBody = false;
if(header instanceof ResponseHeader) {
// Odpowiedzi na zapytanie typu HEAD
// oraz odpowiedzi 1xx, 204, 304 nie mają ciała
ResponseHeader rh = (ResponseHeader) header;
if((request!=null && request.getMethod().equals("HEAD"))
|| rh.getStatus()/100==1
|| rh.getStatus()==204
|| rh.getStatus()==304) {
noBody = true;
}
}
if(noBody) {
body = new byte[]{};
header.setField("Content-Length", 0+"");
} else if(header.containsField("Transfer-Encoding") && !header.fieldContainsValue("Transfer-Encoding", "identity")) {
// treść "pokawałkowana" (chunked)
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
int chunkLen;
byte[] bytes;
String chunkHeader="";
try {
do {
// Odczytujemy nagłówek fragmentu, mówiący ile danych
// mamy do odczytania w danym fragmencie
while((chunkHeader = in.readLine()) != null && chunkHeader.equals("")) {};
if(chunkHeader==null) break; //połączenie zakończone
/*
* W nagłówku fragmentu, po liczbie bajtów do odczytania mogą być oddzielone
* średnikiem rozszerzenia. Nas interesuje wyłącznie liczba.
*/
chunkLen = Integer.parseInt(chunkHeader.split("\\s*;")[0], 16);
// odczytujemy dokładnie tyle bajtów ile nam pozwolił nagłówek fragmentu
bytes = in.forwardAndRead(chunkLen, out, true);
if(bytes==null) break; //połączenie zakończone
tmp.write(bytes);
} while(chunkLen > 0);
// wyślij nagłówek końca wiadomości typu chunked:
if(out!=null) out.write((0 + "\r\n\r\n").getBytes());
// Po treści mogą być dodatkowe nagłówki ("trailing headers"):
if(header.containsField("Trailer")) header.getFieldsFromStream(in);
body = tmp.toByteArray();
// dostosuj nagłówek do tego w jakiej postaci właśnie zapisaliśmy ciało:
header.removeField("Trailer");
header.removeField("Transfer-Encoding");
header.setField("Content-Length", body.length+"");
} catch(NumberFormatException e) {
throw new HttpBadGateway("Długość danych określona w nagłówkach chunked nie jest poprawną liczbą (?!)");
}
} else if(header.containsField("Content-Length")) {
// Pobieramy z strumienia dokładnie tyle ile określono w Content-Length
try {
body = in.forwardAndRead(Integer.parseInt(header.getField("Content-Length")), out);
} catch(NumberFormatException e) {
throw new HttpBadGateway("Długość danych określona w nagłówku nie jest poprawną liczbą (?!)");
}
} else if(header instanceof ResponseHeader && (
header.fieldContainsValue("Connection", "close") || (!header.containsField("Connection") && header.getProtocolVersion().equals("1.0")))) {
// Ojoj. Jaki nieczytelny ten if().
// Chodzi o to, że jest to odpowiedź w nietrwałym połączeniu,
// więc o końcu wiadomości można zorientować się po tym, że serwer zamknął połączenie
// Jeśli używamy trwałego połączenia z klietem to trzeba będzie mu to przekazać jako chunked
boolean usingChunked = (request!=null && request.keepAlive());
body = in.forwardAndRead(-1, out, usingChunked);
// wyślij nagłówek końca wiadomości typu chunked:
if(usingChunked && out!=null) out.write((0 + "\r\n\r\n").getBytes());
// teraz już znamy długość, więc zapiszmy ją w nagłówku!
header.setField("Content-Length", body.length+"");
} else if(header instanceof RequestHeader){
// zapytanie bez ciała, ok
body = new byte[]{};
header.setField("Content-Length", 0+"");
} else {
throw new HttpBadGateway("Otrzymano za mało informacji żeby stwierdzić długość odpowiedzi");
}
}
/**
* Zwraca "ciało" wiadomości <SUF>*/
public byte[] getBytes() {
return body;
}
/**
* Zwraca długość wiadomości (w bajtach)
* @return długość wiadomości
*/
public int length() {
return body.length;
}
}
| t |
4957_0 | lusniam/object-oriented-programming-java | 546 | lab1/lab1.java | package lab1;
public class lab1
{
public static void main( String[] args )
{
System.out.println( "1.1" );
System.out.println( "Ucze sie programowania 5 lat, znam 5 jezykow, moj ulubiony to python" );
System.out.println( "1.2" );
int x, y;
int z = 12;
double i = 2.45;
char znak = 'z';
double j;
x = 0;
y = 444;
j = 0.002;
System.out.print("x = "+ x +", y = "+ y +", z = "+ z );
System.out.println( "Nie wypisano zmiennych i = "+ i +", znak = "+ znak +" oraz j = "+ j );
int zmienna1;
String zmienna2;
zmienna1 = 1;
zmienna2 = "tekst";
System.out.println( "zmienna1 = "+ zmienna1 +", zmienna2 = "+ zmienna2 );
System.out.println( "1.3" );
System.out.printf("i=%4.1f, j=%8.2e, x=%6d znak:%c\n", i, j, x, znak);
//i będzie wyświetlone na 4 pozycjach z jedną cyfrą po kropce
//j będzie wyświetlone na 8 pozycjach z dwoma cyframi po kropce w formacie zmiennopozycyjnym
//x będzie wyświetlone na 6 pozycjach (spacje z przodu)
//znak będzie wyświetlony jako pojedynczy znak
System.out.println( "Po zmianach:" );
System.out.printf("i=%4.5e, j=%8.5e, x=%6d znak:%c\n", i, j, x, znak);
}
}
| //i będzie wyświetlone na 4 pozycjach z jedną cyfrą po kropce
| package lab1;
public class lab1
{
public static void main( String[] args )
{
System.out.println( "1.1" );
System.out.println( "Ucze sie programowania 5 lat, znam 5 jezykow, moj ulubiony to python" );
System.out.println( "1.2" );
int x, y;
int z = 12;
double i = 2.45;
char znak = 'z';
double j;
x = 0;
y = 444;
j = 0.002;
System.out.print("x = "+ x +", y = "+ y +", z = "+ z );
System.out.println( "Nie wypisano zmiennych i = "+ i +", znak = "+ znak +" oraz j = "+ j );
int zmienna1;
String zmienna2;
zmienna1 = 1;
zmienna2 = "tekst";
System.out.println( "zmienna1 = "+ zmienna1 +", zmienna2 = "+ zmienna2 );
System.out.println( "1.3" );
System.out.printf("i=%4.1f, j=%8.2e, x=%6d znak:%c\n", i, j, x, znak);
//i będzie <SUF>
//j będzie wyświetlone na 8 pozycjach z dwoma cyframi po kropce w formacie zmiennopozycyjnym
//x będzie wyświetlone na 6 pozycjach (spacje z przodu)
//znak będzie wyświetlony jako pojedynczy znak
System.out.println( "Po zmianach:" );
System.out.printf("i=%4.5e, j=%8.5e, x=%6d znak:%c\n", i, j, x, znak);
}
}
| t |
10349_0 | maciejtbg/WeddingInvitation | 1,104 | src/main/java/com/wedding/invitation/controllers/EditController.java | package com.wedding.invitation.controllers;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wedding.invitation.dtos.ImageUploadDto;
import com.wedding.invitation.models.UserAccount;
import com.wedding.invitation.services.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Optional;
@Controller
public class EditController {
private final UserAccountService userAccountService;
private final EventService eventService;
private final WishService wishService;
private final FacilityService facilityService;
private final ImageService imageService;
private final GalleryService galleryService;
private final WeddingMediaService weddingMediaService;
private final SimpleDateFormat simpleDateFormat;
@Autowired
public EditController(UserAccountService userAccountService, EventService eventService, WishService wishService, FacilityService facilityService, ImageService imageGalleryService, GalleryService galleryService, WeddingMediaService weddingMediaService, SimpleDateFormat simpleDateFormat) {
this.userAccountService = userAccountService;
this.eventService = eventService;
this.wishService = wishService;
this.facilityService = facilityService;
this.imageService = imageGalleryService;
this.galleryService = galleryService;
this.weddingMediaService = weddingMediaService;
this.simpleDateFormat = simpleDateFormat;
}
@GetMapping("/{alias}/edit")
public String edit (Model model, @PathVariable String alias) {
Optional<UserAccount> userAccountOptional = userAccountService.getUserByAlias(alias);
if (userAccountOptional.isPresent()) {
UserAccount userAccount = userAccountOptional.get();
model.addAttribute("alias",alias);
model.addAttribute("backgroundTop", userAccount.getWeddingMedia().getBackgroundTop());
return "edit";
}else {
return null;
}
}
@ResponseBody
@PostMapping(value = "{alias}/upload", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
public ResponseEntity<?> upload(ImageUploadDto.ImageValues imageValuesUploadDto, @PathVariable String alias) throws IOException {
return weddingMediaService.uploadImage(imageValuesUploadDto,alias);
}
//Ten kod może się przydać gdy będę wysyłał zdjęcie w formularzu HTML
// @ResponseBody
// @PostMapping(value = "{alias}/upload", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
// public String upload(ImageUploadDto imageUploadDto, @PathVariable String alias) throws IOException {
// ObjectMapper objectMapper = new ObjectMapper();
// ImageUploadDto.ImageValues imageValues = objectMapper.readValue(imageUploadDto.getImage_values(), ImageUploadDto.ImageValues.class);
// String base64ImageWithoutHeader = imageValues.getData().split(",")[1];
// // Dekodowanie base64 do tablicy bajtów
// byte[] imageBytes = Base64.getDecoder().decode(base64ImageWithoutHeader);
//
// System.out.println(imageValues.getName());
// String imageName;
// if (imageValues.getName().contains(alias)){
// imageName = imageValues.getName().substring(imageValues.getName().indexOf(alias)+alias.length()+1);
// } else {
// imageName = imageValues.getName();
// }
// Path path = Path.of(UPLOAD_DIR+alias+'/'+"POST_"+imageName);
// Files.write(path, imageBytes);
//
// return "Obraz został pomyślnie przesłany";
// }
}
| //Ten kod może się przydać gdy będę wysyłał zdjęcie w formularzu HTML | package com.wedding.invitation.controllers;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wedding.invitation.dtos.ImageUploadDto;
import com.wedding.invitation.models.UserAccount;
import com.wedding.invitation.services.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Optional;
@Controller
public class EditController {
private final UserAccountService userAccountService;
private final EventService eventService;
private final WishService wishService;
private final FacilityService facilityService;
private final ImageService imageService;
private final GalleryService galleryService;
private final WeddingMediaService weddingMediaService;
private final SimpleDateFormat simpleDateFormat;
@Autowired
public EditController(UserAccountService userAccountService, EventService eventService, WishService wishService, FacilityService facilityService, ImageService imageGalleryService, GalleryService galleryService, WeddingMediaService weddingMediaService, SimpleDateFormat simpleDateFormat) {
this.userAccountService = userAccountService;
this.eventService = eventService;
this.wishService = wishService;
this.facilityService = facilityService;
this.imageService = imageGalleryService;
this.galleryService = galleryService;
this.weddingMediaService = weddingMediaService;
this.simpleDateFormat = simpleDateFormat;
}
@GetMapping("/{alias}/edit")
public String edit (Model model, @PathVariable String alias) {
Optional<UserAccount> userAccountOptional = userAccountService.getUserByAlias(alias);
if (userAccountOptional.isPresent()) {
UserAccount userAccount = userAccountOptional.get();
model.addAttribute("alias",alias);
model.addAttribute("backgroundTop", userAccount.getWeddingMedia().getBackgroundTop());
return "edit";
}else {
return null;
}
}
@ResponseBody
@PostMapping(value = "{alias}/upload", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
public ResponseEntity<?> upload(ImageUploadDto.ImageValues imageValuesUploadDto, @PathVariable String alias) throws IOException {
return weddingMediaService.uploadImage(imageValuesUploadDto,alias);
}
//Ten kod <SUF>
// @ResponseBody
// @PostMapping(value = "{alias}/upload", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
// public String upload(ImageUploadDto imageUploadDto, @PathVariable String alias) throws IOException {
// ObjectMapper objectMapper = new ObjectMapper();
// ImageUploadDto.ImageValues imageValues = objectMapper.readValue(imageUploadDto.getImage_values(), ImageUploadDto.ImageValues.class);
// String base64ImageWithoutHeader = imageValues.getData().split(",")[1];
// // Dekodowanie base64 do tablicy bajtów
// byte[] imageBytes = Base64.getDecoder().decode(base64ImageWithoutHeader);
//
// System.out.println(imageValues.getName());
// String imageName;
// if (imageValues.getName().contains(alias)){
// imageName = imageValues.getName().substring(imageValues.getName().indexOf(alias)+alias.length()+1);
// } else {
// imageName = imageValues.getName();
// }
// Path path = Path.of(UPLOAD_DIR+alias+'/'+"POST_"+imageName);
// Files.write(path, imageBytes);
//
// return "Obraz został pomyślnie przesłany";
// }
}
| t |
3936_3 | macvek/Tanks10 | 791 | src/main/java/tanks10/Logger.java | /*
This file is part of Tanks10 Project (https://github.com/macvek/Tanks10).
Tanks10 Project is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Tanks10 Project is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Tanks10 Project. If not, see <http://www.gnu.org/licenses/>.
*/
package tanks10;
import java.util.*;
import tanks10.mocked.JSObject;
/**
* @author Macvek
*
* Klasa debugerska, do zapamiętania komunikatów wysyłanych przez applet
* i gdy zostanie do niej podłączony obiekt wyjściowy, to wysyła do niego
* informacje. W tym przypadku wyjściem będzie obiekt javascriptu
* w przeglądarce
*/
public class Logger {
private ArrayList<String> buffer = new ArrayList<String>();
private JSObject console;
/**
* Wywoływane po dołączeniu konsoli.
* Wysyła całą zawartość bufora do konsoli
*/
private void flushBuffer() {
for(String tmp : this.buffer) {
writeToConsole(tmp);
}
}
private void writeToConsole(String in) {
// Wywoływane zawsze z ustawioną konsolą
console.call("write", new String[]{in});
}
/**
* Dodanie konsoli i wysłanie jej zawartości bufora.
* Konsola to obiekt JS z zaimplementowaną metodą write()
* @param inConsole
*/
public void attachConsole(JSObject inConsole) {
if (inConsole == null)
return;
console = inConsole;
flushBuffer();
}
/**
* Odłączenie konsoli
*/
public void detachConsole() {
console = null;
}
/**
* Dodanie tekstu, zostanie wysłany do konsoli lub zapamiętany
* w buforze
* @param in
*/
public void log(String in) {
// brak konsoli, dodaj wpis do bufora
if (console == null) {
buffer.add(in);
}
// jest podłączona konsola, więc wywołaj jej metodę write()
else {
writeToConsole(in);
}
}
}
| // Wywoływane zawsze z ustawioną konsolą | /*
This file is part of Tanks10 Project (https://github.com/macvek/Tanks10).
Tanks10 Project is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Tanks10 Project is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Tanks10 Project. If not, see <http://www.gnu.org/licenses/>.
*/
package tanks10;
import java.util.*;
import tanks10.mocked.JSObject;
/**
* @author Macvek
*
* Klasa debugerska, do zapamiętania komunikatów wysyłanych przez applet
* i gdy zostanie do niej podłączony obiekt wyjściowy, to wysyła do niego
* informacje. W tym przypadku wyjściem będzie obiekt javascriptu
* w przeglądarce
*/
public class Logger {
private ArrayList<String> buffer = new ArrayList<String>();
private JSObject console;
/**
* Wywoływane po dołączeniu konsoli.
* Wysyła całą zawartość bufora do konsoli
*/
private void flushBuffer() {
for(String tmp : this.buffer) {
writeToConsole(tmp);
}
}
private void writeToConsole(String in) {
// Wywoływane zawsze <SUF>
console.call("write", new String[]{in});
}
/**
* Dodanie konsoli i wysłanie jej zawartości bufora.
* Konsola to obiekt JS z zaimplementowaną metodą write()
* @param inConsole
*/
public void attachConsole(JSObject inConsole) {
if (inConsole == null)
return;
console = inConsole;
flushBuffer();
}
/**
* Odłączenie konsoli
*/
public void detachConsole() {
console = null;
}
/**
* Dodanie tekstu, zostanie wysłany do konsoli lub zapamiętany
* w buforze
* @param in
*/
public void log(String in) {
// brak konsoli, dodaj wpis do bufora
if (console == null) {
buffer.add(in);
}
// jest podłączona konsola, więc wywołaj jej metodę write()
else {
writeToConsole(in);
}
}
}
| t |
9396_1 | mahcinek/Bankomat | 2,146 | src/Bank.java | import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
/**
* Chyba najciekawsz klasa Bank, tutaj jest sporo zabawy
*
* Jakby się coś nie wypisywało DO LOGA TO DAJ ZNAC bo mogłem o czymś zapomnieć
*/
public class Bank {
ArrayList<Bankomat> bankomaty; //bank ma listę bankomatów i klientów
ArrayList<Klient> klienci;
private int licznik =0; //pomocniczy licznik do blokowania karty
private boolean pom=false; //zmienna pomocnicza do zmiany stanu konta
public Bank ()
{
bankomaty=new ArrayList<Bankomat>();
klienci=new ArrayList<Klient>();
}
public void dodajKlienta (Klient klient)
{
if (!klienci.contains(klient))
klienci.add(klient);
}
boolean menu() { //menu na switchu
System.out.println("Witamy!");
System.out.println("Jaką operację chesz wykonać? (Podaj cyfrę)");
Scanner sc=new Scanner(System.in);
System.out.println("1.Wypłacić pieniądze");
System.out.println("2. Jesteś pracownikiem i wpłacasz pieniądze do bankomatu");
System.out.println("3.Sprawdź stan bankomatu");
System.out.println("4. Wyjdź");
int wyb=sc.nextInt();
switch (wyb) //Tak tutaj zaczyna się zabawa
/*
* pobieramy klienta poprzez autoryzację
* jak go się nie udało pobrać włączmy menu raz jeszcze jak licznik>2 blokujemy kartę z zapisem do loga
* */
{
case 1:{Klient a =autoryzacja(); Bankomat b=null; if (a==null) return( menu()); if(a!=null&&licznik>2) {System.out.println("Zablokowano kartę");
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
pw.println("Zablokowano kartę");pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
/*
* Niestety złe hasło blokowane jest przez pomocniczego użytkownika, bo nie bardzo byłem w stanie to już obejść
* Dalej jeżeli hasło jest dobre odpalamy wybór bankomatu
* Pobieramy od użytkownika kwotę, tutaj sprawdzamy czy jest hajs, jak jest prosimy bankomat o wypłatę, jak nie błąd, wpisujemy do logu i znowu menu
* ewentualne błędy bankomatu załatwione są w bankomacie
* */
return false; } if (a.getPassword().equals("zły")) return (menu()); { b= wybierzBankomat();} licznik=0; System.out.println("Podaj kwotę"); int kw = sc.nextInt(); if (a.hasMoney(kw)) {pom=b.wypiszWyplate(kw);}else if (!a.hasMoney(kw)) {System.out.println("Brak wystarczających środków");
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
if (!a.hasMoney(kw)) pw.println("Brak wystarczjących środków na koncie");
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}}
/*
* Miliony warunków na zmiane salda na koncie, nawet już wszystkich nie pamiętam, ale działa. Dalej wypisujemy stan konta. Zamykamy po drodze też strumienie. Te zamknięcia w sumie nie są takie istotne, bo wszędzie je i tak zamykam dodatkowo.
* */
if (!pom&&b.getPom()&&a.getBalance()>0)a.setBalance(a.getBalance()-kw); System.out.println("Pozostały stan konta to" + a.getBalance()); b.zamknij(); return(menu()); }
/*
* Proste dodawanie hajksu do bankomatu po kolei ilość banknotów po wybraniu bankomatu wcześniej
* */
case 2:{Bankomat b=wybierzBankomat(); System.out.println("Podaj ilość 200"); b.wplacPub(200,sc.nextInt()); System.out.println("Podaj ilość 100"); b.wplacPub(100,sc.nextInt()); System.out.println("Podaj ilość 50"); b.wplacPub(50,sc.nextInt()); System.out.println("Podaj ilość 20"); b.wplacPub(20,sc.nextInt()); System.out.println("Podaj ilość 10"); b.wplacPub(10,sc.nextInt());b.zamknij(); return( menu());}
case 4:return false; //wyjście
case 3:{Bankomat b=wybierzBankomat(); b.stan(); return true;} //sprawdzamy stan bankomatu
}
return false;
}
private Bankomat wybierzBankomat () //wypisujemy bnkomaty i zwracamy wybrany
{
int i=0;
for (Bankomat b:bankomaty)
{
System.out.println(i + " "+ b.getNazwa());
i++;
}
Scanner sc=new Scanner(System.in);
System.out.println("Który bankomat wybierasz? (Podaj numer)");
return bankomaty.get(sc.nextInt());
}
private Klient autoryzacja() //autoryzacja klienta sprawdzamy czy jest jest nik i czy pasuje hasło
{
ArrayList<Klient> kl = klienci;
System.out.println("Podaj NIK");
Scanner sc = new Scanner(System.in);
int a =sc.nextInt();
Klient wybr= null;
for (Klient kli:kl)
{
if (kli.getNik()==a) wybr=kli;
}
if (wybr==null){System.out.println("Nie ma takiego klienta");
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
pw.println("Klienta o niku " +a);
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;}
System.out.println("Podaj hasło");
if (sc.next().equals(wybr.getPassword()))
/*Sprawdzamy hasło*/
return wybr;
else
{
licznik++;
int u=3-licznik;
System.out.println("Błędne hasło");
System.out.println("Pozostało prób: " +u);
/*Te dziwne znaczki try catch to konieczna obsługa błędów dla wyjścia do pliku*/
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
pw.println("Błędane hasło");
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return new Klient(1,"zły",-1000.0); //przy złym haśle zwracamy pomocniczego klienta niestety
}
}
}
| //bank ma listę bankomatów i klientów | import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
/**
* Chyba najciekawsz klasa Bank, tutaj jest sporo zabawy
*
* Jakby się coś nie wypisywało DO LOGA TO DAJ ZNAC bo mogłem o czymś zapomnieć
*/
public class Bank {
ArrayList<Bankomat> bankomaty; //bank ma <SUF>
ArrayList<Klient> klienci;
private int licznik =0; //pomocniczy licznik do blokowania karty
private boolean pom=false; //zmienna pomocnicza do zmiany stanu konta
public Bank ()
{
bankomaty=new ArrayList<Bankomat>();
klienci=new ArrayList<Klient>();
}
public void dodajKlienta (Klient klient)
{
if (!klienci.contains(klient))
klienci.add(klient);
}
boolean menu() { //menu na switchu
System.out.println("Witamy!");
System.out.println("Jaką operację chesz wykonać? (Podaj cyfrę)");
Scanner sc=new Scanner(System.in);
System.out.println("1.Wypłacić pieniądze");
System.out.println("2. Jesteś pracownikiem i wpłacasz pieniądze do bankomatu");
System.out.println("3.Sprawdź stan bankomatu");
System.out.println("4. Wyjdź");
int wyb=sc.nextInt();
switch (wyb) //Tak tutaj zaczyna się zabawa
/*
* pobieramy klienta poprzez autoryzację
* jak go się nie udało pobrać włączmy menu raz jeszcze jak licznik>2 blokujemy kartę z zapisem do loga
* */
{
case 1:{Klient a =autoryzacja(); Bankomat b=null; if (a==null) return( menu()); if(a!=null&&licznik>2) {System.out.println("Zablokowano kartę");
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
pw.println("Zablokowano kartę");pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
/*
* Niestety złe hasło blokowane jest przez pomocniczego użytkownika, bo nie bardzo byłem w stanie to już obejść
* Dalej jeżeli hasło jest dobre odpalamy wybór bankomatu
* Pobieramy od użytkownika kwotę, tutaj sprawdzamy czy jest hajs, jak jest prosimy bankomat o wypłatę, jak nie błąd, wpisujemy do logu i znowu menu
* ewentualne błędy bankomatu załatwione są w bankomacie
* */
return false; } if (a.getPassword().equals("zły")) return (menu()); { b= wybierzBankomat();} licznik=0; System.out.println("Podaj kwotę"); int kw = sc.nextInt(); if (a.hasMoney(kw)) {pom=b.wypiszWyplate(kw);}else if (!a.hasMoney(kw)) {System.out.println("Brak wystarczających środków");
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
if (!a.hasMoney(kw)) pw.println("Brak wystarczjących środków na koncie");
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}}
/*
* Miliony warunków na zmiane salda na koncie, nawet już wszystkich nie pamiętam, ale działa. Dalej wypisujemy stan konta. Zamykamy po drodze też strumienie. Te zamknięcia w sumie nie są takie istotne, bo wszędzie je i tak zamykam dodatkowo.
* */
if (!pom&&b.getPom()&&a.getBalance()>0)a.setBalance(a.getBalance()-kw); System.out.println("Pozostały stan konta to" + a.getBalance()); b.zamknij(); return(menu()); }
/*
* Proste dodawanie hajksu do bankomatu po kolei ilość banknotów po wybraniu bankomatu wcześniej
* */
case 2:{Bankomat b=wybierzBankomat(); System.out.println("Podaj ilość 200"); b.wplacPub(200,sc.nextInt()); System.out.println("Podaj ilość 100"); b.wplacPub(100,sc.nextInt()); System.out.println("Podaj ilość 50"); b.wplacPub(50,sc.nextInt()); System.out.println("Podaj ilość 20"); b.wplacPub(20,sc.nextInt()); System.out.println("Podaj ilość 10"); b.wplacPub(10,sc.nextInt());b.zamknij(); return( menu());}
case 4:return false; //wyjście
case 3:{Bankomat b=wybierzBankomat(); b.stan(); return true;} //sprawdzamy stan bankomatu
}
return false;
}
private Bankomat wybierzBankomat () //wypisujemy bnkomaty i zwracamy wybrany
{
int i=0;
for (Bankomat b:bankomaty)
{
System.out.println(i + " "+ b.getNazwa());
i++;
}
Scanner sc=new Scanner(System.in);
System.out.println("Który bankomat wybierasz? (Podaj numer)");
return bankomaty.get(sc.nextInt());
}
private Klient autoryzacja() //autoryzacja klienta sprawdzamy czy jest jest nik i czy pasuje hasło
{
ArrayList<Klient> kl = klienci;
System.out.println("Podaj NIK");
Scanner sc = new Scanner(System.in);
int a =sc.nextInt();
Klient wybr= null;
for (Klient kli:kl)
{
if (kli.getNik()==a) wybr=kli;
}
if (wybr==null){System.out.println("Nie ma takiego klienta");
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
pw.println("Klienta o niku " +a);
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;}
System.out.println("Podaj hasło");
if (sc.next().equals(wybr.getPassword()))
/*Sprawdzamy hasło*/
return wybr;
else
{
licznik++;
int u=3-licznik;
System.out.println("Błędne hasło");
System.out.println("Pozostało prób: " +u);
/*Te dziwne znaczki try catch to konieczna obsługa błędów dla wyjścia do pliku*/
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("log.log", true)));
pw.println("Błędane hasło");
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return new Klient(1,"zły",-1000.0); //przy złym haśle zwracamy pomocniczego klienta niestety
}
}
}
| t |
9329_0 | majesia/Lab2_gui_swing_1 | 380 | src/tb/soft/MainWindow.java | package tb.soft;
import javax.swing.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* klasa główna zawierająca metodę statyczną main
*/
/*
jframe
guziki ok oraz clear (Login/cancel)
okienko logowania (textfieldy login, haslo (zahaslowane JPasswordField))
funkcja main odpowiednio mała, invokeLater wywolywany
login powinien sprawdzic w "bazie danych" (kolekcji, mapa spk)
jesli login i haslo poprawne to tlo okienka zmienia sie na zielone
jesli nie zgadzaja to sie robi czerwone i np dostajemy druga probe. Po 3 probach cala aplikacja sie zamyka.
clear - reset i kolejna proba, zamkniecie aplikacji krzyzykiem
kontrolka hasla nie mma operacji gettext i nie wolno pobierac z tego textu dlatego ze string pamieta sie w pamieci nawet op zamknieciu aplikacji
getpassword zamiast tego
porownujemy hasla znak po znaku
*/
public class MainWindow {
public static void main(String[] args) {
Window okno= new Window();
okno.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
okno.setVisible(true);
}
}
| /**
* klasa główna zawierająca metodę statyczną main
*/ | package tb.soft;
import javax.swing.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* klasa główna zawierająca <SUF>*/
/*
jframe
guziki ok oraz clear (Login/cancel)
okienko logowania (textfieldy login, haslo (zahaslowane JPasswordField))
funkcja main odpowiednio mała, invokeLater wywolywany
login powinien sprawdzic w "bazie danych" (kolekcji, mapa spk)
jesli login i haslo poprawne to tlo okienka zmienia sie na zielone
jesli nie zgadzaja to sie robi czerwone i np dostajemy druga probe. Po 3 probach cala aplikacja sie zamyka.
clear - reset i kolejna proba, zamkniecie aplikacji krzyzykiem
kontrolka hasla nie mma operacji gettext i nie wolno pobierac z tego textu dlatego ze string pamieta sie w pamieci nawet op zamknieciu aplikacji
getpassword zamiast tego
porownujemy hasla znak po znaku
*/
public class MainWindow {
public static void main(String[] args) {
Window okno= new Window();
okno.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
okno.setVisible(true);
}
}
| t |