Unnamed: 0
int64 0
859
| file_id
stringlengths 5
9
| repo
stringlengths 8
57
| token_length
int64 60
7.97k
| path
stringlengths 8
103
| content
stringlengths 168
26.5k
| original_comment
stringlengths 15
5.13k
| prompt
stringlengths 122
26.4k
| Excluded
stringclasses 1
value | Unnamed: 8
float64 |
|---|---|---|---|---|---|---|---|---|---|
273 | 5685_0 | PJONTAZ99/ZadaniazJAVASDA | 391 | src/main/java/Zadanie7.java | import java.util.Scanner;
public class Zadanie7 {
/*
Napisz program, który pobiera imie od użytkownika, najpierw jednak wypisze na ekran słowa "Podaj swoje imie".
Imię powinno zostać wydrukowane na ekran.
Jeśli podane imię zgadza się z "John Wick",
to na ekran program powinien wypisać "Widzę, że znów pracujesz John",
w przeciwnym przypadku program powinien wydrukować na ekran "Witaj, [xyz]",
gdzie [xyz], powinno zostać zastąpione wartością podaną przez użytkownika.
*/
public static void main(String[] args) {
String specialName = "John Wick";//specjalne imie
System.out.println("Podaj swoje imie");
Scanner scanner = new Scanner(System.in);
String imie = scanner.nextLine();//pobranie od użytkownika
System.out.println("Twoje imię to "+ imie);
if (specialName.contains(imie))//Warunek sprawdza czy imie zawiera się w specjanym imieniu
{
System.out.println("Widzę, że znów pracujesz John");
}
else {
System.out.println("Witaj, "+ imie);
}
}
}
| /*
Napisz program, który pobiera imie od użytkownika, najpierw jednak wypisze na ekran słowa "Podaj swoje imie".
Imię powinno zostać wydrukowane na ekran.
Jeśli podane imię zgadza się z "John Wick",
to na ekran program powinien wypisać "Widzę, że znów pracujesz John",
w przeciwnym przypadku program powinien wydrukować na ekran "Witaj, [xyz]",
gdzie [xyz], powinno zostać zastąpione wartością podaną przez użytkownika.
*/ | import java.util.Scanner;
public class Zadanie7 {
/*
Napisz program, który <SUF>*/
public static void main(String[] args) {
String specialName = "John Wick";//specjalne imie
System.out.println("Podaj swoje imie");
Scanner scanner = new Scanner(System.in);
String imie = scanner.nextLine();//pobranie od użytkownika
System.out.println("Twoje imię to "+ imie);
if (specialName.contains(imie))//Warunek sprawdza czy imie zawiera się w specjanym imieniu
{
System.out.println("Widzę, że znów pracujesz John");
}
else {
System.out.println("Witaj, "+ imie);
}
}
}
| f | null |
276 | 9059_3 | PMerdala/algorithms4 | 1,435 | src/main/java/pl/pmerdala/algs4/std/StdRandom.java | package pl.pmerdala.algs4.std;
import java.util.Random;
public class StdRandom {
private Random random = new Random();
/**
* ustawnienie ziarna pzowala na generowanie zawsze takich samych danych wejściowych
*
* @param seed
*/
public void setSeed(long seed) {
random = new Random(seed);
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double random() {
return random.nextDouble();
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double uniform() {
return random.nextDouble();
}
/**
* Generownaie liczby pseudolosowej całkowitej z przediału [0,(n-1)]
*
* @param n
* @return
*/
public int uniform(int n) {
return random.nextInt(n);
}
/**
* Generownaie liczby pseudolosowej całkowitej z przediału [lo, (hi-1)]
*
* @param lo - najmniejsza wartość, hi - największa wartość
* @return
*/
public int uniform(int lo, int hi) {
return lo + uniform(hi - lo);
}
/**
* Generownaie liczby pseudolosowej reczywistej z przediału [lo - hi)
*
* @param lo, hi
* @return
*/
public double uniform(double lo, double hi) {
return lo + random() * (hi - lo);
}
/**
* Zwraca true z prawdopodobieństwem p
*
* @param p - prawdopodobieństo
* @return
*/
public boolean bernoulli(double p) {
return uniform() < p;
}
/**
* Zwraca true z prawdopodobieństwem 50%
*
* @return
*/
public boolean bernoulli() {
return bernoulli(.5);
}
/**
* Generowanie zmiennych losowych o Rozkładzie normalnym, średnia 0, odch. st. 1
*
* @return
*/
public double gaussian() {
double r, x, y;
do {
x = uniform(-1.0, 1.0);
y = uniform(-1.0, 1.0);
r = x * x + y * y;
} while (r >= 1 || r == 0);
return x * Math.sqrt(-2 * Math.log(r) / r);
}
/**
* Rozkład normalny, średnia m, odch. st. s
*
* @return
*/
public double gaussian(double mean, double stddev) {
return mean + stddev * gaussian();
}
/**
* Generowanie zmiennej całkowitej o rozkładzie geometrycznym ze średnią(mean) 1/p
* użyto algorytmu Knuth
*
* @param p
* @return
*/
public int geometric(double p) {
return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));
}
/**
* Generowanie zmiennej całkowitej o rozkłądznie Poissona ze średnią (mean) lambda.
* uzyto algorytmu Knuth
*
* @param lambda
* @return
* @see "http://en.wikipedia.org/wiki/Poisson_distribution"
*/
public int poisson(double lambda) {
int k = 0;
double p = 1.0;
double L = Math.exp(-lambda);
do {
k++;
p *= uniform();
} while (p >= L);
return k - 1;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie pareto z parametrem podziału alpha
*
* @param alpha
* @return
*/
public double pareto(double alpha) {
return Math.pow(1 - uniform(), -1.0 / alpha) - 1.0;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie cauchy
* @return
*/
public double cauchy(){
return Math.tan(Math.PI*(uniform()-.5));
}
/**
* Zwraca i z prawdopodobieństwem a[i]
*
* @param a tabela z wartościami rzeczyistymi z [rzedziału [0,1)
* @return
*/
public int discrete(double[] a) {
double r = uniform();
double sum = 0.0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
if(sum>=r) return i;
}
assert(false);
return -1;
}
/**
* Losowo porządkuje elementy tablicy a[]
*
* @param a
*/
public void shuffle(double[] a) {
}
}
| /**
* Generownaie liczby pseudolosowej całkowitej z przediału [0,(n-1)]
*
* @param n
* @return
*/ | package pl.pmerdala.algs4.std;
import java.util.Random;
public class StdRandom {
private Random random = new Random();
/**
* ustawnienie ziarna pzowala na generowanie zawsze takich samych danych wejściowych
*
* @param seed
*/
public void setSeed(long seed) {
random = new Random(seed);
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double random() {
return random.nextDouble();
}
/**
* Generowanie liczby pseudolosowej rzeczywistej z przedziału [0,1)
*
* @return
*/
public double uniform() {
return random.nextDouble();
}
/**
* Generownaie liczby pseudolosowej <SUF>*/
public int uniform(int n) {
return random.nextInt(n);
}
/**
* Generownaie liczby pseudolosowej całkowitej z przediału [lo, (hi-1)]
*
* @param lo - najmniejsza wartość, hi - największa wartość
* @return
*/
public int uniform(int lo, int hi) {
return lo + uniform(hi - lo);
}
/**
* Generownaie liczby pseudolosowej reczywistej z przediału [lo - hi)
*
* @param lo, hi
* @return
*/
public double uniform(double lo, double hi) {
return lo + random() * (hi - lo);
}
/**
* Zwraca true z prawdopodobieństwem p
*
* @param p - prawdopodobieństo
* @return
*/
public boolean bernoulli(double p) {
return uniform() < p;
}
/**
* Zwraca true z prawdopodobieństwem 50%
*
* @return
*/
public boolean bernoulli() {
return bernoulli(.5);
}
/**
* Generowanie zmiennych losowych o Rozkładzie normalnym, średnia 0, odch. st. 1
*
* @return
*/
public double gaussian() {
double r, x, y;
do {
x = uniform(-1.0, 1.0);
y = uniform(-1.0, 1.0);
r = x * x + y * y;
} while (r >= 1 || r == 0);
return x * Math.sqrt(-2 * Math.log(r) / r);
}
/**
* Rozkład normalny, średnia m, odch. st. s
*
* @return
*/
public double gaussian(double mean, double stddev) {
return mean + stddev * gaussian();
}
/**
* Generowanie zmiennej całkowitej o rozkładzie geometrycznym ze średnią(mean) 1/p
* użyto algorytmu Knuth
*
* @param p
* @return
*/
public int geometric(double p) {
return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));
}
/**
* Generowanie zmiennej całkowitej o rozkłądznie Poissona ze średnią (mean) lambda.
* uzyto algorytmu Knuth
*
* @param lambda
* @return
* @see "http://en.wikipedia.org/wiki/Poisson_distribution"
*/
public int poisson(double lambda) {
int k = 0;
double p = 1.0;
double L = Math.exp(-lambda);
do {
k++;
p *= uniform();
} while (p >= L);
return k - 1;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie pareto z parametrem podziału alpha
*
* @param alpha
* @return
*/
public double pareto(double alpha) {
return Math.pow(1 - uniform(), -1.0 / alpha) - 1.0;
}
/**
* Generowanie zmiennej rzeczywistej o rozkładzie cauchy
* @return
*/
public double cauchy(){
return Math.tan(Math.PI*(uniform()-.5));
}
/**
* Zwraca i z prawdopodobieństwem a[i]
*
* @param a tabela z wartościami rzeczyistymi z [rzedziału [0,1)
* @return
*/
public int discrete(double[] a) {
double r = uniform();
double sum = 0.0;
for (int i = 0; i < a.length; i++) {
sum += a[i];
if(sum>=r) return i;
}
assert(false);
return -1;
}
/**
* Losowo porządkuje elementy tablicy a[]
*
* @param a
*/
public void shuffle(double[] a) {
}
}
| f | null |
278 | 8306_1 | PandkaDEV/TUTORIAL_DATABASE | 298 | TUTORIAL-DATABASE/TUTORIAL/src/main/java/pl/xpawelek/database/manager/UserManager.java | package pl.xpawelek.database.manager;
import org.bukkit.entity.Player;
import pl.xpawelek.database.basic.User;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class UserManager {
public static ConcurrentHashMap<UUID, User> userConcurrentHashMap = new ConcurrentHashMap<>(); // tworzymy mape dzieki ktorej bedziemy mogli przechowywac nasze dane
public static User getUser(Player player){
for(User user : getUserConcurrentHashMap().values()) // pobieramy naszego gracza z wszystkich userow
if(user.getUuid().equals(player.getUniqueId())) // sprawdzamy czy byl kiedys juz w naszej mapie jesli byl zwrocimy mu jego dane
return user;
return new User(player); // jesli gracz nigdy nie byl na serwerze tworzymy go
}
public static ConcurrentHashMap<UUID, User> getUserConcurrentHashMap() {
return userConcurrentHashMap;
}
}
| // pobieramy naszego gracza z wszystkich userow
| package pl.xpawelek.database.manager;
import org.bukkit.entity.Player;
import pl.xpawelek.database.basic.User;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class UserManager {
public static ConcurrentHashMap<UUID, User> userConcurrentHashMap = new ConcurrentHashMap<>(); // tworzymy mape dzieki ktorej bedziemy mogli przechowywac nasze dane
public static User getUser(Player player){
for(User user : getUserConcurrentHashMap().values()) // pobieramy naszego <SUF>
if(user.getUuid().equals(player.getUniqueId())) // sprawdzamy czy byl kiedys juz w naszej mapie jesli byl zwrocimy mu jego dane
return user;
return new User(player); // jesli gracz nigdy nie byl na serwerze tworzymy go
}
public static ConcurrentHashMap<UUID, User> getUserConcurrentHashMap() {
return userConcurrentHashMap;
}
}
| f | null |
280 | 9023_1 | ParfenovichDmitry/Akademia-Envelo | 517 | src/com/task02/Search.java | package com.task02;
public class Search {
public static void main(String[] args) {
int[] numbers = new int[]{45, 1, 1, 1, 0, 0, -3, -5, -48}; //Posortowana tablica w porządku rosnącym
int x = 0; //Liczba
System.out.println(new Search().search(numbers, x)); //Wdrażanie metody search
}
private boolean search(int[] numbers, int x) { //Metoda search
int firstIndex = 0;
int lastIndex = numbers.length - 1;
int midleIndex = (firstIndex + lastIndex) / 2;
/*Jeżeli wartość liczby nie jest większa lub mniejsza niż
maksymalna i minimalna wartości tablicy, to liczba nie może
znajdować się w tej tablicy i nie jest wykonywane dalsze wyszukiwanie.
Złożoność obliczeniową algorytmy O(1), pamięciową O(1)*/
if ((x > numbers[firstIndex]) && (x < numbers[lastIndex])) {
return false;
}
/* Algorytm wyszukiwania binarnego dla podanej liczby.
Z każdą iteracją liczba wyszukiwań zmniejsza się o połowę.
Złożoność obliczeniową algorytmy O(log n), pamięciową O(1)*/
while (firstIndex <= lastIndex) {
if (x == numbers[midleIndex]) {
return true;
} else if (x < numbers[midleIndex]) {
firstIndex = midleIndex + 1;
} else {
lastIndex = midleIndex - 1;
}
midleIndex = (firstIndex + lastIndex) / 2;
}
return false;
}
}
| //Wdrażanie metody search | package com.task02;
public class Search {
public static void main(String[] args) {
int[] numbers = new int[]{45, 1, 1, 1, 0, 0, -3, -5, -48}; //Posortowana tablica w porządku rosnącym
int x = 0; //Liczba
System.out.println(new Search().search(numbers, x)); //Wdrażanie metody <SUF>
}
private boolean search(int[] numbers, int x) { //Metoda search
int firstIndex = 0;
int lastIndex = numbers.length - 1;
int midleIndex = (firstIndex + lastIndex) / 2;
/*Jeżeli wartość liczby nie jest większa lub mniejsza niż
maksymalna i minimalna wartości tablicy, to liczba nie może
znajdować się w tej tablicy i nie jest wykonywane dalsze wyszukiwanie.
Złożoność obliczeniową algorytmy O(1), pamięciową O(1)*/
if ((x > numbers[firstIndex]) && (x < numbers[lastIndex])) {
return false;
}
/* Algorytm wyszukiwania binarnego dla podanej liczby.
Z każdą iteracją liczba wyszukiwań zmniejsza się o połowę.
Złożoność obliczeniową algorytmy O(log n), pamięciową O(1)*/
while (firstIndex <= lastIndex) {
if (x == numbers[midleIndex]) {
return true;
} else if (x < numbers[midleIndex]) {
firstIndex = midleIndex + 1;
} else {
lastIndex = midleIndex - 1;
}
midleIndex = (firstIndex + lastIndex) / 2;
}
return false;
}
}
| f | null |
281 | 2750_0 | Pasjonat90D/Core-Java-for-the-Impatient-Tasks | 249 | src/main/java/com/task/chapter5/task6/Main.java | package com.task.chapter5.task6;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class Main {
public static void main(String[] args) throws IOException {
Path path = Paths.get("cos");
BufferedReader in = null;
try {
in = Files.newBufferedReader(path, StandardCharsets.UTF_8);
String line= "";
while((line = in.readLine())!=null){
}
} catch (IOException ex) {
System.err.println("Przechwycony wyjątek: " + ex.getMessage());
} finally {
if (in != null) {
in.close(); // Ostrzeżenie — może wyrzucić wyjątek
}
}
}
}
| // Ostrzeżenie — może wyrzucić wyjątek | package com.task.chapter5.task6;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class Main {
public static void main(String[] args) throws IOException {
Path path = Paths.get("cos");
BufferedReader in = null;
try {
in = Files.newBufferedReader(path, StandardCharsets.UTF_8);
String line= "";
while((line = in.readLine())!=null){
}
} catch (IOException ex) {
System.err.println("Przechwycony wyjątek: " + ex.getMessage());
} finally {
if (in != null) {
in.close(); // Ostrzeżenie — <SUF>
}
}
}
}
| f | null |
283 | 9390_3 | PatrykZdz/Bazy_g1_PZ | 6,735 | Java powtorka.java | ZAD1
//// Najwaznijesze RECORD Z Konstruktorem
package Zad1;
public record BankAccount(String numerKonta, double saldo) {
public BankAccount(String numerKonta) { // Konstruktor
this(numerKonta,0);
}
}
/// Record z Metoda
package Zad1;
public record Car(String brand,String model, double fuelConsumptionPer100km) {
public double fuelCost(double fuelPrice,double distance) /// Metoda
{
double fuelConsumed = (fuelConsumptionPer100km / 100) * distance;
return fuelConsumed * fuelPrice;
}
}
/// Record Address w Person
public record Person(String firstName, String lastName, Address adres) {
}
package Zad1;
public record Address(String street, int houseNumber, String postalCode, String city) {
}
/// Main
package Zad1;
public class Main {
public static void main(String[] args) {
////Obiekty
BookDT0 book1 = new BookDT0("Tytul1", "Autor1", 20.99,1999);
BookDT0 book2 = new BookDT0("Tytul2","Autor2",21.99,2000);
BookDT0 book3 = new BookDT0("Tytul3","Autor3",22.99,2015);
Address adres1 = new Address("Mikojaki",56,"10-900","Warsaw");
Person person1 = new Person("Adam","Rybak",adres1);
System.out.println(book1);
System.out.println(book2);
System.out.println(book3);
System.out.println(person1);
BankAccount bankAccount1 = new BankAccount("123456789");
System.out.println(bankAccount1);
MusicTrack musicTrack1 = new MusicTrack("Title", "Unknown");
System.out.println(musicTrack1);
Car car1 = new Car("Opel","Astra",10.5);
System.out.println(car1.fuelCost(7.50,300));
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD2 Comparator i comparable
package Zad2;
import java.util.Comparator;
public class IdComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return Integer.compare(o1.id, o2.id);
}
}
package Zad2;
import java.time.LocalDate;
/// implements Comparable<nazwaKlasy> || prawy przycisk i metoda compareTo
public class Ksiazka implements Comparable<Ksiazka> {
public String tytul;
public int liczbaStron;
public LocalDate dataWydania;
public Ksiazka(String tytul, int liczbaStron, LocalDate dataWydania) {
this.tytul = tytul;
this.liczbaStron = liczbaStron;
this.dataWydania = dataWydania;
}
@Override
public String toString() {
return "Ksiazka{" +
"tytul='" + tytul + '\'' +
", liczbaStron=" + liczbaStron +
", dataWydania=" + dataWydania +
'}';
}
@Override
public int compareTo(Ksiazka o) {
return Integer.compare(o.liczbaStron,this.liczbaStron); // Sortowanie wedlug stron malejaca
//return Integer.compare(this.liczbaStron,o.liczbaStron); // Sortowanie wedlug stron rosnoca
}
}
package Zad2;
import java.time.LocalDate;
import java.util.*;
public class Main {
public static void main(String[] args) {
/// Tablica obiektow
Ksiazka[] ksiazkas = {new Ksiazka("Książka1", 200, LocalDate.of(2020, 1, 1)),
new Ksiazka("Książka2", 150, LocalDate.of(2019, 5, 15)),
new Ksiazka("Książka3", 300, LocalDate.of(2022, 8, 20)),
new Ksiazka("Książka4", 180, LocalDate.of(2021, 3, 10))
};
Arrays.sort(ksiazkas); // Sortowanie
System.out.println("Posortowana Lista Malejąco:");
for(int i = 0; i < ksiazkas.length;i++) // Wypisanie
{
System.out.println(ksiazkas[i]);
}
Samochod[] samochods = {new Samochod("Toyota", 50000, 2018),
new Samochod("Ford", 70000, 2019),
new Samochod("Volkswagen", 60000, 2020),
new Samochod("BMW", 45000, 2017)};
Arrays.sort(samochods);
System.out.println();
System.out.println("Posortowana Lista Rosnąco:");
for(int i = 0; i < samochods.length;i++)
{
System.out.println(samochods[i]);
}
/// Lista Tablicowa
List<Zamowienie> zamowienia = new ArrayList<>();
zamowienia.add(new Zamowienie("Produkt1", 5, 25.0));
zamowienia.add(new Zamowienie("Produkt2", 3, 30.0));
zamowienia.add(new Zamowienie("Produkt3", 2, 25.0));
zamowienia.add(new Zamowienie("Produkt4", 4, 20.0));
zamowienia.sort(null);
System.out.println();
System.out.println("Posortowane malejąco według ceny jednostkowej, a przy równości sortowane były rosnąco według ilości");
for(int i = 0; i < zamowienia.size();i++)
{
System.out.println(zamowienia.get(i));
}
List<Order> orders = new ArrayList<>();
orders.add(new Order(1, "Customer1", LocalDate.of(2022, 1, 15)));
orders.add(new Order(2, "Customer2", LocalDate.of(2022, 2, 20)));
orders.add(new Order(3, "Customer3", LocalDate.of(2022, 1, 10)));
orders.add(new Order(4, "Customer4", LocalDate.of(2022, 2, 5)));
orders.add(new Order(5, "Customer5", LocalDate.of(2022, 1, 25)));
Collections.sort(orders,new OrderComparator());////lub tak: orders.sort(new Order2());
System.out.println();
System.out.println("Posortowana Lista:");
for(int i = 0; i < orders.size();i++)
{
System.out.println(orders.get(i));
}
Song[] songs ={new Song("Song1", "Artist1", 180),
new Song("Song2", "Artist2", 220),
new Song("Song3", "Artist3", 200),
new Song("Song4", "Artist4", 180),
new Song("Song5", "Artist5", 240)
};
Arrays.sort(songs,new SongComparator());
System.out.println();
System.out.println("Posortowana tablica:");
for(int i = 0; i < songs.length;i++)
{
System.out.println(songs[i]);
}
List<Student> students = new ArrayList<>();
students.add( new Student(1, "Student1", 4.5));
students.add(new Student(2, "Student2", 3.8));
students.add(new Student(3, "Student3", 4.2));
students.add(new Student(5, "Student5", 4.8));
students.add(new Student(4, "Student4", 4.0));
Collections.sort(students,new AverageGradeComparator());
System.out.println();
for (int i = 0; i < students.size();i++)
{
System.out.println(students.get(i));
}
Collections.sort(students,new IdComparator());
System.out.println();
for (int i = 0; i < students.size();i++)
{
System.out.println(students.get(i));
}
/// NIE DOKONCA
// Utwórz oryginalnego sportowca
// Athlete originalAthlete = new Athlete("John Doe", List.of(60, 62, 58, 61, 59));
// Sklonuj sportowca
// Athlete clonedAthlete = originalAthlete.clone();
// Zmiana czasu na pozycji 3 oryginalnego sportowca
// originalAthlete.setLapTime(2, 55);
// Wyświetl czasy obu sportowców
//System.out.println("Oryginalny sportowiec: " + originalAthlete);
//System.out.println("Sklonowany sportowiec: " + clonedAthlete);
}
}
package Zad2;
import java.util.Comparator;
/// Comparator
public class OrderComparator implements Comparator<Order> {
@Override
public int compare(Order o1, Order o2) {
int dateComparation = o1.orderDate.compareTo(o2.orderDate);
if (dateComparation == 0)
{
return Integer.compare(o1.id, o2.id);
}
return dateComparation;
}
}
package Zad2;
public class Samochod implements Comparable<Samochod> {
public String marka;
public int przebieg;
public int rokProdukcji;
public Samochod(String marka, int przebieg, int rokProdukcji) {
this.marka = marka;
this.przebieg = przebieg;
this.rokProdukcji = rokProdukcji;
}
@Override
public String toString() {
return "Samochod{" +
"marka='" + marka + '\'' +
", przebieg=" + przebieg +
", rokProdukcji=" + rokProdukcji +
'}';
}
@Override
public int compareTo(Samochod o) {
return Integer.compare(this.przebieg,o.przebieg); // Integer.compare( )
}
}
package Zad2;
public class Song {
public String title;
public String artist;
public int duration;
public Song(String title, String artist, int duration) {
this.title = title;
this.artist = artist;
this.duration = duration;
}
@Override
public String toString() {
return "Song{" +
"title='" + title + '\'' +
", artist='" + artist + '\'' +
", duration=" + duration +
'}';
}
}
package Zad2;
import java.util.Comparator;
public class SongComparator implements Comparator<Song>{
@Override
public int compare(Song o1, Song o2) {
int DurationComparation = Integer.compare(o1.duration,o2.duration);
if(DurationComparation == 0)
{
return o1.title.compareTo(o2.title);
}
return DurationComparation;
}
}
package Zad2;
public class Zamowienie implements Comparable<Zamowienie> {
public String nazwaProduktu;
public int ilosc;
public double cenaJednostkowa;
public Zamowienie(String nazwaProduktu, int ilosc, double cenaJednostkowa) {
this.nazwaProduktu = nazwaProduktu;
this.ilosc = ilosc;
this.cenaJednostkowa = cenaJednostkowa;
}
@Override
public String toString() {
return "Zamowienie{" +
"nazwaProduktu='" + nazwaProduktu + '\'' +
", ilosc=" + ilosc +
", cenaJednostkowa=" + cenaJednostkowa +
'}';
}
@Override
public int compareTo(Zamowienie o) {
int comparePrice = Double.compare(o.cenaJednostkowa,this.cenaJednostkowa);
if(comparePrice == 0)
{
Integer.compare(this.ilosc,o.ilosc);
}
return comparePrice;
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD 3 Implentowanie wlasnych Interfaceow
package Zad3;
public interface MediaPlayer {
/// Metody Abstrakcyjne
void play(String trackName);
void pause();
String getCurrentTrack();
}
package Zad3;
public class AudioPlayer implements MediaPlayer{
public String currentTrack;
@Override
public void play(String trackName) {
System.out.println("Gra utwór: " + trackName );
currentTrack = trackName;
}
@Override
public void pause() {
System.out.println("Zatrzymano");
}
@Override
public String getCurrentTrack() {
return currentTrack;
}
}
package Zad3;
public class VideoPlayer implements MediaPlayer{
public String current;
@Override
public void play(String trackName) {
System.out.println("Leci film: "+trackName);
current = trackName;
}
@Override
public void pause() {
System.out.println("Zatrzymano film:" + current);
}
@Override
public String getCurrentTrack() {
return current;
}
}
package Zad3;
public class MediaPlayerTest {
public static void main(String [] args)
{
AudioPlayer audioPlayer1 = new AudioPlayer();
audioPlayer1.play("Eyes-Travis Scoot");
audioPlayer1.pause();
System.out.println(audioPlayer1.getCurrentTrack());
System.out.println();
VideoPlayer videoPlayer1= new VideoPlayer();
videoPlayer1.play("Tenet");
videoPlayer1.pause();
System.out.println(videoPlayer1.getCurrentTrack());
}
}
package Zad3;
public interface VehicleManager {
String startEngine();
int getFuelLevel();
}
package Zad3;
public class Motorcycle implements VehicleManager{
@Override
public String startEngine() {
return "Silnik motocykle uruchomiony";
}
@Override
public int getFuelLevel() {
return 30;
}
}
package Zad3;
public class Car implements VehicleManager {
@Override
public String startEngine() {
return "Silnik samochodu uruchomiony";
}
@Override
public int getFuelLevel() {
return 50;
}
}
package Zad3;
public class VehicleManagerTest {
public static void main(String [] args)
{
Car car1 = new Car();
System.out.println(car1.startEngine());
System.out.println(car1.getFuelLevel());
System.out.println();
Motorcycle motorcycle1 = new Motorcycle();
System.out.println(motorcycle1.startEngine());
System.out.println(motorcycle1.getFuelLevel());
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD 4
package Zad4;
public interface Printer {
void drukuj(String tekst);
}
package Zad4;
public class Biuro {
private Printer printer; /// INterface jako zmienna
public Biuro(Printer printer) {
this.printer = printer;
}
public void drukujDokument(String tekst)
{
printer.drukuj(tekst);
}
}
package Zad4;
public class StandardowyPrinter implements Printer{
@Override
public void drukuj(String tekst) {
System.out.println(tekst);
}
public static void main(String[] args)
{
StandardowyPrinter standardowyPrinter1 = new StandardowyPrinter();// nie dajemy tak Interface
standardowyPrinter1.drukuj("Drukuje");
Biuro biuro = new Biuro(standardowyPrinter1);
biuro.drukujDokument("To jest wazny dokument");
}
}
package Zad4;
/// Dokonczyc 2 ostatnie
import java.util.Scanner;
public class Main_Z_Programami {
public static void main(String[] args)
{
try {
checkAge(20);
checkAge(15);
checkAge(25);
}
catch (IllegalArgumentException e) /// Obsluga wyjatku
{
/// Wyswieltli komunikat Obsulga wyjatku
System.out.println("Blad: " + e.getMessage());
///Wyslwietli na czerwono Wyrzucenie wyjatku
///throw new ArithmeticException("Dzielnie przez 0");
}
}
public static void checkAge(int age) // Static
{
if (age < 18)
{
throw new IllegalArgumentException("Zbyt Młody");
/// Wyrzucenie wyjatku
}
else
{
System.out.println(age);
}
}
}
package Zad4;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main_Z_Programami2 {
public static void main (String[] args)
{
Scanner scanner = new Scanner(System.in);
while (true)
{
try {
System.out.println("Podaj A: ");
int a = scanner.nextInt();
System.out.println("Podaj B: ");
int b = scanner.nextInt();
double wynik = dzielenie(a,b);
System.out.println(wynik);
break;
}
catch (InputMismatchException e)
{
System.out.println("Nie podano cyfry");
}
catch (ArithmeticException e)
{
System.out.println("Dzielenie przez zero nie jest dozwolone");
}
scanner.nextLine();
}
}
public static double dzielenie(int liczba1, int liczba2)
{
if(liczba2 == 0)
{
throw new ArithmeticException("Dzielenie przez 0");
}
else
{
return (double) liczba1 /liczba2;
}
}
}
package Zad4;
public class NiepoprawnyFormatDanychException extends Exception{
public NiepoprawnyFormatDanychException(String dane)
{
super(dane);
}
public static void main(String [] args)
{
try {
SprawdzFormatDanych("niepoprawnyAdresEmail");
System.out.println("Format danych jest poprawny.");
} catch (NiepoprawnyFormatDanychException e) {
System.out.println("Błąd: " + e.getMessage());
}
}
public static void SprawdzFormatDanych(String dane) throws NiepoprawnyFormatDanychException {
if(!dane.matches("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$"))
{
throw new NiepoprawnyFormatDanychException("Niepoprawny format danych");
}
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD 5 Generyczne
package Zad5;
public class Main1 {
public static void main(String[] args)
{
int number1 = 43;
int number2 = 65;
System.out.println(isEqual(number1,number2));
String tekst1 = "Hello";
String tekst2 = "World";
System.out.println(isEqual(tekst1,tekst2));
}
/// Metoda generyczna
public static <T> boolean isEqual(T obj1, T obj2) /// Dowolny obiekt nawet bez posiadnia obiektu
{
return obj1.equals(obj2);
}
}
package Zad5;
import java.util.Arrays;
public class Main2 {
public static void main(String[] args)
{
try{
Integer[] tab = {1,2,3,4}; // Tak musi byc
swap(tab,0,6);
System.out.println(Arrays.toString(tab));
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.getMessage());
}
}
public static <T> void swap(T[] tab, int indeks1, int indeks2) {
/// Nie jest potrzebne
if (indeks1 < 0 || indeks1 >= tab.length || indeks2 < 0 || indeks2 >= tab.length) {
throw new ArrayIndexOutOfBoundsException("Nieprawidłowe indeksy. Poza rozmiarem tablicy.");
}
T temp = tab[indeks1];
tab[indeks1] = tab[indeks2];
tab[indeks2] = temp;
}
}
package Zad5;
public class Main3 {
public static void main(String[] args)
{
Integer[] intTab = {5, 2, 8, 1, 9};
Float[] floatTab = {2.5f, 7.2f, 4.8f, 1.3f};
String[] stringTab = {"apple", "banana", "cherry", "date"};
Vehicle[] vehicleTab =
{
new Vehicle("Car", 120),
new Vehicle("Bike", 25),
new Vehicle("Truck", 80)
};
System.out.println("Max int tab: " + maxValue(intTab));
System.out.println("Max float tab: " + maxValue(floatTab));
System.out.println("Max string tab: " + maxValue(stringTab));
System.out.println("Max speed w vehicle tab: " + maxValue(vehicleTab).getSpeed());
}
public static <T extends Comparable<T>> T maxValue (T[] tab)
{
if (tab.length == 0
) {
throw new IllegalArgumentException("Tablica nie moze byc pusta");
}
T max = tab[0];
for (T element : tab)
{
if (element.compareTo(max) > 0)
{
max = element;
}
}
return max;
}
static class Vehicle implements Comparable<Vehicle>
{
private String model;
private int speed;
public Vehicle(String model, int speed)
{
this.model = model;
this.speed = speed;
}
public int getSpeed()
{
return speed;
}
@Override
public int compareTo(Vehicle other)
{
return Integer.compare(this.speed, other.speed);
}
}
}
package Zad5;
public class Triple <T,U,V>{
T first;
U second;
V third;
public Triple(T first, U second, V third) {
this.first = first;
this.second = second;
this.third = third;
}
public T getFirst() {
return first;
}
public U getSecond() {
return second;
}
public V getThird() {
return third;
}
public static void main(String[] args) {
Triple<String, Integer, Double> exampleTriple = new Triple<>("Hello", 42, 3.14);
String firstElement = exampleTriple.getFirst();
Integer secondElement = exampleTriple.getSecond();
Double thirdElement = exampleTriple.getThird();
System.out.println("First Element: " + firstElement);
System.out.println("Second Element: " + secondElement);
System.out.println("Third Element: " + thirdElement);
}
}
| /// implements Comparable<nazwaKlasy> || prawy przycisk i metoda compareTo | ZAD1
//// Najwaznijesze RECORD Z Konstruktorem
package Zad1;
public record BankAccount(String numerKonta, double saldo) {
public BankAccount(String numerKonta) { // Konstruktor
this(numerKonta,0);
}
}
/// Record z Metoda
package Zad1;
public record Car(String brand,String model, double fuelConsumptionPer100km) {
public double fuelCost(double fuelPrice,double distance) /// Metoda
{
double fuelConsumed = (fuelConsumptionPer100km / 100) * distance;
return fuelConsumed * fuelPrice;
}
}
/// Record Address w Person
public record Person(String firstName, String lastName, Address adres) {
}
package Zad1;
public record Address(String street, int houseNumber, String postalCode, String city) {
}
/// Main
package Zad1;
public class Main {
public static void main(String[] args) {
////Obiekty
BookDT0 book1 = new BookDT0("Tytul1", "Autor1", 20.99,1999);
BookDT0 book2 = new BookDT0("Tytul2","Autor2",21.99,2000);
BookDT0 book3 = new BookDT0("Tytul3","Autor3",22.99,2015);
Address adres1 = new Address("Mikojaki",56,"10-900","Warsaw");
Person person1 = new Person("Adam","Rybak",adres1);
System.out.println(book1);
System.out.println(book2);
System.out.println(book3);
System.out.println(person1);
BankAccount bankAccount1 = new BankAccount("123456789");
System.out.println(bankAccount1);
MusicTrack musicTrack1 = new MusicTrack("Title", "Unknown");
System.out.println(musicTrack1);
Car car1 = new Car("Opel","Astra",10.5);
System.out.println(car1.fuelCost(7.50,300));
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD2 Comparator i comparable
package Zad2;
import java.util.Comparator;
public class IdComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return Integer.compare(o1.id, o2.id);
}
}
package Zad2;
import java.time.LocalDate;
/// implements Comparable<nazwaKlasy> <SUF>
public class Ksiazka implements Comparable<Ksiazka> {
public String tytul;
public int liczbaStron;
public LocalDate dataWydania;
public Ksiazka(String tytul, int liczbaStron, LocalDate dataWydania) {
this.tytul = tytul;
this.liczbaStron = liczbaStron;
this.dataWydania = dataWydania;
}
@Override
public String toString() {
return "Ksiazka{" +
"tytul='" + tytul + '\'' +
", liczbaStron=" + liczbaStron +
", dataWydania=" + dataWydania +
'}';
}
@Override
public int compareTo(Ksiazka o) {
return Integer.compare(o.liczbaStron,this.liczbaStron); // Sortowanie wedlug stron malejaca
//return Integer.compare(this.liczbaStron,o.liczbaStron); // Sortowanie wedlug stron rosnoca
}
}
package Zad2;
import java.time.LocalDate;
import java.util.*;
public class Main {
public static void main(String[] args) {
/// Tablica obiektow
Ksiazka[] ksiazkas = {new Ksiazka("Książka1", 200, LocalDate.of(2020, 1, 1)),
new Ksiazka("Książka2", 150, LocalDate.of(2019, 5, 15)),
new Ksiazka("Książka3", 300, LocalDate.of(2022, 8, 20)),
new Ksiazka("Książka4", 180, LocalDate.of(2021, 3, 10))
};
Arrays.sort(ksiazkas); // Sortowanie
System.out.println("Posortowana Lista Malejąco:");
for(int i = 0; i < ksiazkas.length;i++) // Wypisanie
{
System.out.println(ksiazkas[i]);
}
Samochod[] samochods = {new Samochod("Toyota", 50000, 2018),
new Samochod("Ford", 70000, 2019),
new Samochod("Volkswagen", 60000, 2020),
new Samochod("BMW", 45000, 2017)};
Arrays.sort(samochods);
System.out.println();
System.out.println("Posortowana Lista Rosnąco:");
for(int i = 0; i < samochods.length;i++)
{
System.out.println(samochods[i]);
}
/// Lista Tablicowa
List<Zamowienie> zamowienia = new ArrayList<>();
zamowienia.add(new Zamowienie("Produkt1", 5, 25.0));
zamowienia.add(new Zamowienie("Produkt2", 3, 30.0));
zamowienia.add(new Zamowienie("Produkt3", 2, 25.0));
zamowienia.add(new Zamowienie("Produkt4", 4, 20.0));
zamowienia.sort(null);
System.out.println();
System.out.println("Posortowane malejąco według ceny jednostkowej, a przy równości sortowane były rosnąco według ilości");
for(int i = 0; i < zamowienia.size();i++)
{
System.out.println(zamowienia.get(i));
}
List<Order> orders = new ArrayList<>();
orders.add(new Order(1, "Customer1", LocalDate.of(2022, 1, 15)));
orders.add(new Order(2, "Customer2", LocalDate.of(2022, 2, 20)));
orders.add(new Order(3, "Customer3", LocalDate.of(2022, 1, 10)));
orders.add(new Order(4, "Customer4", LocalDate.of(2022, 2, 5)));
orders.add(new Order(5, "Customer5", LocalDate.of(2022, 1, 25)));
Collections.sort(orders,new OrderComparator());////lub tak: orders.sort(new Order2());
System.out.println();
System.out.println("Posortowana Lista:");
for(int i = 0; i < orders.size();i++)
{
System.out.println(orders.get(i));
}
Song[] songs ={new Song("Song1", "Artist1", 180),
new Song("Song2", "Artist2", 220),
new Song("Song3", "Artist3", 200),
new Song("Song4", "Artist4", 180),
new Song("Song5", "Artist5", 240)
};
Arrays.sort(songs,new SongComparator());
System.out.println();
System.out.println("Posortowana tablica:");
for(int i = 0; i < songs.length;i++)
{
System.out.println(songs[i]);
}
List<Student> students = new ArrayList<>();
students.add( new Student(1, "Student1", 4.5));
students.add(new Student(2, "Student2", 3.8));
students.add(new Student(3, "Student3", 4.2));
students.add(new Student(5, "Student5", 4.8));
students.add(new Student(4, "Student4", 4.0));
Collections.sort(students,new AverageGradeComparator());
System.out.println();
for (int i = 0; i < students.size();i++)
{
System.out.println(students.get(i));
}
Collections.sort(students,new IdComparator());
System.out.println();
for (int i = 0; i < students.size();i++)
{
System.out.println(students.get(i));
}
/// NIE DOKONCA
// Utwórz oryginalnego sportowca
// Athlete originalAthlete = new Athlete("John Doe", List.of(60, 62, 58, 61, 59));
// Sklonuj sportowca
// Athlete clonedAthlete = originalAthlete.clone();
// Zmiana czasu na pozycji 3 oryginalnego sportowca
// originalAthlete.setLapTime(2, 55);
// Wyświetl czasy obu sportowców
//System.out.println("Oryginalny sportowiec: " + originalAthlete);
//System.out.println("Sklonowany sportowiec: " + clonedAthlete);
}
}
package Zad2;
import java.util.Comparator;
/// Comparator
public class OrderComparator implements Comparator<Order> {
@Override
public int compare(Order o1, Order o2) {
int dateComparation = o1.orderDate.compareTo(o2.orderDate);
if (dateComparation == 0)
{
return Integer.compare(o1.id, o2.id);
}
return dateComparation;
}
}
package Zad2;
public class Samochod implements Comparable<Samochod> {
public String marka;
public int przebieg;
public int rokProdukcji;
public Samochod(String marka, int przebieg, int rokProdukcji) {
this.marka = marka;
this.przebieg = przebieg;
this.rokProdukcji = rokProdukcji;
}
@Override
public String toString() {
return "Samochod{" +
"marka='" + marka + '\'' +
", przebieg=" + przebieg +
", rokProdukcji=" + rokProdukcji +
'}';
}
@Override
public int compareTo(Samochod o) {
return Integer.compare(this.przebieg,o.przebieg); // Integer.compare( )
}
}
package Zad2;
public class Song {
public String title;
public String artist;
public int duration;
public Song(String title, String artist, int duration) {
this.title = title;
this.artist = artist;
this.duration = duration;
}
@Override
public String toString() {
return "Song{" +
"title='" + title + '\'' +
", artist='" + artist + '\'' +
", duration=" + duration +
'}';
}
}
package Zad2;
import java.util.Comparator;
public class SongComparator implements Comparator<Song>{
@Override
public int compare(Song o1, Song o2) {
int DurationComparation = Integer.compare(o1.duration,o2.duration);
if(DurationComparation == 0)
{
return o1.title.compareTo(o2.title);
}
return DurationComparation;
}
}
package Zad2;
public class Zamowienie implements Comparable<Zamowienie> {
public String nazwaProduktu;
public int ilosc;
public double cenaJednostkowa;
public Zamowienie(String nazwaProduktu, int ilosc, double cenaJednostkowa) {
this.nazwaProduktu = nazwaProduktu;
this.ilosc = ilosc;
this.cenaJednostkowa = cenaJednostkowa;
}
@Override
public String toString() {
return "Zamowienie{" +
"nazwaProduktu='" + nazwaProduktu + '\'' +
", ilosc=" + ilosc +
", cenaJednostkowa=" + cenaJednostkowa +
'}';
}
@Override
public int compareTo(Zamowienie o) {
int comparePrice = Double.compare(o.cenaJednostkowa,this.cenaJednostkowa);
if(comparePrice == 0)
{
Integer.compare(this.ilosc,o.ilosc);
}
return comparePrice;
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD 3 Implentowanie wlasnych Interfaceow
package Zad3;
public interface MediaPlayer {
/// Metody Abstrakcyjne
void play(String trackName);
void pause();
String getCurrentTrack();
}
package Zad3;
public class AudioPlayer implements MediaPlayer{
public String currentTrack;
@Override
public void play(String trackName) {
System.out.println("Gra utwór: " + trackName );
currentTrack = trackName;
}
@Override
public void pause() {
System.out.println("Zatrzymano");
}
@Override
public String getCurrentTrack() {
return currentTrack;
}
}
package Zad3;
public class VideoPlayer implements MediaPlayer{
public String current;
@Override
public void play(String trackName) {
System.out.println("Leci film: "+trackName);
current = trackName;
}
@Override
public void pause() {
System.out.println("Zatrzymano film:" + current);
}
@Override
public String getCurrentTrack() {
return current;
}
}
package Zad3;
public class MediaPlayerTest {
public static void main(String [] args)
{
AudioPlayer audioPlayer1 = new AudioPlayer();
audioPlayer1.play("Eyes-Travis Scoot");
audioPlayer1.pause();
System.out.println(audioPlayer1.getCurrentTrack());
System.out.println();
VideoPlayer videoPlayer1= new VideoPlayer();
videoPlayer1.play("Tenet");
videoPlayer1.pause();
System.out.println(videoPlayer1.getCurrentTrack());
}
}
package Zad3;
public interface VehicleManager {
String startEngine();
int getFuelLevel();
}
package Zad3;
public class Motorcycle implements VehicleManager{
@Override
public String startEngine() {
return "Silnik motocykle uruchomiony";
}
@Override
public int getFuelLevel() {
return 30;
}
}
package Zad3;
public class Car implements VehicleManager {
@Override
public String startEngine() {
return "Silnik samochodu uruchomiony";
}
@Override
public int getFuelLevel() {
return 50;
}
}
package Zad3;
public class VehicleManagerTest {
public static void main(String [] args)
{
Car car1 = new Car();
System.out.println(car1.startEngine());
System.out.println(car1.getFuelLevel());
System.out.println();
Motorcycle motorcycle1 = new Motorcycle();
System.out.println(motorcycle1.startEngine());
System.out.println(motorcycle1.getFuelLevel());
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD 4
package Zad4;
public interface Printer {
void drukuj(String tekst);
}
package Zad4;
public class Biuro {
private Printer printer; /// INterface jako zmienna
public Biuro(Printer printer) {
this.printer = printer;
}
public void drukujDokument(String tekst)
{
printer.drukuj(tekst);
}
}
package Zad4;
public class StandardowyPrinter implements Printer{
@Override
public void drukuj(String tekst) {
System.out.println(tekst);
}
public static void main(String[] args)
{
StandardowyPrinter standardowyPrinter1 = new StandardowyPrinter();// nie dajemy tak Interface
standardowyPrinter1.drukuj("Drukuje");
Biuro biuro = new Biuro(standardowyPrinter1);
biuro.drukujDokument("To jest wazny dokument");
}
}
package Zad4;
/// Dokonczyc 2 ostatnie
import java.util.Scanner;
public class Main_Z_Programami {
public static void main(String[] args)
{
try {
checkAge(20);
checkAge(15);
checkAge(25);
}
catch (IllegalArgumentException e) /// Obsluga wyjatku
{
/// Wyswieltli komunikat Obsulga wyjatku
System.out.println("Blad: " + e.getMessage());
///Wyslwietli na czerwono Wyrzucenie wyjatku
///throw new ArithmeticException("Dzielnie przez 0");
}
}
public static void checkAge(int age) // Static
{
if (age < 18)
{
throw new IllegalArgumentException("Zbyt Młody");
/// Wyrzucenie wyjatku
}
else
{
System.out.println(age);
}
}
}
package Zad4;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Main_Z_Programami2 {
public static void main (String[] args)
{
Scanner scanner = new Scanner(System.in);
while (true)
{
try {
System.out.println("Podaj A: ");
int a = scanner.nextInt();
System.out.println("Podaj B: ");
int b = scanner.nextInt();
double wynik = dzielenie(a,b);
System.out.println(wynik);
break;
}
catch (InputMismatchException e)
{
System.out.println("Nie podano cyfry");
}
catch (ArithmeticException e)
{
System.out.println("Dzielenie przez zero nie jest dozwolone");
}
scanner.nextLine();
}
}
public static double dzielenie(int liczba1, int liczba2)
{
if(liczba2 == 0)
{
throw new ArithmeticException("Dzielenie przez 0");
}
else
{
return (double) liczba1 /liczba2;
}
}
}
package Zad4;
public class NiepoprawnyFormatDanychException extends Exception{
public NiepoprawnyFormatDanychException(String dane)
{
super(dane);
}
public static void main(String [] args)
{
try {
SprawdzFormatDanych("niepoprawnyAdresEmail");
System.out.println("Format danych jest poprawny.");
} catch (NiepoprawnyFormatDanychException e) {
System.out.println("Błąd: " + e.getMessage());
}
}
public static void SprawdzFormatDanych(String dane) throws NiepoprawnyFormatDanychException {
if(!dane.matches("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$"))
{
throw new NiepoprawnyFormatDanychException("Niepoprawny format danych");
}
}
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
ZAD 5 Generyczne
package Zad5;
public class Main1 {
public static void main(String[] args)
{
int number1 = 43;
int number2 = 65;
System.out.println(isEqual(number1,number2));
String tekst1 = "Hello";
String tekst2 = "World";
System.out.println(isEqual(tekst1,tekst2));
}
/// Metoda generyczna
public static <T> boolean isEqual(T obj1, T obj2) /// Dowolny obiekt nawet bez posiadnia obiektu
{
return obj1.equals(obj2);
}
}
package Zad5;
import java.util.Arrays;
public class Main2 {
public static void main(String[] args)
{
try{
Integer[] tab = {1,2,3,4}; // Tak musi byc
swap(tab,0,6);
System.out.println(Arrays.toString(tab));
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.getMessage());
}
}
public static <T> void swap(T[] tab, int indeks1, int indeks2) {
/// Nie jest potrzebne
if (indeks1 < 0 || indeks1 >= tab.length || indeks2 < 0 || indeks2 >= tab.length) {
throw new ArrayIndexOutOfBoundsException("Nieprawidłowe indeksy. Poza rozmiarem tablicy.");
}
T temp = tab[indeks1];
tab[indeks1] = tab[indeks2];
tab[indeks2] = temp;
}
}
package Zad5;
public class Main3 {
public static void main(String[] args)
{
Integer[] intTab = {5, 2, 8, 1, 9};
Float[] floatTab = {2.5f, 7.2f, 4.8f, 1.3f};
String[] stringTab = {"apple", "banana", "cherry", "date"};
Vehicle[] vehicleTab =
{
new Vehicle("Car", 120),
new Vehicle("Bike", 25),
new Vehicle("Truck", 80)
};
System.out.println("Max int tab: " + maxValue(intTab));
System.out.println("Max float tab: " + maxValue(floatTab));
System.out.println("Max string tab: " + maxValue(stringTab));
System.out.println("Max speed w vehicle tab: " + maxValue(vehicleTab).getSpeed());
}
public static <T extends Comparable<T>> T maxValue (T[] tab)
{
if (tab.length == 0
) {
throw new IllegalArgumentException("Tablica nie moze byc pusta");
}
T max = tab[0];
for (T element : tab)
{
if (element.compareTo(max) > 0)
{
max = element;
}
}
return max;
}
static class Vehicle implements Comparable<Vehicle>
{
private String model;
private int speed;
public Vehicle(String model, int speed)
{
this.model = model;
this.speed = speed;
}
public int getSpeed()
{
return speed;
}
@Override
public int compareTo(Vehicle other)
{
return Integer.compare(this.speed, other.speed);
}
}
}
package Zad5;
public class Triple <T,U,V>{
T first;
U second;
V third;
public Triple(T first, U second, V third) {
this.first = first;
this.second = second;
this.third = third;
}
public T getFirst() {
return first;
}
public U getSecond() {
return second;
}
public V getThird() {
return third;
}
public static void main(String[] args) {
Triple<String, Integer, Double> exampleTriple = new Triple<>("Hello", 42, 3.14);
String firstElement = exampleTriple.getFirst();
Integer secondElement = exampleTriple.getSecond();
Double thirdElement = exampleTriple.getThird();
System.out.println("First Element: " + firstElement);
System.out.println("Second Element: " + secondElement);
System.out.println("Third Element: " + thirdElement);
}
}
| f | null |
284 | 8320_11 | PawelDabrowski83/javaLearn | 521 | src/main/java/tablice/MainArrays.java | package tablice;
public class MainArrays {
public static void main(String[] args) {
// deklaracja tablicy
int[] array1 = new int[6]; // tablica z 6 elementami (same zera) {0, 0, 0, 0, 0, 0}
int[] array2 = {1, 2, 3, 4, 5, 6}; //tablica inicjalizowana konkretnymi wartościami
// uwaga - indeksy tablicy liczymy od 0 a nie od 1!
// odczytanie elementu z tablicy:
int a, b;
a = array1[0]; // odczytuję liczbę z indeksu '0' (początek tablicy)
b = array1[1]; // odczytuję liczbę z indeksu 1 (czyli drugą w kolejności)
// przypisanie elementu do tablicy:
array1[3] = 7; // wartość 7 przypisuję do elementu nr 3 tablicy (czyli tak naprawdę czwarty element)
// 1. Stwórz tablicę Stringów składającą się z 3 dowolnych słów
// 2. Stwórz tablicę intów o rozmiarze 10 elementów
// 3. Stwórz tablicę charów składającą się z liter: L, o, r, e, m
// 4. Napisz program, który znajduje najniższą wartość w tablicy z p. 3.
// 5. Stwórz tablicę intów o rozmiarze 10. Wypełnij je kolejnymi liczbami, zaczynając od liczby 5.
// 6. Za pomocą pętli zwiększ o 3 wartość każdej liczby z tablicy z p. 5.
}
}
| // 4. Napisz program, który znajduje najniższą wartość w tablicy z p. 3. | package tablice;
public class MainArrays {
public static void main(String[] args) {
// deklaracja tablicy
int[] array1 = new int[6]; // tablica z 6 elementami (same zera) {0, 0, 0, 0, 0, 0}
int[] array2 = {1, 2, 3, 4, 5, 6}; //tablica inicjalizowana konkretnymi wartościami
// uwaga - indeksy tablicy liczymy od 0 a nie od 1!
// odczytanie elementu z tablicy:
int a, b;
a = array1[0]; // odczytuję liczbę z indeksu '0' (początek tablicy)
b = array1[1]; // odczytuję liczbę z indeksu 1 (czyli drugą w kolejności)
// przypisanie elementu do tablicy:
array1[3] = 7; // wartość 7 przypisuję do elementu nr 3 tablicy (czyli tak naprawdę czwarty element)
// 1. Stwórz tablicę Stringów składającą się z 3 dowolnych słów
// 2. Stwórz tablicę intów o rozmiarze 10 elementów
// 3. Stwórz tablicę charów składającą się z liter: L, o, r, e, m
// 4. Napisz <SUF>
// 5. Stwórz tablicę intów o rozmiarze 10. Wypełnij je kolejnymi liczbami, zaczynając od liczby 5.
// 6. Za pomocą pętli zwiększ o 3 wartość każdej liczby z tablicy z p. 5.
}
}
| f | null |
286 | 5795_0 | PawelMozdzynski/Zadanie-Pawel-Mozdzynski | 373 | Zad1.java | package pl.pawelMozdzynski;
class zad1 {
public static void main(String[] args) {
Czlowiek o1 = new Czlowiek();
o1.setImie("Janusz");
o1.setNazwisko("Błaszczyk");
o1.setPESEL("3214321432");
Student student = new Student();
student.setImie("Robert");
student.setNazwisko("Nowak");
student.setPESEL("9283849213");
student.setIndex(472638L);
student.setSrednia(4.5);
Wykladowca wykladowca = new Wykladowca();
wykladowca.setImie("Arkadiusz");
wykladowca.setNazwisko("Patyk");
wykladowca.setPESEL("123456789");
wykladowca.setTytul_naukowy("Doktor");
wykladowca.setPrzedmiot("Fizyka");
System.out.println(wykladowca);
/*
Kiedy tworzymy obiekt klasy podrzędnej najpierw wywołuje się konstruktor klasy nadrzednej
*/
}
}
| /*
Kiedy tworzymy obiekt klasy podrzędnej najpierw wywołuje się konstruktor klasy nadrzednej
*/ | package pl.pawelMozdzynski;
class zad1 {
public static void main(String[] args) {
Czlowiek o1 = new Czlowiek();
o1.setImie("Janusz");
o1.setNazwisko("Błaszczyk");
o1.setPESEL("3214321432");
Student student = new Student();
student.setImie("Robert");
student.setNazwisko("Nowak");
student.setPESEL("9283849213");
student.setIndex(472638L);
student.setSrednia(4.5);
Wykladowca wykladowca = new Wykladowca();
wykladowca.setImie("Arkadiusz");
wykladowca.setNazwisko("Patyk");
wykladowca.setPESEL("123456789");
wykladowca.setTytul_naukowy("Doktor");
wykladowca.setPrzedmiot("Fizyka");
System.out.println(wykladowca);
/*
Kiedy tworzymy obiekt <SUF>*/
}
}
| f | null |
287 | 9126_0 | PawelOzdoba-dev/microservices | 326 | user/src/main/java/pl/app/user/UserApplication.java | package pl.app.user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableFeignClients
@EnableSwagger2
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
}
//zrobić pakiet config w której zrobię RestTemplate klasę w której zrobię bean która zwraca restTemplate i bean ma być oznaczony adnotacją: @LoadBalanced
//w linku muszę wstawić nazwę aplikacji czyli (url) PRODUCT-SERVICE
//zrobić security user
//endpoiinty przenieść z monolitu z usera i produktu.
//elasticsearch co to ? https://smartbees.pl/blog/elasticsearch-czyli-wszystko-o-wyszukiwaniu-pelnotekstowym
//product maven projekt ten jest drugą instancją mikroserwisu PRODUCT-SERVICE - odpalany na porcie 8084.
| //zrobić pakiet config w której zrobię RestTemplate klasę w której zrobię bean która zwraca restTemplate i bean ma być oznaczony adnotacją: @LoadBalanced | package pl.app.user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableFeignClients
@EnableSwagger2
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
}
//zrobić pakiet <SUF>
//w linku muszę wstawić nazwę aplikacji czyli (url) PRODUCT-SERVICE
//zrobić security user
//endpoiinty przenieść z monolitu z usera i produktu.
//elasticsearch co to ? https://smartbees.pl/blog/elasticsearch-czyli-wszystko-o-wyszukiwaniu-pelnotekstowym
//product maven projekt ten jest drugą instancją mikroserwisu PRODUCT-SERVICE - odpalany na porcie 8084.
| f | null |
289 | 3747_0 | PieroganoReggiano/Kvadrato | 626 | src/kvadrato/game/WorldThread.java | package kvadrato.game;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.lang.Runnable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CancellationException;
/**
* To jest klasa, która ma wątek zajmujący się wszystkim, co się dzieje na
* świecie. Nie jest ona publiczna, ma być widoczna tylko w pakiecie,
*/
class WorldThread extends ScheduledThreadPoolExecutor
{
private World world;
private Future imm;
private ScheduledFuture tim;
/**
* Tutaj też bym coś napisał, ale na razie nie wiem, co.
*/
WorldThread(World w)
{
super(2);
world=w;
}
class Immediately implements Runnable
{
public void run()
{
world.lock();
try
{
while(world.decImmediatelyTicks())
{
world.oneTick();
}
}
finally
{
world.unlock();
}
}
}
class Timed implements Runnable
{
public void run()
{
world.lock();
try
{
world.oneTick();
}
finally
{
world.unlock();
}
}
}
void reschedule()
{
halt();
imm=submit(new Immediately());
if(world.runs())
{
long time=world.getWaitTime();
tim=scheduleAtFixedRate(new Timed(),time,time,TimeUnit.NANOSECONDS);
}
}
void halt()
{
if(imm!=null)
{
imm.cancel(false);
try
{
imm.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
imm=null;
}
if(tim!=null)
{
tim.cancel(false);
try
{
tim.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
tim=null;
}
}
}
| /**
* To jest klasa, która ma wątek zajmujący się wszystkim, co się dzieje na
* świecie. Nie jest ona publiczna, ma być widoczna tylko w pakiecie,
*/ | package kvadrato.game;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.lang.Runnable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.CancellationException;
/**
* To jest klasa, <SUF>*/
class WorldThread extends ScheduledThreadPoolExecutor
{
private World world;
private Future imm;
private ScheduledFuture tim;
/**
* Tutaj też bym coś napisał, ale na razie nie wiem, co.
*/
WorldThread(World w)
{
super(2);
world=w;
}
class Immediately implements Runnable
{
public void run()
{
world.lock();
try
{
while(world.decImmediatelyTicks())
{
world.oneTick();
}
}
finally
{
world.unlock();
}
}
}
class Timed implements Runnable
{
public void run()
{
world.lock();
try
{
world.oneTick();
}
finally
{
world.unlock();
}
}
}
void reschedule()
{
halt();
imm=submit(new Immediately());
if(world.runs())
{
long time=world.getWaitTime();
tim=scheduleAtFixedRate(new Timed(),time,time,TimeUnit.NANOSECONDS);
}
}
void halt()
{
if(imm!=null)
{
imm.cancel(false);
try
{
imm.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
imm=null;
}
if(tim!=null)
{
tim.cancel(false);
try
{
tim.get();
}
catch(InterruptedException exc){}
catch(ExecutionException exc){}
catch(CancellationException exc){}
tim=null;
}
}
}
| f | null |
290 | 6249_18 | Pikei/Metody-podejmowania-Ryzyka | 1,517 | src/HookeJeeves.java | import java.util.Arrays;
import java.util.stream.IntStream;
public class HookeJeeves {
public HookeJeeves() {
algorytm();
}
private final double[] xStart = new double[2]; //punkt startowy, deklaracja wymiarów (x,y,z,...)
private final double[] x = new double[xStart.length]; //punkt, który będzie się poruszać, tyle samo współrzędnych co punkt startowy
private double k = 1.5; //krok
private final double e = 0.00002; //dokładność rozwiązania
private double f(double[] x) { //funkcja f(x) = Σ (i+2)*xi^i
// return IntStream.range(0, x.length).mapToDouble(i -> (i + 2) * Math.pow(x[i], (i))).sum();
return 2 * Math.pow(x[0] - 1.5, 2) + 2 * x[0] * x[1] + Math.pow(x[1] - 0.5, 2) - 3;
}
private void algorytm() {
Arrays.fill(xStart, 2); //początek z punktu (1,1,1,...)
Arrays.setAll(x, i -> xStart[i]);
do {
krokProbny(); //wykonanie kroku próbnego
krokRoboczy(); //wykonanie kroku roboczego
if (f(x) < f(xStart))
Arrays.setAll(xStart, i -> x[i]); //jeśli po wykonaniu kroku punkt jest lepszy to zapisz jego wartość jako aktualną
print(); //wypisanie aktualnego położenia
} while (k > e); //pętla będzie się wykonywać tak długo, dopóki krok będzie większy od e
printResult(); //wypisanie wyniku końcowego
}
private void krokProbny() {
double v = k; //zapisz aktualną wartość kroku
for (int i = 0; i < x.length; i++) { //dla wszystkich wymiarów
x[i] += k; //zmień współrzędną osi o krok
if (f(x) < f(xStart)) { //jeśli nowy punkt jest lepszty niż poprzedni
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] -= 2 * k; //jeśli zwiększenie współrzędnej nie było lepsze to zmniejsz współrzędną o krok
if (f(x) < f(xStart)) { //jeśli nowy punkt jest lepszty niż poprzedni
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] = xStart[i]; //jeśli krok w żadną ze stron nie był pomyślny przywróć poprzednią wartość współrzędnej
if (k > e) { //jeśli krok jest większy niż e
k *= 0.2; //zmniejsz krok
i--; //ponów dla tej samej współrzędnej powyższe działania ze zmniejszonym krokiem
} else k = v; //jeśli krok jest mniejszy niż e, przywróć początkową wartość kroku i przejdź do następnej współrzędnej
}
}
private void krokRoboczy() {
double[] tempArray = new double[x.length]; //utwórz tymczasowy punkt, o współrzędnych x
Arrays.setAll(tempArray, i -> x[i]);
Arrays.setAll(x, i -> xStart[i] + 1.5 * (x[i] - xStart[i])); //wykonaj krok po wektorze o długości kroku
if (f(x) < f(tempArray)) k *= 1.25; //jeśli krok był udany zwiększ wartość kroku
else {
Arrays.setAll(x, i -> tempArray[i]); //jeśli nie przywróć poprzednie współrzędne
k *= 0.2; //zmniejsz wartość kroku
}
}
private void print() {
System.out.println("==========================");
System.out.print("aktualny punkt: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("aktualne przybliżenie wyniku: " + f(x));
System.out.println("aktualny krok: " + k);
System.out.println("==========================");
}
private void printResult() {
System.out.println("==========WYNIK===========");
System.out.print("Znaleziono minimum funkcji w punkcie: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("Wartość funkcji wynosi: " + f(x));
System.out.println("==========================");
}
} | //jeśli nowy punkt jest lepszty niż poprzedni | import java.util.Arrays;
import java.util.stream.IntStream;
public class HookeJeeves {
public HookeJeeves() {
algorytm();
}
private final double[] xStart = new double[2]; //punkt startowy, deklaracja wymiarów (x,y,z,...)
private final double[] x = new double[xStart.length]; //punkt, który będzie się poruszać, tyle samo współrzędnych co punkt startowy
private double k = 1.5; //krok
private final double e = 0.00002; //dokładność rozwiązania
private double f(double[] x) { //funkcja f(x) = Σ (i+2)*xi^i
// return IntStream.range(0, x.length).mapToDouble(i -> (i + 2) * Math.pow(x[i], (i))).sum();
return 2 * Math.pow(x[0] - 1.5, 2) + 2 * x[0] * x[1] + Math.pow(x[1] - 0.5, 2) - 3;
}
private void algorytm() {
Arrays.fill(xStart, 2); //początek z punktu (1,1,1,...)
Arrays.setAll(x, i -> xStart[i]);
do {
krokProbny(); //wykonanie kroku próbnego
krokRoboczy(); //wykonanie kroku roboczego
if (f(x) < f(xStart))
Arrays.setAll(xStart, i -> x[i]); //jeśli po wykonaniu kroku punkt jest lepszy to zapisz jego wartość jako aktualną
print(); //wypisanie aktualnego położenia
} while (k > e); //pętla będzie się wykonywać tak długo, dopóki krok będzie większy od e
printResult(); //wypisanie wyniku końcowego
}
private void krokProbny() {
double v = k; //zapisz aktualną wartość kroku
for (int i = 0; i < x.length; i++) { //dla wszystkich wymiarów
x[i] += k; //zmień współrzędną osi o krok
if (f(x) < f(xStart)) { //jeśli nowy punkt jest lepszty niż poprzedni
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] -= 2 * k; //jeśli zwiększenie współrzędnej nie było lepsze to zmniejsz współrzędną o krok
if (f(x) < f(xStart)) { //jeśli nowy <SUF>
k = v; //przywróć poprzednią wartość kroku
continue; //przejdź do kolejnej współrzędnej na osi
}
x[i] = xStart[i]; //jeśli krok w żadną ze stron nie był pomyślny przywróć poprzednią wartość współrzędnej
if (k > e) { //jeśli krok jest większy niż e
k *= 0.2; //zmniejsz krok
i--; //ponów dla tej samej współrzędnej powyższe działania ze zmniejszonym krokiem
} else k = v; //jeśli krok jest mniejszy niż e, przywróć początkową wartość kroku i przejdź do następnej współrzędnej
}
}
private void krokRoboczy() {
double[] tempArray = new double[x.length]; //utwórz tymczasowy punkt, o współrzędnych x
Arrays.setAll(tempArray, i -> x[i]);
Arrays.setAll(x, i -> xStart[i] + 1.5 * (x[i] - xStart[i])); //wykonaj krok po wektorze o długości kroku
if (f(x) < f(tempArray)) k *= 1.25; //jeśli krok był udany zwiększ wartość kroku
else {
Arrays.setAll(x, i -> tempArray[i]); //jeśli nie przywróć poprzednie współrzędne
k *= 0.2; //zmniejsz wartość kroku
}
}
private void print() {
System.out.println("==========================");
System.out.print("aktualny punkt: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("aktualne przybliżenie wyniku: " + f(x));
System.out.println("aktualny krok: " + k);
System.out.println("==========================");
}
private void printResult() {
System.out.println("==========WYNIK===========");
System.out.print("Znaleziono minimum funkcji w punkcie: [");
for (double v : x) {
System.out.print(v + " ");
}
System.out.print("]\n");
System.out.println("Wartość funkcji wynosi: " + f(x));
System.out.println("==========================");
}
} | f | null |
291 | 7105_0 | PiotrDeda/labs-po2 | 523 | Lab6/ListaLiczb.java | public class ListaLiczb extends Lista
{
public void add(Liczba obj)
{
super.add(obj);
}
public void add(Object obj)
throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
public Object smallestValue()
{
Node smallest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() < ((Liczba) smallest.obj).toDouble())
smallest = currNode.next;
currNode = currNode.next;
}
return smallest.obj;
}
public Object largestValue()
{
Node largest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() > ((Liczba) largest.obj).toDouble())
largest = currNode.next;
currNode = currNode.next;
}
return largest.obj;
}
public double[] toArray()
{
double[] result = new double[size()];
Node currNode = root;
int i = 0;
while (currNode != null)
{
result[i] = ((Liczba) currNode.obj).toDouble();
i += 1;
currNode = currNode.next;
}
return result;
}
public double average()
{
double[] arr = toArray();
double sum = 0;
for (double n : arr)
sum += n;
return sum / size();
}
public void sort()
{
// sortowanie jeszcze niezrealizowane, może kiedyś do niego wrócę
}
} | // sortowanie jeszcze niezrealizowane, może kiedyś do niego wrócę | public class ListaLiczb extends Lista
{
public void add(Liczba obj)
{
super.add(obj);
}
public void add(Object obj)
throws IllegalArgumentException
{
throw new IllegalArgumentException();
}
public Object smallestValue()
{
Node smallest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() < ((Liczba) smallest.obj).toDouble())
smallest = currNode.next;
currNode = currNode.next;
}
return smallest.obj;
}
public Object largestValue()
{
Node largest = root;
Node currNode = root;
while (currNode.next != null)
{
if (((Liczba) currNode.next.obj).toDouble() > ((Liczba) largest.obj).toDouble())
largest = currNode.next;
currNode = currNode.next;
}
return largest.obj;
}
public double[] toArray()
{
double[] result = new double[size()];
Node currNode = root;
int i = 0;
while (currNode != null)
{
result[i] = ((Liczba) currNode.obj).toDouble();
i += 1;
currNode = currNode.next;
}
return result;
}
public double average()
{
double[] arr = toArray();
double sum = 0;
for (double n : arr)
sum += n;
return sum / size();
}
public void sort()
{
// sortowanie jeszcze <SUF>
}
} | f | null |
292 | 7738_0 | PiotrSmola/Studies---Object-oriented-programming | 859 | Lab02/ex4.java | import java.util.Scanner;
public class ex4 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] tablica = new int[10];
System.out.println("Wprowadź 10 liczb:");
for (int i = 0; i < 10; i++) {
tablica[i] = in.nextInt();
}
int suma = 0;
int iloczyn = 1;
double srednia = 0;
int min = tablica[0];
int max = tablica[0];
for (int i = 0; i < tablica.length; i++) {
suma += tablica[i];
iloczyn *= tablica[i];
if (tablica[i] < min) {
min = tablica[i];
}
if (tablica[i] > max) {
max = tablica[i];
}
}
srednia = (double)suma/tablica.length;
while(true) {
System.out.println("\nMENU:");
System.out.println("1. Suma elementów tablicy");
System.out.println("2. Iloczyn elementów tablicy");
System.out.println("3. Średnia wartość elementów tablicy");
System.out.println("4. Wartość minimalna");
System.out.println("5. Wartość maksymalna");
System.out.println("6. Wyjście");
System.out.print("\nWybierz opcję: ");
int wybor = in.nextInt();
switch (wybor) {
case 1:
System.out.println("Suma elementów tablicy: " + suma);
break;
case 2:
System.out.println("Iloczyn elementów tablicy: " + iloczyn);
break;
case 3:
System.out.println("Średnia wartość elementów tablicy: " + srednia);
break;
case 4:
System.out.println("Wartość minimalna: " + min);
break;
case 5:
System.out.println("Wartość maksymalna: " + max);
break;
case 6:
Close();
default:
Error();
break;
}
}
}
public static void Error()
{
System.out.println("Błędne dane, koniec programu");
System.exit(0);
}
public static String InputString() { //potwierdzenie zakończenia programu
Scanner input = new Scanner(System.in);
String znak = input.nextLine();
return znak;
}
public static void Close() {
System.out.println("\t\t\tCzy na pewno chcesz wyjść t || T");
String znak = InputString();
String st1="t";
String st2="T";
if (znak.equals(st1) || znak.equals(st2)) System.exit(0);
}
}
| //potwierdzenie zakończenia programu
| import java.util.Scanner;
public class ex4 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] tablica = new int[10];
System.out.println("Wprowadź 10 liczb:");
for (int i = 0; i < 10; i++) {
tablica[i] = in.nextInt();
}
int suma = 0;
int iloczyn = 1;
double srednia = 0;
int min = tablica[0];
int max = tablica[0];
for (int i = 0; i < tablica.length; i++) {
suma += tablica[i];
iloczyn *= tablica[i];
if (tablica[i] < min) {
min = tablica[i];
}
if (tablica[i] > max) {
max = tablica[i];
}
}
srednia = (double)suma/tablica.length;
while(true) {
System.out.println("\nMENU:");
System.out.println("1. Suma elementów tablicy");
System.out.println("2. Iloczyn elementów tablicy");
System.out.println("3. Średnia wartość elementów tablicy");
System.out.println("4. Wartość minimalna");
System.out.println("5. Wartość maksymalna");
System.out.println("6. Wyjście");
System.out.print("\nWybierz opcję: ");
int wybor = in.nextInt();
switch (wybor) {
case 1:
System.out.println("Suma elementów tablicy: " + suma);
break;
case 2:
System.out.println("Iloczyn elementów tablicy: " + iloczyn);
break;
case 3:
System.out.println("Średnia wartość elementów tablicy: " + srednia);
break;
case 4:
System.out.println("Wartość minimalna: " + min);
break;
case 5:
System.out.println("Wartość maksymalna: " + max);
break;
case 6:
Close();
default:
Error();
break;
}
}
}
public static void Error()
{
System.out.println("Błędne dane, koniec programu");
System.exit(0);
}
public static String InputString() { //potwierdzenie zakończenia <SUF>
Scanner input = new Scanner(System.in);
String znak = input.nextLine();
return znak;
}
public static void Close() {
System.out.println("\t\t\tCzy na pewno chcesz wyjść t || T");
String znak = InputString();
String st1="t";
String st2="T";
if (znak.equals(st1) || znak.equals(st2)) System.exit(0);
}
}
| f | null |
294 | 9997_1 | PiotrStoklosa/uwr-first-cycle-studies | 882 | semestr III/kurs-jezyka-java/zadanie1/spirala.java | //Piotr Stokłosa Zadanie1
public class Spirala {
private static final boolean[] sieve = new boolean[40001];
static boolean ifPrimary(int number){
return !sieve[number];
}
static void fillingTheSieve(){
sieve[0] = true;
sieve[1] = true;
for (int i = 2; i < 40001; i++)
if (!sieve[i])
for (int j = i * i; j < 40001; j += i)
sieve[j] = true;
}
static void fillingTheSpiral(int[][] spiral, int n){
int start = n / 2;
int max = 2; // (maks / 2) oznacza ile powinien algorytm przypisac liczb w jednej lini
int currentMax = 1; // oznacza ile jeszcze trzeba przypisac liczb przed zmiana kierunku
int currentx = n % 2 == 0 ? start - 1 : start; // miejsce od ktorego zaczynamy
int currenty = start; // miejsce od ktorego zaczynamy
int direction = 0; // wschod = 0, polnoc = 1, zachod = 2; poludnie = 3
for (int i = 1; i <= n * n; i++){
spiral[currenty][currentx] = i;
if (currentMax == 0){ // jesli prawda trzeba zmienic kierunek
max++;
currentMax = max / 2;
direction++;
if (direction == 4)
direction = 0;
}
if (direction == 0) // zmiana parametru zaleznie od kierunku w ktorym idzie algorytm
currentx++;
if (direction == 1)
currenty--;
if (direction == 2)
currentx--;
if (direction == 3)
currenty++;
currentMax--;
}
}
static void fillingWithZeros(int[][] spiral, int n){
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!ifPrimary(spiral[i][j]))
spiral[i][j] = 0;
}
static void printingTheSpiral(int[][] spiral, int n){
for (int i=0; i<n; i++) {
for (int j = 0; j < n; j++)
if (spiral[i][j] != 0)
System.out.print("* ");
else
System.out.print(" ");
System.out.print('\n');
}
}
public static void main(String[] args){
int size = Integer.parseInt(args[0]);
if (size < 2 || size > 200)
throw new IllegalArgumentException("parametr spoza zakresu 2...200");
int[][] spiral = new int[size][size];
fillingTheSieve();
fillingTheSpiral(spiral, size);
fillingWithZeros(spiral, size);
printingTheSpiral(spiral, size);
}
}
| // (maks / 2) oznacza ile powinien algorytm przypisac liczb w jednej lini | //Piotr Stokłosa Zadanie1
public class Spirala {
private static final boolean[] sieve = new boolean[40001];
static boolean ifPrimary(int number){
return !sieve[number];
}
static void fillingTheSieve(){
sieve[0] = true;
sieve[1] = true;
for (int i = 2; i < 40001; i++)
if (!sieve[i])
for (int j = i * i; j < 40001; j += i)
sieve[j] = true;
}
static void fillingTheSpiral(int[][] spiral, int n){
int start = n / 2;
int max = 2; // (maks / <SUF>
int currentMax = 1; // oznacza ile jeszcze trzeba przypisac liczb przed zmiana kierunku
int currentx = n % 2 == 0 ? start - 1 : start; // miejsce od ktorego zaczynamy
int currenty = start; // miejsce od ktorego zaczynamy
int direction = 0; // wschod = 0, polnoc = 1, zachod = 2; poludnie = 3
for (int i = 1; i <= n * n; i++){
spiral[currenty][currentx] = i;
if (currentMax == 0){ // jesli prawda trzeba zmienic kierunek
max++;
currentMax = max / 2;
direction++;
if (direction == 4)
direction = 0;
}
if (direction == 0) // zmiana parametru zaleznie od kierunku w ktorym idzie algorytm
currentx++;
if (direction == 1)
currenty--;
if (direction == 2)
currentx--;
if (direction == 3)
currenty++;
currentMax--;
}
}
static void fillingWithZeros(int[][] spiral, int n){
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!ifPrimary(spiral[i][j]))
spiral[i][j] = 0;
}
static void printingTheSpiral(int[][] spiral, int n){
for (int i=0; i<n; i++) {
for (int j = 0; j < n; j++)
if (spiral[i][j] != 0)
System.out.print("* ");
else
System.out.print(" ");
System.out.print('\n');
}
}
public static void main(String[] args){
int size = Integer.parseInt(args[0]);
if (size < 2 || size > 200)
throw new IllegalArgumentException("parametr spoza zakresu 2...200");
int[][] spiral = new int[size][size];
fillingTheSieve();
fillingTheSpiral(spiral, size);
fillingWithZeros(spiral, size);
printingTheSpiral(spiral, size);
}
}
| f | null |
295 | 3706_5 | PizzaHub/PWZP | 461 | PWZP/src/app/TextFieldLimit.java | package app;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;
/**
* Klasa umożliwiająca ograniczenie liczby wprowadzanych znaków dla komponentu JTextField
*
*/
public class TextFieldLimit extends PlainDocument {
/**
* Zmienna przechowująca limit wprowadzanych znaków
*/
private int limit;
/**
* Konstruktor z parametrem klasy TextFieldLimit
* @param limit
*/
public TextFieldLimit(int limit){
this.setLimit(limit);
}
public void setLimit(int limit) {
this.limit = limit;
}
public int getLimit() {
return limit;
}
/**
* Metoda z rozszerzanej klasy PlainDocument
*/
public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException {
//Jeśli string jest pusty to nic nie zwraca
if (str == null)
return;
//Jeśli tekst wprowadzony plus jego długość jest mniejszy lub równy z limitem to zostanie wyświetlony
if ((getLength() + str.length()) <= limit) {
super.insertString(offset, str, attr);
}
}
//offset - offset(przesunięcie) w dokumencie do wprowadzania zawartości wiekszej lub rownej 0
//str - łańcuch znaków do wprowadzania
//attr - atrybuty dla wprowadzanej zawartośći
}
| //Jeśli tekst wprowadzony plus jego długość jest mniejszy lub równy z limitem to zostanie wyświetlony | package app;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;
/**
* Klasa umożliwiająca ograniczenie liczby wprowadzanych znaków dla komponentu JTextField
*
*/
public class TextFieldLimit extends PlainDocument {
/**
* Zmienna przechowująca limit wprowadzanych znaków
*/
private int limit;
/**
* Konstruktor z parametrem klasy TextFieldLimit
* @param limit
*/
public TextFieldLimit(int limit){
this.setLimit(limit);
}
public void setLimit(int limit) {
this.limit = limit;
}
public int getLimit() {
return limit;
}
/**
* Metoda z rozszerzanej klasy PlainDocument
*/
public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException {
//Jeśli string jest pusty to nic nie zwraca
if (str == null)
return;
//Jeśli tekst <SUF>
if ((getLength() + str.length()) <= limit) {
super.insertString(offset, str, attr);
}
}
//offset - offset(przesunięcie) w dokumencie do wprowadzania zawartości wiekszej lub rownej 0
//str - łańcuch znaków do wprowadzania
//attr - atrybuty dla wprowadzanej zawartośći
}
| f | null |
296 | 8447_0 | Pkow1999/AOC2023 | 563 | day6/ex1.java | package day6;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ex1 {
public static void main(String[] args) throws FileNotFoundException {
String inputFilePath = "day6/Input";
File file = new File(inputFilePath);
Scanner reader = new Scanner(file);
String Time = reader.nextLine();
String Distance = reader.nextLine();
Matcher matchTime = Pattern.compile("\\d+").matcher(Time);
Matcher matchDistance = Pattern.compile("\\d+").matcher(Distance);
int result = 1;
while(matchTime.find() && matchDistance.find())
{
int timeOfRace = Integer.valueOf(matchTime.group());
int distanceToBeat = Integer.valueOf(matchDistance.group());
int counter = 0;
int previousDistance = 0;
for (int speed = 1; speed <= timeOfRace/2; ++speed)//mozna o polowe bo pozniej bede miec takie same wyniki tylko odwrocone
{
int newDistance = (timeOfRace - speed) * speed;
// if(newDistance > previousDistance){
// previousDistance = newDistance;
// }
// else if(newDistance == previousDistance)
// {
// counter *= 2;
// break;
// }
// else
// {
// counter = counter * 2 - 1;
// break;
// }
if(newDistance > distanceToBeat){
counter = counter + 2; //no i mamy podwojne wyniki
}
}
counter = counter - (timeOfRace + 1)%2;//jesli wyscig mial parzysty czas to odejmujemy jeden bo mamy o jednego dubla za duzo [liczba wychodzi nieparzysta]
System.out.println(counter);
result *= counter;
}
System.out.println(result);
reader.close();
}
}
| //mozna o polowe bo pozniej bede miec takie same wyniki tylko odwrocone | package day6;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ex1 {
public static void main(String[] args) throws FileNotFoundException {
String inputFilePath = "day6/Input";
File file = new File(inputFilePath);
Scanner reader = new Scanner(file);
String Time = reader.nextLine();
String Distance = reader.nextLine();
Matcher matchTime = Pattern.compile("\\d+").matcher(Time);
Matcher matchDistance = Pattern.compile("\\d+").matcher(Distance);
int result = 1;
while(matchTime.find() && matchDistance.find())
{
int timeOfRace = Integer.valueOf(matchTime.group());
int distanceToBeat = Integer.valueOf(matchDistance.group());
int counter = 0;
int previousDistance = 0;
for (int speed = 1; speed <= timeOfRace/2; ++speed)//mozna o <SUF>
{
int newDistance = (timeOfRace - speed) * speed;
// if(newDistance > previousDistance){
// previousDistance = newDistance;
// }
// else if(newDistance == previousDistance)
// {
// counter *= 2;
// break;
// }
// else
// {
// counter = counter * 2 - 1;
// break;
// }
if(newDistance > distanceToBeat){
counter = counter + 2; //no i mamy podwojne wyniki
}
}
counter = counter - (timeOfRace + 1)%2;//jesli wyscig mial parzysty czas to odejmujemy jeden bo mamy o jednego dubla za duzo [liczba wychodzi nieparzysta]
System.out.println(counter);
result *= counter;
}
System.out.println(result);
reader.close();
}
}
| f | null |
297 | 4027_11 | Platonn/FishKey | 2,531 | src/com/fishkey/QuizRound.java | package com.fishkey;
import android.util.Log;
import com.fishkey.exceptions.EndOfQuizException;
import com.fishkey.exceptions.EndOfQuizRoundException;
import com.fishkey.model.AnswerCorrectness;
import com.fishkey.model.AnswerCorrectnessList;
import com.fishkey.model.AnswerCorrectness;
import com.fishkey.model.FlashcardIdList;
import com.fishkey.model.ShuffleLinkedList;
/**
* runda quizu
* @author Platon
*
*/
public class QuizRound {
/**
* lista id fiszek do przepytania
*/
FlashcardIdList idToAskList;
/**
* lista id fiszek, na ktore udzielono poprawnej odpowiedzi
*/
AnswerCorrectnessList answeredCorrectList;
/**
* lista id fiszek, na ktore udzielono blednej odpowiedzi
*/
AnswerCorrectnessList answeredWrongList;
/**
* ilosc fiszek do przepytania w rundzie
*/
public final int SIZE;
/**
* numer rundy
* <p>
* w konstruktorze numer rundy jest ustalany na podstawie <code>roundCounter</code>
* @see #roundCounter
*/
public final int NUMBER;
/**
* tag to oznaczania logow
*/
private static final String LOG_TAG = QuizRound.class.getName();
/**
* przygotowuje runde do przeprowadzenia, ustawia jej numer na 1
* <p>
* ustawia podany zestaw fiszek jako zestaw do przepytania
* @param fs zestaw fiszek do przepytania w rundzie
*/
public QuizRound(FlashcardIdList idToAskList) {
this.idToAskList = idToAskList;
answeredCorrectList = new AnswerCorrectnessList();
answeredWrongList = new AnswerCorrectnessList();
SIZE = idToAskList.size();
NUMBER = 1;
Log.v(LOG_TAG,"Rozpoczeto runde nr " + NUMBER);
}
/**
* przygotowuje kolejna runde do przeprowadzenia na podstawie poprzedniej,
* ustawia jej numer na o 1 wiekszy niz poprzedniej
* <p>
* kopiuje z poprzedniej rundy zestaw fiszek nieodgadnietych do zestawu fiszek do przepytania
* biezacej rundzie
* @param prevRound poprzednia runda
* @throws EndOfQuizException rzucany, gdy w konstruktorze rundy zostanie podany pusty zestaw fiszek
*/
public QuizRound(QuizRound prevRound) throws EndOfQuizException {
AnswerCorrectnessList prevAnsweredWrong = prevRound.getAnsweredWrongIdList();
if(prevAnsweredWrong.isEmpty()) {
Log.v(LOG_TAG,"Koniec quizu");
throw new EndOfQuizException();
}
idToAskList = new FlashcardIdList();
for(AnswerCorrectness idWithAnsw : prevAnsweredWrong) {
idToAskList.add(idWithAnsw.getId());
}
answeredCorrectList = new AnswerCorrectnessList();
answeredWrongList = new AnswerCorrectnessList();
SIZE = idToAskList.size();
NUMBER = prevRound.NUMBER + 1;
Log.v(LOG_TAG,"Rozpoczeto nastepna runde nr " + NUMBER);
}
/* Implementacja metod interfejsu IFlashcardPassOn */
public Long popFlashcardId() throws EndOfQuizRoundException {
if (isEnd()) {
Log.v(LOG_TAG,"Koniec rundy nr "+NUMBER);
throw new EndOfQuizRoundException(getReport());
}
else
return idToAskList.poll();
}
public void putAnswered(AnswerCorrectness idWithAnsw) {
if (idWithAnsw.getAnswer().equals(AnswerCorrectness.Correctness.CORRECT)){
answeredCorrectList.offer(idWithAnsw);
Log.v(LOG_TAG,"Dodano do listy poprawnych id fiszki: " + idWithAnsw.getId());
} else if (idWithAnsw.getAnswer().equals(AnswerCorrectness.Correctness.WRONG)) {
answeredWrongList.offer(idWithAnsw);
Log.v(LOG_TAG,"Dodano do listy blednych id fiszki: " + idWithAnsw.getId());
} else {
Log.w(LOG_TAG,"Nie mozna dodac do listy poprawnych ani blednych id fiszki: "+ idWithAnsw.getId());
}
}
/* Implementacja metod wlasnych */
/**
* zwraca info, czy jest juz rundy quizu
* <p>
* zwraca info, czy skonczyly sie juz fiszki do przepytania w tej rundzie
*
* @return true, jesli zestaw koniec rundy, false w przeciwnym przypadku
*/
private boolean isEnd(){
return idToAskList.isEmpty();
}
/**
* zwraca zestaw dobrze odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku zwraca false
*
* @return zestaw dobrze odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku zwraca false
*/
public AnswerCorrectnessList getAnsweredCorrectList(){
if(isEnd())
return this.answeredCorrectList;
else
return null;
}
/**
* zwraca zestaw zle odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku zwraca false
*
* @return zestaw zle odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku false
*/
public AnswerCorrectnessList getAnsweredWrongIdList(){
if(isEnd())
return this.answeredWrongList;
else
return null;
}
/**
* Dodaje fiszke do zestawu dobrze ogadnietych
* @param fiszka do dodania do zestawu dobrze odgadnietych
*/
public void answeredCorrect(AnswerCorrectness idWithAnsw){
answeredCorrectList.offer(idWithAnsw);
}
/**
* Dodaje fiszke do zestawu dobrze ogadnietych
* @param fiszka do dodania do zestawu dobrze odgadnietych
*/
public void answeredWrong(AnswerCorrectness idWithAnsw){
answeredWrongList.offer(idWithAnsw);
}
/**
* raport stanu rundy
* @author Platon
*
*/
public class Report {
int correctNum;
int wrongNum;
int roundSize;
int roundNumber;
public Report(){
correctNum = QuizRound.this.getNumCorrect();
wrongNum = QuizRound.this.getNumWrong();
roundSize = QuizRound.this.SIZE;
roundNumber = QuizRound.this.NUMBER;
Log.v(LOG_TAG,"Utworzono raport CWSN: " + correctNum + " " + wrongNum + " " + roundSize + " " + roundNumber);
}
/* gettery */
public int getNumCorrect() { return correctNum; }
public int getNumWrong() { return wrongNum; }
public int getRoundSize() { return roundSize; }
public int getRoundNumber() { return roundNumber; }
}
/**
* zwraca raport z aktualnego stanu rundy
* @return raport z aktualnego stanu rundy
*/
public Report getReport(){
return new Report();
}
/**
* zwraca liczbe poprawnych odpowiedzi w tej rundzie
* @return liczba poprawnych odpowiedzi w tej rundzie
*/
public int getNumCorrect(){
return answeredCorrectList.size();
}
/**
* zwraca liczbe blednych odpowiedzi w tej rundzie
* @return liczba blednych odpowiedzi w tej rundzie
*/
public int getNumWrong(){
return answeredWrongList.size();
}
}
| /**
* zwraca info, czy jest juz rundy quizu
* <p>
* zwraca info, czy skonczyly sie juz fiszki do przepytania w tej rundzie
*
* @return true, jesli zestaw koniec rundy, false w przeciwnym przypadku
*/ | package com.fishkey;
import android.util.Log;
import com.fishkey.exceptions.EndOfQuizException;
import com.fishkey.exceptions.EndOfQuizRoundException;
import com.fishkey.model.AnswerCorrectness;
import com.fishkey.model.AnswerCorrectnessList;
import com.fishkey.model.AnswerCorrectness;
import com.fishkey.model.FlashcardIdList;
import com.fishkey.model.ShuffleLinkedList;
/**
* runda quizu
* @author Platon
*
*/
public class QuizRound {
/**
* lista id fiszek do przepytania
*/
FlashcardIdList idToAskList;
/**
* lista id fiszek, na ktore udzielono poprawnej odpowiedzi
*/
AnswerCorrectnessList answeredCorrectList;
/**
* lista id fiszek, na ktore udzielono blednej odpowiedzi
*/
AnswerCorrectnessList answeredWrongList;
/**
* ilosc fiszek do przepytania w rundzie
*/
public final int SIZE;
/**
* numer rundy
* <p>
* w konstruktorze numer rundy jest ustalany na podstawie <code>roundCounter</code>
* @see #roundCounter
*/
public final int NUMBER;
/**
* tag to oznaczania logow
*/
private static final String LOG_TAG = QuizRound.class.getName();
/**
* przygotowuje runde do przeprowadzenia, ustawia jej numer na 1
* <p>
* ustawia podany zestaw fiszek jako zestaw do przepytania
* @param fs zestaw fiszek do przepytania w rundzie
*/
public QuizRound(FlashcardIdList idToAskList) {
this.idToAskList = idToAskList;
answeredCorrectList = new AnswerCorrectnessList();
answeredWrongList = new AnswerCorrectnessList();
SIZE = idToAskList.size();
NUMBER = 1;
Log.v(LOG_TAG,"Rozpoczeto runde nr " + NUMBER);
}
/**
* przygotowuje kolejna runde do przeprowadzenia na podstawie poprzedniej,
* ustawia jej numer na o 1 wiekszy niz poprzedniej
* <p>
* kopiuje z poprzedniej rundy zestaw fiszek nieodgadnietych do zestawu fiszek do przepytania
* biezacej rundzie
* @param prevRound poprzednia runda
* @throws EndOfQuizException rzucany, gdy w konstruktorze rundy zostanie podany pusty zestaw fiszek
*/
public QuizRound(QuizRound prevRound) throws EndOfQuizException {
AnswerCorrectnessList prevAnsweredWrong = prevRound.getAnsweredWrongIdList();
if(prevAnsweredWrong.isEmpty()) {
Log.v(LOG_TAG,"Koniec quizu");
throw new EndOfQuizException();
}
idToAskList = new FlashcardIdList();
for(AnswerCorrectness idWithAnsw : prevAnsweredWrong) {
idToAskList.add(idWithAnsw.getId());
}
answeredCorrectList = new AnswerCorrectnessList();
answeredWrongList = new AnswerCorrectnessList();
SIZE = idToAskList.size();
NUMBER = prevRound.NUMBER + 1;
Log.v(LOG_TAG,"Rozpoczeto nastepna runde nr " + NUMBER);
}
/* Implementacja metod interfejsu IFlashcardPassOn */
public Long popFlashcardId() throws EndOfQuizRoundException {
if (isEnd()) {
Log.v(LOG_TAG,"Koniec rundy nr "+NUMBER);
throw new EndOfQuizRoundException(getReport());
}
else
return idToAskList.poll();
}
public void putAnswered(AnswerCorrectness idWithAnsw) {
if (idWithAnsw.getAnswer().equals(AnswerCorrectness.Correctness.CORRECT)){
answeredCorrectList.offer(idWithAnsw);
Log.v(LOG_TAG,"Dodano do listy poprawnych id fiszki: " + idWithAnsw.getId());
} else if (idWithAnsw.getAnswer().equals(AnswerCorrectness.Correctness.WRONG)) {
answeredWrongList.offer(idWithAnsw);
Log.v(LOG_TAG,"Dodano do listy blednych id fiszki: " + idWithAnsw.getId());
} else {
Log.w(LOG_TAG,"Nie mozna dodac do listy poprawnych ani blednych id fiszki: "+ idWithAnsw.getId());
}
}
/* Implementacja metod wlasnych */
/**
* zwraca info, czy <SUF>*/
private boolean isEnd(){
return idToAskList.isEmpty();
}
/**
* zwraca zestaw dobrze odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku zwraca false
*
* @return zestaw dobrze odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku zwraca false
*/
public AnswerCorrectnessList getAnsweredCorrectList(){
if(isEnd())
return this.answeredCorrectList;
else
return null;
}
/**
* zwraca zestaw zle odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku zwraca false
*
* @return zestaw zle odpowiedzianych fiszek, jesli nastapil juz koniec quizu,
* w przeciwnym przypadku false
*/
public AnswerCorrectnessList getAnsweredWrongIdList(){
if(isEnd())
return this.answeredWrongList;
else
return null;
}
/**
* Dodaje fiszke do zestawu dobrze ogadnietych
* @param fiszka do dodania do zestawu dobrze odgadnietych
*/
public void answeredCorrect(AnswerCorrectness idWithAnsw){
answeredCorrectList.offer(idWithAnsw);
}
/**
* Dodaje fiszke do zestawu dobrze ogadnietych
* @param fiszka do dodania do zestawu dobrze odgadnietych
*/
public void answeredWrong(AnswerCorrectness idWithAnsw){
answeredWrongList.offer(idWithAnsw);
}
/**
* raport stanu rundy
* @author Platon
*
*/
public class Report {
int correctNum;
int wrongNum;
int roundSize;
int roundNumber;
public Report(){
correctNum = QuizRound.this.getNumCorrect();
wrongNum = QuizRound.this.getNumWrong();
roundSize = QuizRound.this.SIZE;
roundNumber = QuizRound.this.NUMBER;
Log.v(LOG_TAG,"Utworzono raport CWSN: " + correctNum + " " + wrongNum + " " + roundSize + " " + roundNumber);
}
/* gettery */
public int getNumCorrect() { return correctNum; }
public int getNumWrong() { return wrongNum; }
public int getRoundSize() { return roundSize; }
public int getRoundNumber() { return roundNumber; }
}
/**
* zwraca raport z aktualnego stanu rundy
* @return raport z aktualnego stanu rundy
*/
public Report getReport(){
return new Report();
}
/**
* zwraca liczbe poprawnych odpowiedzi w tej rundzie
* @return liczba poprawnych odpowiedzi w tej rundzie
*/
public int getNumCorrect(){
return answeredCorrectList.size();
}
/**
* zwraca liczbe blednych odpowiedzi w tej rundzie
* @return liczba blednych odpowiedzi w tej rundzie
*/
public int getNumWrong(){
return answeredWrongList.size();
}
}
| f | null |
299 | 3792_0 | Pp-4/projekt_java | 784 | ProjektBiblioteka/src/com/company/Models/BoardGame.java | package com.company.Models;
import com.company.Models.EnumsForModels.AccesLevel;
import com.company.Models.EnumsForModels.Complexity;
import com.company.Models.EnumsForModels.GameCategory;
import java.util.List;
import java.util.Objects;
public class BoardGame implements IDataBaseObject{
//Wszystkie poniższe informacje o grach planszowych można znależć na boardgamegeek.com
// wszytie typy muszą mieć wrappery(typy pierwotne nie mają metody/pola class , dlaczego ? nie wiem)
public Integer gameId;
public String name;
public Integer yearPublished;
public Integer minPlayers;
public Integer maxPlayers;
public Integer playingTimeInMinutes;
public Integer minimalAge;
public Integer overallRank;
public Double avgRating;
public Integer BGGRank;//tymczasowy fix ze względu na niekompatybilność modelu a rzeczywistej tabeli
public Double complexity;
public Integer OwnedUsers;
public String[] mechanics;
public String[] domains;
public Boolean isAvailable;
public BoardGame(){}
//da się coś z tym zrobić ?
public BoardGame(int gameId,String name,int yearPublished,int minPlayers,int maxPlayers, int playTime, int minimalAge,double avgRating,String[] mechanics, int overallRank,double complexity,String[] domains,boolean isAvailable){
this.gameId = gameId;
this.name = name;
this.yearPublished = yearPublished;
this.minPlayers = minPlayers;
this.maxPlayers = maxPlayers;
this.avgRating = avgRating;
this.minimalAge = minimalAge;
this.mechanics = mechanics;
this.playingTimeInMinutes = playTime;
this.overallRank = overallRank;
this.complexity = complexity;
this.domains = domains;
this.isAvailable = isAvailable;
}
@Override
public String toString() {
Integer Players;
if(Objects.equals(minPlayers, maxPlayers)){
return "Id:" + gameId + "| Tytul: "+ name + " | Gatunek: " + domains[0] +" | Ilosc graczy: " + maxPlayers;
}
else {
return "Id:" + gameId + "| Tytul: "+ name + " | Gatunek: " + domains[0] +" | Ilosc graczy: " + minPlayers+ "-"+ maxPlayers;
}
}
@Override
public String sqlTableName() {
//TODO: wskazanie odpowiadającej tabeli z bazy danych
//poniżej znajduje się kod z C#, który jest za to odpowiedzialny
//public override string SqlTableName { get { return "Users"; } }
return null;
}
}
| //Wszystkie poniższe informacje o grach planszowych można znależć na boardgamegeek.com | package com.company.Models;
import com.company.Models.EnumsForModels.AccesLevel;
import com.company.Models.EnumsForModels.Complexity;
import com.company.Models.EnumsForModels.GameCategory;
import java.util.List;
import java.util.Objects;
public class BoardGame implements IDataBaseObject{
//Wszystkie poniższe <SUF>
// wszytie typy muszą mieć wrappery(typy pierwotne nie mają metody/pola class , dlaczego ? nie wiem)
public Integer gameId;
public String name;
public Integer yearPublished;
public Integer minPlayers;
public Integer maxPlayers;
public Integer playingTimeInMinutes;
public Integer minimalAge;
public Integer overallRank;
public Double avgRating;
public Integer BGGRank;//tymczasowy fix ze względu na niekompatybilność modelu a rzeczywistej tabeli
public Double complexity;
public Integer OwnedUsers;
public String[] mechanics;
public String[] domains;
public Boolean isAvailable;
public BoardGame(){}
//da się coś z tym zrobić ?
public BoardGame(int gameId,String name,int yearPublished,int minPlayers,int maxPlayers, int playTime, int minimalAge,double avgRating,String[] mechanics, int overallRank,double complexity,String[] domains,boolean isAvailable){
this.gameId = gameId;
this.name = name;
this.yearPublished = yearPublished;
this.minPlayers = minPlayers;
this.maxPlayers = maxPlayers;
this.avgRating = avgRating;
this.minimalAge = minimalAge;
this.mechanics = mechanics;
this.playingTimeInMinutes = playTime;
this.overallRank = overallRank;
this.complexity = complexity;
this.domains = domains;
this.isAvailable = isAvailable;
}
@Override
public String toString() {
Integer Players;
if(Objects.equals(minPlayers, maxPlayers)){
return "Id:" + gameId + "| Tytul: "+ name + " | Gatunek: " + domains[0] +" | Ilosc graczy: " + maxPlayers;
}
else {
return "Id:" + gameId + "| Tytul: "+ name + " | Gatunek: " + domains[0] +" | Ilosc graczy: " + minPlayers+ "-"+ maxPlayers;
}
}
@Override
public String sqlTableName() {
//TODO: wskazanie odpowiadającej tabeli z bazy danych
//poniżej znajduje się kod z C#, który jest za to odpowiedzialny
//public override string SqlTableName { get { return "Users"; } }
return null;
}
}
| f | null |
300 | 6788_0 | Prawy126/Java | 778 | Algorytmy_Lab/PlecakDynamicznie/src/Main.java | public class Main {
public static void main(String[] args) {
// Definicja tablic z wagami i wartościami przedmiotów
final int[] objetosci = {6, 2, 3, 2, 3, 1};
final int[] wartosci = {6, 4, 5, 7, 10, 2};
// Maksymalna pojemność plecaka
final int MAX = 10;
// Liczba dostępnych przedmiotów
final int iloscPrzedmiotow = objetosci.length;
// Tablica wyników przechowująca maksymalne wartości plecaka dla różnych kombinacji przedmiotów i pojemności plecaka
int[][] tablicaWynikow = new int[iloscPrzedmiotow][MAX+1];
// Wypełnianie tablicy wyników algorytmem rozwiązywania problemu plecaka
for (int i=0; i<iloscPrzedmiotow; i++) {
for (int j=0; j<MAX+1; j++) {
if (i == 0 && objetosci[i] > j) {
// Jeśli to pierwszy przedmiot i jego waga jest większa niż pojemność plecaka, to nie możemy go umieścić w plecaku
tablicaWynikow[i][j] = 0;
} else if (i == 0 && objetosci[i] <= j) {
// Jeśli to pierwszy przedmiot i jego waga jest mniejsza lub równa pojemności plecaka, to umieszczamy go w plecaku
tablicaWynikow[i][j] = wartosci[i];
} else if (i > 0 && objetosci[i] > j) {
// Jeśli waga aktualnego przedmiotu jest większa niż pojemność plecaka, nie możemy go umieścić, więc bierzemy wynik z poprzedniego wiersza
tablicaWynikow[i][j] = tablicaWynikow[i-1][j];
} else if (i > 0 && objetosci[i] <= j) {
// Jeśli możemy umieścić przedmiot w plecaku, wybieramy maksimum spośród dwóch możliwości: wzięcie przedmiotu lub pozostawienie go
tablicaWynikow[i][j] = Math.max(tablicaWynikow[i - 1][j], wartosci[i] + tablicaWynikow[i - 1][j - objetosci[i]]);
}
}
}
// Wyświetlenie maksymalnej wartości plecaka dla danej pojemności
System.out.println("Maksymalna wartość plecaka to " + tablicaWynikow[iloscPrzedmiotow-1][MAX] + " przy pojemności " + MAX);
}
}
| // Definicja tablic z wagami i wartościami przedmiotów | public class Main {
public static void main(String[] args) {
// Definicja tablic <SUF>
final int[] objetosci = {6, 2, 3, 2, 3, 1};
final int[] wartosci = {6, 4, 5, 7, 10, 2};
// Maksymalna pojemność plecaka
final int MAX = 10;
// Liczba dostępnych przedmiotów
final int iloscPrzedmiotow = objetosci.length;
// Tablica wyników przechowująca maksymalne wartości plecaka dla różnych kombinacji przedmiotów i pojemności plecaka
int[][] tablicaWynikow = new int[iloscPrzedmiotow][MAX+1];
// Wypełnianie tablicy wyników algorytmem rozwiązywania problemu plecaka
for (int i=0; i<iloscPrzedmiotow; i++) {
for (int j=0; j<MAX+1; j++) {
if (i == 0 && objetosci[i] > j) {
// Jeśli to pierwszy przedmiot i jego waga jest większa niż pojemność plecaka, to nie możemy go umieścić w plecaku
tablicaWynikow[i][j] = 0;
} else if (i == 0 && objetosci[i] <= j) {
// Jeśli to pierwszy przedmiot i jego waga jest mniejsza lub równa pojemności plecaka, to umieszczamy go w plecaku
tablicaWynikow[i][j] = wartosci[i];
} else if (i > 0 && objetosci[i] > j) {
// Jeśli waga aktualnego przedmiotu jest większa niż pojemność plecaka, nie możemy go umieścić, więc bierzemy wynik z poprzedniego wiersza
tablicaWynikow[i][j] = tablicaWynikow[i-1][j];
} else if (i > 0 && objetosci[i] <= j) {
// Jeśli możemy umieścić przedmiot w plecaku, wybieramy maksimum spośród dwóch możliwości: wzięcie przedmiotu lub pozostawienie go
tablicaWynikow[i][j] = Math.max(tablicaWynikow[i - 1][j], wartosci[i] + tablicaWynikow[i - 1][j - objetosci[i]]);
}
}
}
// Wyświetlenie maksymalnej wartości plecaka dla danej pojemności
System.out.println("Maksymalna wartość plecaka to " + tablicaWynikow[iloscPrzedmiotow-1][MAX] + " przy pojemności " + MAX);
}
}
| f | null |
301 | 3410_1 | Prawy126/Kolejka-FIFO | 1,395 | Sklep_Internetowy/src/Grafika/Kasa.java | package Grafika;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import CSV.KlientCSV;
import Dzwieki.MusicPlayerConsole;
import Klient.Klient;
import Towary.MagazynSklapowy;
public class Kasa extends JFrame{
private JPanel Wyswietlacz;
private JButton zapłaćKartąButton;
private JButton zrezygnujZZakupówButton;
private JLabel Kolejka;
private JButton cofnijButton;
public Kasa(Klient klient, int numerKolejki, MagazynSklapowy magazynSklapowy,Klient[] klienci){
super("Kasa");
this.setContentPane(Wyswietlacz);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(600,300);
this.setVisible(true);
zapłaćKartąButton.setEnabled(false);
MusicPlayerConsole muzyka = new MusicPlayerConsole();
muzyka.playMusicLoop();
Timer timer = new Timer();
Random random = new Random();
int interwal = (random.nextInt(5)+1) * 1000; // Interwał w milisekundach (3 minuty i 52 sekundy)
timer.scheduleAtFixedRate(new TimerTask() {
int lista2 = numerKolejki;
@Override
public void run() {
lista2 = lista2 - 1;
if (lista2 > 0) {
// Aktualizuj etykietę tekstową w wątku dystrybucji Swing
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
Kolejka.setText("Aktualnie jesteś " + lista2);
}
});
} else {
// Zakończ zadanie po zadanym czasie
zapłaćKartąButton.setEnabled(true);
Kolejka.setText("Teraz twoja kolej \t Do zapłaty: " + klient.ileDoZaplaty());
timer.cancel();
System.out.println(klient.ileDoZaplaty());
zapłaćKartąButton.setEnabled(true);
}
}
}, 0, interwal);
// Dodaj WindowListener, aby zatrzymać odtwarzanie muzyki przy zamknięciu okna
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
timer.cancel(); // Zatrzymaj zadanie Timera
muzyka.stopMusic();
}
});
zapłaćKartąButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if(klient.zwrocStanKonta()>=klient.ileDoZaplaty()) {
JOptionPane.showMessageDialog(null, "Transakcja udana", "Wszystko poszło pomyślnie", JOptionPane.INFORMATION_MESSAGE);
klient.odejmijZKonta(klient.ileDoZaplaty());
KlientCSV.updateKlientAccount(klient.podajLogin(), klient.podajZawartoscKonta(), "src\\CSV\\BazaDanychKlientow.csv");
JOptionPane.showMessageDialog(null, "Aktualny stan konta " + klient.zwrocStanKonta(), "Ile na koncie", JOptionPane.INFORMATION_MESSAGE);
zapłaćKartąButton.setEnabled(false);
int decyzja = JOptionPane.showConfirmDialog(null,"Czy chcesz jeszcze cos kupić jeszcze","tak",JOptionPane.YES_NO_OPTION);
if(decyzja==JOptionPane.YES_OPTION){
muzyka.stopMusic();
dispose();
GUISklep guiSklep = new GUISklep(random.nextInt(20),klient,magazynSklapowy,klienci);
}else {
dispose();
}
}else{
JOptionPane.showMessageDialog(null,"Za mało pieniędzy na koncie","Transakcja nie udana",JOptionPane.ERROR_MESSAGE);
}
}
});
zrezygnujZZakupówButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
timer.cancel();
muzyka.stopMusic();
dispose();
}
});
cofnijButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
GUISklep guiSklep = new GUISklep(numerKolejki,klient,magazynSklapowy,klienci);
dispose();
muzyka.stopMusic();
}
});
}
}
| // Aktualizuj etykietę tekstową w wątku dystrybucji Swing | package Grafika;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import CSV.KlientCSV;
import Dzwieki.MusicPlayerConsole;
import Klient.Klient;
import Towary.MagazynSklapowy;
public class Kasa extends JFrame{
private JPanel Wyswietlacz;
private JButton zapłaćKartąButton;
private JButton zrezygnujZZakupówButton;
private JLabel Kolejka;
private JButton cofnijButton;
public Kasa(Klient klient, int numerKolejki, MagazynSklapowy magazynSklapowy,Klient[] klienci){
super("Kasa");
this.setContentPane(Wyswietlacz);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(600,300);
this.setVisible(true);
zapłaćKartąButton.setEnabled(false);
MusicPlayerConsole muzyka = new MusicPlayerConsole();
muzyka.playMusicLoop();
Timer timer = new Timer();
Random random = new Random();
int interwal = (random.nextInt(5)+1) * 1000; // Interwał w milisekundach (3 minuty i 52 sekundy)
timer.scheduleAtFixedRate(new TimerTask() {
int lista2 = numerKolejki;
@Override
public void run() {
lista2 = lista2 - 1;
if (lista2 > 0) {
// Aktualizuj etykietę <SUF>
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
Kolejka.setText("Aktualnie jesteś " + lista2);
}
});
} else {
// Zakończ zadanie po zadanym czasie
zapłaćKartąButton.setEnabled(true);
Kolejka.setText("Teraz twoja kolej \t Do zapłaty: " + klient.ileDoZaplaty());
timer.cancel();
System.out.println(klient.ileDoZaplaty());
zapłaćKartąButton.setEnabled(true);
}
}
}, 0, interwal);
// Dodaj WindowListener, aby zatrzymać odtwarzanie muzyki przy zamknięciu okna
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
timer.cancel(); // Zatrzymaj zadanie Timera
muzyka.stopMusic();
}
});
zapłaćKartąButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if(klient.zwrocStanKonta()>=klient.ileDoZaplaty()) {
JOptionPane.showMessageDialog(null, "Transakcja udana", "Wszystko poszło pomyślnie", JOptionPane.INFORMATION_MESSAGE);
klient.odejmijZKonta(klient.ileDoZaplaty());
KlientCSV.updateKlientAccount(klient.podajLogin(), klient.podajZawartoscKonta(), "src\\CSV\\BazaDanychKlientow.csv");
JOptionPane.showMessageDialog(null, "Aktualny stan konta " + klient.zwrocStanKonta(), "Ile na koncie", JOptionPane.INFORMATION_MESSAGE);
zapłaćKartąButton.setEnabled(false);
int decyzja = JOptionPane.showConfirmDialog(null,"Czy chcesz jeszcze cos kupić jeszcze","tak",JOptionPane.YES_NO_OPTION);
if(decyzja==JOptionPane.YES_OPTION){
muzyka.stopMusic();
dispose();
GUISklep guiSklep = new GUISklep(random.nextInt(20),klient,magazynSklapowy,klienci);
}else {
dispose();
}
}else{
JOptionPane.showMessageDialog(null,"Za mało pieniędzy na koncie","Transakcja nie udana",JOptionPane.ERROR_MESSAGE);
}
}
});
zrezygnujZZakupówButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
timer.cancel();
muzyka.stopMusic();
dispose();
}
});
cofnijButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
GUISklep guiSklep = new GUISklep(numerKolejki,klient,magazynSklapowy,klienci);
dispose();
muzyka.stopMusic();
}
});
}
}
| f | null |
302 | 10259_5 | PrzemekBarczyk/swing-kalkulator | 6,663 | src/CalculatorModel.java | import java.awt.Color;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import javax.swing.JButton;
public class CalculatorModel {
private String operationLabelText; // zawartość JLabel z zapisem przeprowadzonych operacji
private String resultLabelText; // zawartość JLabel z aktualnie wprowadzoną wartością/wynikiem
private double previousNumber; // poprzednio podana wartość
private double lastNumber; // ostatnio podana wartość
private String lastOperationSign; // znak ostatniej operacji
private String stringBuff; // zmienna do przechowywania ciągów znakowych
private boolean choseNumber; // wpisano liczbę do resultLabelText
private boolean choseDot; // we wpisanej liczbie użytko przecinka
private boolean choseDyadicOperation; // wybrano jedną z operacji dwuargumentowych
private boolean chosePowOrSqlt; // wybrano operację potęgowania lub pierwiastkowania
private boolean chosePercent; // wybrano oprarację liczenia procentu
private boolean choseFraction; // wybrano operację liczenia ułamka z podanej liczby
private boolean choseEqualSign; // wybrano operację wyświetlenia wyniku
private boolean dividedByZero; // doszło do dzielenia przez 0
private DecimalFormat formatForResultLabelText; // do usunięcia powtarzających się zer z przodu i końca oraz dodania odstępów
private DecimalFormat formatForOperationLabelText; // do usunięcia powtarzających się zer z przodu i z końca
private final int MAX_NUMBERS = 13; // maksymalna liczba cyfr jakie może mieć wpisywana liczba
/**
* Ustawia zmienne
*/
public CalculatorModel() {
previousNumber = 0;
lastNumber = 0;
operationLabelText = "";
resultLabelText = "0";
lastOperationSign = "";
choseNumber = false;
choseDot = false;
choseDyadicOperation = false;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
choseEqualSign = false;
dividedByZero = false;
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setDecimalSeparator('.');
symbols.setGroupingSeparator(' ');
formatForResultLabelText = new DecimalFormat();
formatForResultLabelText.setDecimalFormatSymbols(symbols);
formatForResultLabelText.setGroupingUsed(true);
formatForResultLabelText.setMaximumIntegerDigits(MAX_NUMBERS);
formatForResultLabelText.setMaximumFractionDigits(MAX_NUMBERS);
formatForOperationLabelText = new DecimalFormat();
formatForOperationLabelText.setDecimalFormatSymbols(symbols);
formatForOperationLabelText.setGroupingUsed(false);
formatForOperationLabelText.setMaximumIntegerDigits(MAX_NUMBERS);
formatForOperationLabelText.setMaximumFractionDigits(MAX_NUMBERS);
}
/**
* Obsługuje zdarzenie wywołane wyborem dowolnej z cyfr lub przecinka
*
* Zmienia wartość resultLabelText w przypadku podania cyfry lub przecinka. Może również wyczyścić
* operationLabelText w przypadku gdy użyto equalsButton.
*
* Metoda posiada zabezpieczenia przed sytuacjami takimi jak gdy nastąpiło dzielenie przez 0, użycie przycisku
* equalsButton, podanie pierwszej cyfry oraz podanie za dużej ilości cyfr.
*
* Następnie w zależności czy wybrano dowolną z cyfr czy przecinek wykonywane są instrukcję modyfikujące
* resultLabelText.
*/
public void handleNumbers(String number) {
// zabezpieczenia przed różnymi sytuacjami
if (!number.equals(".") && dividedByZero) { // dzielenie przez 0 i wybrano cyfrę
handleClear();
dividedByZero = false;
}
else if (number.equals(".") && dividedByZero) { // dzielenie przez 0 i wybrano przecinek
return;
}
if (!choseNumber && !choseDot && !choseDyadicOperation && !choseEqualSign) { // wybrano pierwszą cyfrę lub przecinek []||[2+]||[2-3+]||[2=]
resultLabelText = "0";
}
else if (!choseNumber && !choseDot) { // użyto equalsButton i wybrano pierwszą cyfrę lub przecinek [2+3=]||[2+3-4=]
resultLabelText = "0";
operationLabelText = "";
}
else if (resultLabelText.length() > MAX_NUMBERS) { // blokada przed wpisaniem bardzo dużej liczby
return;
}
// modyfikacja resultLabelText i flag
if (!number.equals(".")) { // cyfra
resultLabelText = resultLabelText + number;
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = true;
}
else if (!choseDot) { // przecinek (wybrany po raz pierwszy)
resultLabelText = resultLabelText + number;
choseDot = true;
}
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji dwuargumentowej
*
* Zapisuje podaną wartość wraz z wybranym znakiem operacji w operationLabelText. W przypadku wybrania drugiej i
* każdej kolejnej operacji bez wybrania equalsButton zapisuje wynik w resultLabelText.
*
* Metoda posiada zabezpieczenia przed sytuacjami takimi jak gdy nastąpiło dzielenie przez 0, wybór znaku operacji
* kilka razy pod rząd, użycie przycisku equalsButton i nie podanie nowej wartości przed wyborem znaku. użycie
* nie typowej operacji lub zwykłej.
*
* Następnie w zależności czy wybrano operację jednoargumentową czy dwuargumentową modyfikowane jest
* operationLabelText. Ponadto, jeśli wybrana operacja jest drugą lub kolejną wybraną bez wybrania equalsButton
* wyznaczany jest nowy wynik.
*/
public void handleDyadicOperation(String sign) {
lastOperationSign = sign;
// zabezpieczenie przed różnymi sytuacjami
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
if (choseDyadicOperation && !choseNumber && !choseEqualSign && !chosePowOrSqlt) { // wybrano kolejny znak pod rząd [2+][2+3-]
swapSignNumber(lastOperationSign); // nadpisuje poprzedni znak nowym
return; // nie trzeba ustawiać flag, bo zostały już ustawione dla poprzedniego znaku
}
if (choseEqualSign && !choseNumber) { // użyto equalsButton i nie podano liczby [=]||[2=]||[2+3=]
operationLabelText = "";
}
// modyfikacja operationLabelText
if (chosePowOrSqlt || chosePercent || choseFraction) { // wybrano operację jednoargumentową [sqrt(2)][2+sqrt(3)]
operationLabelText = operationLabelText + " " + lastOperationSign + " ";
}
else { // wybrano operację dwuargumentową
operationLabelText = operationLabelText + formatWithoutSpacing(resultLabelText) + " " + lastOperationSign + " ";
}
// modyfikacja resultLabelText
if (choseDyadicOperation && (choseNumber || chosePowOrSqlt || chosePercent || choseFraction) && !choseEqualSign) { // wybrano operację dwuargumentową kolejny raz bez wyboru = [2+3]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
executeDyadicOperation(); // wyznacza nowy resultLabelText
}
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText); // nowa wartość
previousNumber = deleteSpacesAndConvertToDouble(resultLabelText);
choseNumber = false;
choseDot = false;
choseDyadicOperation = true;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
choseEqualSign = false;
}
/**
* Wykonuje operację dwuargumentową na podstawie ostatnio użytego znaku
*
* Modyfikuję wartość resultLabelText przy użyciu zmiennych previousNumber i lastNumber.
*/
private void executeDyadicOperation() {
switch (lastOperationSign) {
case "+":
resultLabelText = convertToString(previousNumber + lastNumber);
break;
case "-":
resultLabelText = convertToString(previousNumber - lastNumber);
break;
case "×":
resultLabelText = convertToString(previousNumber * lastNumber);
break;
case "÷":
if (lastNumber != 0) { // zabezpieczenie przed dzieleniem przez 0
resultLabelText = convertToString(previousNumber / lastNumber);
}
else {
resultLabelText = "Cannot divide by zero";
dividedByZero = true;
}
break;
default:
System.out.println("Nieznana operacja!");
}
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji potęgowania lub pierwiastkowania
*
* Modyfikuję operationLabelText w różny sposób w zależności od tego czy operacja była wywołana pierwszy czy kolejny
* raz pod rząd.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handlePowerAndSqrt(String sign) {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
// modyfikacja operationLabelText
if (!chosePowOrSqlt) { // pierwszy pod rząd wybór tej operacji
stringBuff = sign + "(" + formatWithoutSpacing(resultLabelText) + ")";
operationLabelText = operationLabelText + stringBuff;
}
else { // kolejny
String reversedBuff = new StringBuilder(stringBuff).reverse().toString();
reversedBuff = reversedBuff.replace(")", "\\)");
reversedBuff = reversedBuff.replace("(", "\\(");
stringBuff = sign + "(" + stringBuff + ")";
operationLabelText = new StringBuilder(operationLabelText).reverse().toString().replaceFirst(reversedBuff, ")" + reversedBuff + "(" + new StringBuilder(sign).reverse().toString());
operationLabelText = new StringBuilder(operationLabelText).reverse().toString();
}
// modyfikacja resultLabelText
executeUnaryOperation(sign);
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
chosePowOrSqlt = true;
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji wyznaczania procentu
*
* Modyfikuję operationLabelText w różny sposób w zależności od tego czy operacja była wywołana pierwszy czy kolejny
* raz pod rząd.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handlePercent() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
// modyfikacja operationLabelText i resultLabelText
if (!chosePercent) { // pierwszy pod rząd wybór tej operacji
executeUnaryOperation("%");
operationLabelText = operationLabelText + formatWithoutSpacing(resultLabelText);
}
else { // kolejny
String oldResult = formatWithoutSpacing(resultLabelText);
executeUnaryOperation("%");
String reversedOldResult = new StringBuilder(oldResult).reverse().toString();
operationLabelText = new StringBuilder(operationLabelText).reverse().toString().replaceFirst(reversedOldResult, new StringBuilder(resultLabelText).reverse().toString());
operationLabelText = new StringBuilder(operationLabelText).reverse().toString();
}
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
chosePercent = true;
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji wyznaczania ułamka
*
* Modyfikuję operationLabelText w różny sposób w zależności od tego czy operacja była wywołana pierwszy czy kolejny
* raz pod rząd.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleFraction() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
// modyfikacja operationLabelText
if (!choseFraction) { // pierwszy pod rząd wybór tej operacji
stringBuff = "1/( " + formatWithoutSpacing(resultLabelText) + " )";
operationLabelText = operationLabelText + stringBuff;
}
else { // kolejny
String reversedBuff = new StringBuilder(stringBuff).reverse().toString();
reversedBuff = reversedBuff.replace(")", "\\)");
reversedBuff = reversedBuff.replace("(", "\\(");
stringBuff = "1/" + "( " + stringBuff + " )";
operationLabelText = new StringBuilder(operationLabelText).reverse().toString().replaceFirst(reversedBuff, ") " + reversedBuff + " (" + new StringBuilder("1/").reverse().toString());
operationLabelText = new StringBuilder(operationLabelText).reverse().toString();
}
// modyfikacja resultLabelText
executeUnaryOperation("1/");
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
choseFraction = true;
}
/**
* Wykonuje operację jednoargumentową na podstawie otrzymanego znaku
*
* Modyfikuję wartość resultLabelText przy użyciu odpowiedniego działania na resultLabelText.
*/
private void executeUnaryOperation(String sign) {
switch(sign) {
case "sqrt":
resultLabelText = convertToString(convertToDouble(resultLabelText) * convertToDouble(resultLabelText));
break;
case "√":
resultLabelText = convertToString(Math.sqrt(convertToDouble(resultLabelText)));
break;
case "1/":
if (deleteSpacesAndConvertToDouble(resultLabelText) != 0) { // zabezpieczenie przed dzieleniem przez 0
resultLabelText = convertToString(1 / convertToDouble(resultLabelText));
}
else {
resultLabelText = "Cannot divide by zero";
dividedByZero = true;
}
break;
case "%":
resultLabelText = convertToString(convertToDouble(resultLabelText) / 100 * previousNumber);
break;
default:
System.out.println("Nieznana operacja!");
}
}
/**
* Obsługuje zdarzenie wywołane wyborem znaku =
*
* Modyfikuje operationLabelText oraz wyznacza nową wartość resultLabelText przy użyciu wartości zmiennych
* previousNumber i lastNumber.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*
* Następnie podejmowane są kroki w przypadku gdy metoda została wywołana bez wyboru operacji dwuargumentowej.
* Polegają one na modyfikacji operationLabelText i zakończeniu wykonywania metody ponieważ resultLabelText nie
* może być w takiej sytuacji modyfikowany. W przypadku gdy metoda została wywołana z wybraną operacją
* dwuargumentową modyfikowany jest operationLabelText, wykonywana jest wybrana operacja oraz wyświetlana jest
* nowa wartość resultLabelText.
*/
public void handleEqualSign() {
// zabezpieczenie przed różnymi sytuacjami
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
handleClear();
return;
}
// modyfikacja operationLabelText przy braku wyboru operacji dwuargumentowej
if (!choseDyadicOperation && !chosePowOrSqlt && !chosePercent && !choseFraction) { // nie wybrano znaku i operacji jednoargumentowej []||[=]||[2]||[2=]
operationLabelText = formatWithoutSpacing(resultLabelText) + " = ";
choseNumber = false;
choseDot = false;
choseEqualSign = true;
return;
}
if (!choseDyadicOperation) { // nie wybrano znaku i wybrano operację jednoargumentową
operationLabelText = operationLabelText + " = ";
choseNumber = false;
choseDot = false;
choseEqualSign = true;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
return;
}
// modyfikacja operationLabelText po wyborze operacji dwuargumentowej
// choseOperationSign == True zawsze w tym miejscu
if (choseEqualSign) { // wybrano znak i = kolejny raz pod rząd [2+=]||[2+3=]||[2+3==]
previousNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = formatWithoutSpacing(resultLabelText) + " " + lastOperationSign + " " + formatWithoutSpacing(convertToString(lastNumber)) + " = ";
}
else if (!choseNumber && !chosePowOrSqlt && !chosePercent && !choseFraction) { // wybrano znak i nie wybrano drugiej liczby [+]||[2+]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = operationLabelText + formatWithoutSpacing(resultLabelText) + " = ";
}
else if (chosePowOrSqlt || chosePercent || choseFraction) { // wybrano znak i operację jednoargumentową [2+sqrt(3)]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = operationLabelText + " = ";
}
else { // wybrano znak i cyfre [2+3]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = operationLabelText + formatWithoutSpacing(convertToString(lastNumber)) + " = ";
}
// modyfikacja resultLabelText
executeDyadicOperation();
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
choseEqualSign = true;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
}
/**
* Usuwa ostatni znak z resultLabelText
*
* Posiada trzy możliwe przebiegi w zależności czy ostatni znak to przecinek, cyfra oraz ostatnia cyfra.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleBackspace() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
handleClear();
return;
}
if (resultLabelText.length() == 1) { // ostatnia cyfra
resultLabelText = "0";
}
else if (!resultLabelText.endsWith(".")) { // zwykła cyfra
resultLabelText = resultLabelText.substring(0, resultLabelText.length() - 1);
}
else { // przecinek
resultLabelText = resultLabelText.substring(0, resultLabelText.length() - 1);
choseDot = false;
}
}
/**
* Usuwa zawartość resultLabelText
*
* W przypadku użycia znaku "=" działa tak samo jak clear().
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleClearEntry() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
handleClear();
return;
}
if (!choseEqualSign) {
resultLabelText = "0";
choseNumber = false;
choseDot = false;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
}
else {
handleClear();
}
}
/**
* Usuwa wszystkie wprowadzone dane i przywraca je do wartości początkowych
*/
public void handleClear() {
previousNumber = 0;
lastNumber = 0;
operationLabelText = "";
resultLabelText = "0";
lastOperationSign = "";
choseNumber = false;
choseDot = false;
choseDyadicOperation = false;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
choseEqualSign = false;
}
/**
* Obsługuje zdarzenie wywołane wyborem przycisku zmiany znaku
*
* Zmienia znak liczby przechowywanej w resultLabel na przeciwny mnożąc jej wartość przez -1.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleSignNegation() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
if (!resultLabelText.equals("0"))
resultLabelText = formatWithSpacing(convertToString(-1 * deleteSpacesAndConvertToDouble(resultLabelText)));
}
/**
* Usuwa ostatni znak z operationLabelText i zamienia go na otrzymany w argumencie
*/
private void swapSignNumber(String sign) {
if (operationLabelText.length() > 0) {
operationLabelText = operationLabelText.substring(0, operationLabelText.length()-2) + sign + " ";
}
}
/**
* Konwertuje otrzymanego doubla do Stringa
*/
private String convertToString(double number) {
return String.valueOf(number);
}
/**
* Konwertuje otrzymanego Stringa do doubla
*/
private double convertToDouble(String number) {
return Double.parseDouble(number);
}
/**
* Usuwa spację z otrzymanego Stringa i konwertuję go do doubla
*/
private double deleteSpacesAndConvertToDouble(String number) {
return Double.parseDouble(number.replace(" ", "")); // " " ma nietypowe kodowanie;
}
/**
* Formatuje otrzymanego Stringa dodając spację co 3 cyfry
*
* Używa w tym celu klasy DecimalFormat
*/
private String formatWithSpacing(String number) {
return resultLabelText = formatForResultLabelText.format(deleteSpacesAndConvertToDouble(number));
}
/**
* Formatuje otrzymanego Stringa bez dodawania spacji
*
* Używa w tym celu klasy DecimalFormat
*/
private String formatWithoutSpacing(String number) {
return resultLabelText = formatForOperationLabelText.format(deleteSpacesAndConvertToDouble(number));
}
/**
* Zwraca zawartość zmiennej operationLabelText
*/
public String getOperationLabelText() {
return operationLabelText;
}
/**
* Zwraca zawartość zmiennej resultLabelText
*/
public String getResultLabelText() {
return resultLabelText;
}
/**
* Zmienia na chwilę kolor tła przesłanego przycisku
*/
public void highlightButton(JButton button, Color color) {
Color selectButtonColor = new Color(70,70,70);
button.setBackground(selectButtonColor);
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
button.setBackground(color);
}
}
| // zmienna do przechowywania ciągów znakowych | import java.awt.Color;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import javax.swing.JButton;
public class CalculatorModel {
private String operationLabelText; // zawartość JLabel z zapisem przeprowadzonych operacji
private String resultLabelText; // zawartość JLabel z aktualnie wprowadzoną wartością/wynikiem
private double previousNumber; // poprzednio podana wartość
private double lastNumber; // ostatnio podana wartość
private String lastOperationSign; // znak ostatniej operacji
private String stringBuff; // zmienna do <SUF>
private boolean choseNumber; // wpisano liczbę do resultLabelText
private boolean choseDot; // we wpisanej liczbie użytko przecinka
private boolean choseDyadicOperation; // wybrano jedną z operacji dwuargumentowych
private boolean chosePowOrSqlt; // wybrano operację potęgowania lub pierwiastkowania
private boolean chosePercent; // wybrano oprarację liczenia procentu
private boolean choseFraction; // wybrano operację liczenia ułamka z podanej liczby
private boolean choseEqualSign; // wybrano operację wyświetlenia wyniku
private boolean dividedByZero; // doszło do dzielenia przez 0
private DecimalFormat formatForResultLabelText; // do usunięcia powtarzających się zer z przodu i końca oraz dodania odstępów
private DecimalFormat formatForOperationLabelText; // do usunięcia powtarzających się zer z przodu i z końca
private final int MAX_NUMBERS = 13; // maksymalna liczba cyfr jakie może mieć wpisywana liczba
/**
* Ustawia zmienne
*/
public CalculatorModel() {
previousNumber = 0;
lastNumber = 0;
operationLabelText = "";
resultLabelText = "0";
lastOperationSign = "";
choseNumber = false;
choseDot = false;
choseDyadicOperation = false;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
choseEqualSign = false;
dividedByZero = false;
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setDecimalSeparator('.');
symbols.setGroupingSeparator(' ');
formatForResultLabelText = new DecimalFormat();
formatForResultLabelText.setDecimalFormatSymbols(symbols);
formatForResultLabelText.setGroupingUsed(true);
formatForResultLabelText.setMaximumIntegerDigits(MAX_NUMBERS);
formatForResultLabelText.setMaximumFractionDigits(MAX_NUMBERS);
formatForOperationLabelText = new DecimalFormat();
formatForOperationLabelText.setDecimalFormatSymbols(symbols);
formatForOperationLabelText.setGroupingUsed(false);
formatForOperationLabelText.setMaximumIntegerDigits(MAX_NUMBERS);
formatForOperationLabelText.setMaximumFractionDigits(MAX_NUMBERS);
}
/**
* Obsługuje zdarzenie wywołane wyborem dowolnej z cyfr lub przecinka
*
* Zmienia wartość resultLabelText w przypadku podania cyfry lub przecinka. Może również wyczyścić
* operationLabelText w przypadku gdy użyto equalsButton.
*
* Metoda posiada zabezpieczenia przed sytuacjami takimi jak gdy nastąpiło dzielenie przez 0, użycie przycisku
* equalsButton, podanie pierwszej cyfry oraz podanie za dużej ilości cyfr.
*
* Następnie w zależności czy wybrano dowolną z cyfr czy przecinek wykonywane są instrukcję modyfikujące
* resultLabelText.
*/
public void handleNumbers(String number) {
// zabezpieczenia przed różnymi sytuacjami
if (!number.equals(".") && dividedByZero) { // dzielenie przez 0 i wybrano cyfrę
handleClear();
dividedByZero = false;
}
else if (number.equals(".") && dividedByZero) { // dzielenie przez 0 i wybrano przecinek
return;
}
if (!choseNumber && !choseDot && !choseDyadicOperation && !choseEqualSign) { // wybrano pierwszą cyfrę lub przecinek []||[2+]||[2-3+]||[2=]
resultLabelText = "0";
}
else if (!choseNumber && !choseDot) { // użyto equalsButton i wybrano pierwszą cyfrę lub przecinek [2+3=]||[2+3-4=]
resultLabelText = "0";
operationLabelText = "";
}
else if (resultLabelText.length() > MAX_NUMBERS) { // blokada przed wpisaniem bardzo dużej liczby
return;
}
// modyfikacja resultLabelText i flag
if (!number.equals(".")) { // cyfra
resultLabelText = resultLabelText + number;
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = true;
}
else if (!choseDot) { // przecinek (wybrany po raz pierwszy)
resultLabelText = resultLabelText + number;
choseDot = true;
}
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji dwuargumentowej
*
* Zapisuje podaną wartość wraz z wybranym znakiem operacji w operationLabelText. W przypadku wybrania drugiej i
* każdej kolejnej operacji bez wybrania equalsButton zapisuje wynik w resultLabelText.
*
* Metoda posiada zabezpieczenia przed sytuacjami takimi jak gdy nastąpiło dzielenie przez 0, wybór znaku operacji
* kilka razy pod rząd, użycie przycisku equalsButton i nie podanie nowej wartości przed wyborem znaku. użycie
* nie typowej operacji lub zwykłej.
*
* Następnie w zależności czy wybrano operację jednoargumentową czy dwuargumentową modyfikowane jest
* operationLabelText. Ponadto, jeśli wybrana operacja jest drugą lub kolejną wybraną bez wybrania equalsButton
* wyznaczany jest nowy wynik.
*/
public void handleDyadicOperation(String sign) {
lastOperationSign = sign;
// zabezpieczenie przed różnymi sytuacjami
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
if (choseDyadicOperation && !choseNumber && !choseEqualSign && !chosePowOrSqlt) { // wybrano kolejny znak pod rząd [2+][2+3-]
swapSignNumber(lastOperationSign); // nadpisuje poprzedni znak nowym
return; // nie trzeba ustawiać flag, bo zostały już ustawione dla poprzedniego znaku
}
if (choseEqualSign && !choseNumber) { // użyto equalsButton i nie podano liczby [=]||[2=]||[2+3=]
operationLabelText = "";
}
// modyfikacja operationLabelText
if (chosePowOrSqlt || chosePercent || choseFraction) { // wybrano operację jednoargumentową [sqrt(2)][2+sqrt(3)]
operationLabelText = operationLabelText + " " + lastOperationSign + " ";
}
else { // wybrano operację dwuargumentową
operationLabelText = operationLabelText + formatWithoutSpacing(resultLabelText) + " " + lastOperationSign + " ";
}
// modyfikacja resultLabelText
if (choseDyadicOperation && (choseNumber || chosePowOrSqlt || chosePercent || choseFraction) && !choseEqualSign) { // wybrano operację dwuargumentową kolejny raz bez wyboru = [2+3]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
executeDyadicOperation(); // wyznacza nowy resultLabelText
}
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText); // nowa wartość
previousNumber = deleteSpacesAndConvertToDouble(resultLabelText);
choseNumber = false;
choseDot = false;
choseDyadicOperation = true;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
choseEqualSign = false;
}
/**
* Wykonuje operację dwuargumentową na podstawie ostatnio użytego znaku
*
* Modyfikuję wartość resultLabelText przy użyciu zmiennych previousNumber i lastNumber.
*/
private void executeDyadicOperation() {
switch (lastOperationSign) {
case "+":
resultLabelText = convertToString(previousNumber + lastNumber);
break;
case "-":
resultLabelText = convertToString(previousNumber - lastNumber);
break;
case "×":
resultLabelText = convertToString(previousNumber * lastNumber);
break;
case "÷":
if (lastNumber != 0) { // zabezpieczenie przed dzieleniem przez 0
resultLabelText = convertToString(previousNumber / lastNumber);
}
else {
resultLabelText = "Cannot divide by zero";
dividedByZero = true;
}
break;
default:
System.out.println("Nieznana operacja!");
}
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji potęgowania lub pierwiastkowania
*
* Modyfikuję operationLabelText w różny sposób w zależności od tego czy operacja była wywołana pierwszy czy kolejny
* raz pod rząd.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handlePowerAndSqrt(String sign) {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
// modyfikacja operationLabelText
if (!chosePowOrSqlt) { // pierwszy pod rząd wybór tej operacji
stringBuff = sign + "(" + formatWithoutSpacing(resultLabelText) + ")";
operationLabelText = operationLabelText + stringBuff;
}
else { // kolejny
String reversedBuff = new StringBuilder(stringBuff).reverse().toString();
reversedBuff = reversedBuff.replace(")", "\\)");
reversedBuff = reversedBuff.replace("(", "\\(");
stringBuff = sign + "(" + stringBuff + ")";
operationLabelText = new StringBuilder(operationLabelText).reverse().toString().replaceFirst(reversedBuff, ")" + reversedBuff + "(" + new StringBuilder(sign).reverse().toString());
operationLabelText = new StringBuilder(operationLabelText).reverse().toString();
}
// modyfikacja resultLabelText
executeUnaryOperation(sign);
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
chosePowOrSqlt = true;
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji wyznaczania procentu
*
* Modyfikuję operationLabelText w różny sposób w zależności od tego czy operacja była wywołana pierwszy czy kolejny
* raz pod rząd.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handlePercent() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
// modyfikacja operationLabelText i resultLabelText
if (!chosePercent) { // pierwszy pod rząd wybór tej operacji
executeUnaryOperation("%");
operationLabelText = operationLabelText + formatWithoutSpacing(resultLabelText);
}
else { // kolejny
String oldResult = formatWithoutSpacing(resultLabelText);
executeUnaryOperation("%");
String reversedOldResult = new StringBuilder(oldResult).reverse().toString();
operationLabelText = new StringBuilder(operationLabelText).reverse().toString().replaceFirst(reversedOldResult, new StringBuilder(resultLabelText).reverse().toString());
operationLabelText = new StringBuilder(operationLabelText).reverse().toString();
}
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
chosePercent = true;
}
/**
* Obsługuje zdarzenie wywołane wyborem operacji wyznaczania ułamka
*
* Modyfikuję operationLabelText w różny sposób w zależności od tego czy operacja była wywołana pierwszy czy kolejny
* raz pod rząd.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleFraction() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
// modyfikacja operationLabelText
if (!choseFraction) { // pierwszy pod rząd wybór tej operacji
stringBuff = "1/( " + formatWithoutSpacing(resultLabelText) + " )";
operationLabelText = operationLabelText + stringBuff;
}
else { // kolejny
String reversedBuff = new StringBuilder(stringBuff).reverse().toString();
reversedBuff = reversedBuff.replace(")", "\\)");
reversedBuff = reversedBuff.replace("(", "\\(");
stringBuff = "1/" + "( " + stringBuff + " )";
operationLabelText = new StringBuilder(operationLabelText).reverse().toString().replaceFirst(reversedBuff, ") " + reversedBuff + " (" + new StringBuilder("1/").reverse().toString());
operationLabelText = new StringBuilder(operationLabelText).reverse().toString();
}
// modyfikacja resultLabelText
executeUnaryOperation("1/");
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
choseFraction = true;
}
/**
* Wykonuje operację jednoargumentową na podstawie otrzymanego znaku
*
* Modyfikuję wartość resultLabelText przy użyciu odpowiedniego działania na resultLabelText.
*/
private void executeUnaryOperation(String sign) {
switch(sign) {
case "sqrt":
resultLabelText = convertToString(convertToDouble(resultLabelText) * convertToDouble(resultLabelText));
break;
case "√":
resultLabelText = convertToString(Math.sqrt(convertToDouble(resultLabelText)));
break;
case "1/":
if (deleteSpacesAndConvertToDouble(resultLabelText) != 0) { // zabezpieczenie przed dzieleniem przez 0
resultLabelText = convertToString(1 / convertToDouble(resultLabelText));
}
else {
resultLabelText = "Cannot divide by zero";
dividedByZero = true;
}
break;
case "%":
resultLabelText = convertToString(convertToDouble(resultLabelText) / 100 * previousNumber);
break;
default:
System.out.println("Nieznana operacja!");
}
}
/**
* Obsługuje zdarzenie wywołane wyborem znaku =
*
* Modyfikuje operationLabelText oraz wyznacza nową wartość resultLabelText przy użyciu wartości zmiennych
* previousNumber i lastNumber.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*
* Następnie podejmowane są kroki w przypadku gdy metoda została wywołana bez wyboru operacji dwuargumentowej.
* Polegają one na modyfikacji operationLabelText i zakończeniu wykonywania metody ponieważ resultLabelText nie
* może być w takiej sytuacji modyfikowany. W przypadku gdy metoda została wywołana z wybraną operacją
* dwuargumentową modyfikowany jest operationLabelText, wykonywana jest wybrana operacja oraz wyświetlana jest
* nowa wartość resultLabelText.
*/
public void handleEqualSign() {
// zabezpieczenie przed różnymi sytuacjami
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
handleClear();
return;
}
// modyfikacja operationLabelText przy braku wyboru operacji dwuargumentowej
if (!choseDyadicOperation && !chosePowOrSqlt && !chosePercent && !choseFraction) { // nie wybrano znaku i operacji jednoargumentowej []||[=]||[2]||[2=]
operationLabelText = formatWithoutSpacing(resultLabelText) + " = ";
choseNumber = false;
choseDot = false;
choseEqualSign = true;
return;
}
if (!choseDyadicOperation) { // nie wybrano znaku i wybrano operację jednoargumentową
operationLabelText = operationLabelText + " = ";
choseNumber = false;
choseDot = false;
choseEqualSign = true;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
return;
}
// modyfikacja operationLabelText po wyborze operacji dwuargumentowej
// choseOperationSign == True zawsze w tym miejscu
if (choseEqualSign) { // wybrano znak i = kolejny raz pod rząd [2+=]||[2+3=]||[2+3==]
previousNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = formatWithoutSpacing(resultLabelText) + " " + lastOperationSign + " " + formatWithoutSpacing(convertToString(lastNumber)) + " = ";
}
else if (!choseNumber && !chosePowOrSqlt && !chosePercent && !choseFraction) { // wybrano znak i nie wybrano drugiej liczby [+]||[2+]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = operationLabelText + formatWithoutSpacing(resultLabelText) + " = ";
}
else if (chosePowOrSqlt || chosePercent || choseFraction) { // wybrano znak i operację jednoargumentową [2+sqrt(3)]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = operationLabelText + " = ";
}
else { // wybrano znak i cyfre [2+3]
lastNumber = deleteSpacesAndConvertToDouble(resultLabelText);
operationLabelText = operationLabelText + formatWithoutSpacing(convertToString(lastNumber)) + " = ";
}
// modyfikacja resultLabelText
executeDyadicOperation();
if (!dividedByZero)
resultLabelText = formatWithSpacing(resultLabelText);
choseNumber = false;
choseDot = false;
choseEqualSign = true;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
}
/**
* Usuwa ostatni znak z resultLabelText
*
* Posiada trzy możliwe przebiegi w zależności czy ostatni znak to przecinek, cyfra oraz ostatnia cyfra.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleBackspace() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
handleClear();
return;
}
if (resultLabelText.length() == 1) { // ostatnia cyfra
resultLabelText = "0";
}
else if (!resultLabelText.endsWith(".")) { // zwykła cyfra
resultLabelText = resultLabelText.substring(0, resultLabelText.length() - 1);
}
else { // przecinek
resultLabelText = resultLabelText.substring(0, resultLabelText.length() - 1);
choseDot = false;
}
}
/**
* Usuwa zawartość resultLabelText
*
* W przypadku użycia znaku "=" działa tak samo jak clear().
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleClearEntry() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
handleClear();
return;
}
if (!choseEqualSign) {
resultLabelText = "0";
choseNumber = false;
choseDot = false;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
}
else {
handleClear();
}
}
/**
* Usuwa wszystkie wprowadzone dane i przywraca je do wartości początkowych
*/
public void handleClear() {
previousNumber = 0;
lastNumber = 0;
operationLabelText = "";
resultLabelText = "0";
lastOperationSign = "";
choseNumber = false;
choseDot = false;
choseDyadicOperation = false;
chosePowOrSqlt = false;
chosePercent = false;
choseFraction = false;
choseEqualSign = false;
}
/**
* Obsługuje zdarzenie wywołane wyborem przycisku zmiany znaku
*
* Zmienia znak liczby przechowywanej w resultLabel na przeciwny mnożąc jej wartość przez -1.
*
* Metoda posiada zabezpieczenie przed sytuacją gdy nastąpiło dzielenie przez 0.
*/
public void handleSignNegation() {
if (dividedByZero) { // zablokowanie operacji po dzieleniu przez zero
return;
}
if (!resultLabelText.equals("0"))
resultLabelText = formatWithSpacing(convertToString(-1 * deleteSpacesAndConvertToDouble(resultLabelText)));
}
/**
* Usuwa ostatni znak z operationLabelText i zamienia go na otrzymany w argumencie
*/
private void swapSignNumber(String sign) {
if (operationLabelText.length() > 0) {
operationLabelText = operationLabelText.substring(0, operationLabelText.length()-2) + sign + " ";
}
}
/**
* Konwertuje otrzymanego doubla do Stringa
*/
private String convertToString(double number) {
return String.valueOf(number);
}
/**
* Konwertuje otrzymanego Stringa do doubla
*/
private double convertToDouble(String number) {
return Double.parseDouble(number);
}
/**
* Usuwa spację z otrzymanego Stringa i konwertuję go do doubla
*/
private double deleteSpacesAndConvertToDouble(String number) {
return Double.parseDouble(number.replace(" ", "")); // " " ma nietypowe kodowanie;
}
/**
* Formatuje otrzymanego Stringa dodając spację co 3 cyfry
*
* Używa w tym celu klasy DecimalFormat
*/
private String formatWithSpacing(String number) {
return resultLabelText = formatForResultLabelText.format(deleteSpacesAndConvertToDouble(number));
}
/**
* Formatuje otrzymanego Stringa bez dodawania spacji
*
* Używa w tym celu klasy DecimalFormat
*/
private String formatWithoutSpacing(String number) {
return resultLabelText = formatForOperationLabelText.format(deleteSpacesAndConvertToDouble(number));
}
/**
* Zwraca zawartość zmiennej operationLabelText
*/
public String getOperationLabelText() {
return operationLabelText;
}
/**
* Zwraca zawartość zmiennej resultLabelText
*/
public String getResultLabelText() {
return resultLabelText;
}
/**
* Zmienia na chwilę kolor tła przesłanego przycisku
*/
public void highlightButton(JButton button, Color color) {
Color selectButtonColor = new Color(70,70,70);
button.setBackground(selectButtonColor);
try {
Thread.sleep(100);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
button.setBackground(color);
}
}
| f | null |
303 | 5010_5 | Przemex13/VATCalculatorWithRegEx | 2,011 | src/MainFrame.java |
/*
Simply application for computing value added tax.
I used regular expressions to make code more readable.
This project is upgraded version of another project (Kalkulator VAT),
And this time I wanted to utilize my new skills acquired during solving
tasks on codewars.com. Enjoy! :)
Przemysław Poskrobko
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MainFrame extends JFrame implements ActionListener, FocusListener{
JButton computeButton, clearButton;
JLabel netValueLabel, vatValueLabel, grossValueLabel;
JTextField netValueTextField, vatValueTextField, grossValueTextField;
public MainFrame(){
super("Calculator 2.0");
this.setLayout(null);
this.getContentPane().setBackground(Color.white);
// adding components
netValueLabel = new JLabel("Net Value",null,SwingConstants.RIGHT);
netValueLabel.setBounds(76,62,75,17);
this.add(netValueLabel);
vatValueLabel = new JLabel("VAT Tax",null,SwingConstants.RIGHT);
vatValueLabel.setBounds(76, 95, 75, 17);
this.add(vatValueLabel);
grossValueLabel = new JLabel("Gross Value",null,SwingConstants.RIGHT);
grossValueLabel.setBounds(76, 127, 75, 17);
this.add(grossValueLabel);
netValueTextField = new JTextField();
netValueTextField.setBounds(160, 58, 150, 25);
this.add(netValueTextField);
vatValueTextField = new JTextField();
vatValueTextField.setBounds(160, 91, 150, 25);
this.add(vatValueTextField);
grossValueTextField = new JTextField();
grossValueTextField.setBounds(160, 123, 150, 25);
this.add(grossValueTextField);
computeButton = new JButton("Compute!");
computeButton.setBounds(116, 210, 90, 25);
this.add(computeButton);
clearButton = new JButton("Clear");
clearButton.setBounds(215, 210, 70, 25);
this.add(clearButton);
// add action listeners
computeButton.addActionListener(this);
clearButton.addActionListener(this);
// add lost listener
netValueTextField.addFocusListener(this);
vatValueTextField.addFocusListener(this);
grossValueTextField.addFocusListener(this);
this.setLayout(new BorderLayout());
this.setSize(400, 310);
this.setLocation(300, 310);
this.setVisible(true);
}
private static void checkIfNumbersWereTyped(JTextField textField){
Pattern appropriateFormatwithDecimal = Pattern.compile("^\\d+[.]?\\d*$");
Matcher matcher = appropriateFormatwithDecimal.matcher(textField.getText());
if (!matcher.matches() && !textField.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Napisz, proszę poprawny format liczby, pamiętaj proszę by zamiast przecinków używać kropek");
textField.requestFocus();
textField.setSelectionStart(0);
textField.setSelectionEnd(textField.getText().length());
}
}
public boolean checkIfOneTextFieldIsEmpty(){
int textFieldsInUse = 0;
if (!netValueTextField.getText().isEmpty()) textFieldsInUse ++ ;
if (!vatValueTextField.getText().isEmpty()) textFieldsInUse ++;
if (!grossValueTextField.getText().isEmpty()) textFieldsInUse ++;
return (textFieldsInUse == 2) ? true : false;
}
public static void organizeAmount (JTextField textField){
// pattern który będzie obsługiwał 3 cyfry i więcj po przecinku
Pattern pattern = Pattern.compile("^\\d+[.]?\\d{3,}");
Matcher matcher = pattern.matcher(textField.getText());
// pattern który będzie ossługiwał 1 cyfrę po przecinku
Pattern pattern1 = Pattern.compile("^\\d+[.]\\d$");
Matcher matcher1 = pattern1.matcher(textField.getText());
// pattern który będzie obsługiwał liczbę zakończoną przecinkiem lub kropką
Pattern pattern2 = Pattern.compile("^\\d+[.]$");
Matcher matcher2 = pattern2.matcher(textField.getText());
// pattern który obsłuży liczbę int
Pattern pattern3 = Pattern.compile("^\\d+$");
Matcher matcher3 = pattern3.matcher(textField.getText());
if (matcher.matches()){
double number;
number = Double.parseDouble(textField.getText());
double numberRounded;
numberRounded = (int) Math.round((number * 100));
textField.setText(String.valueOf(numberRounded/100));
} else if (matcher1.matches()) {textField.setText(textField.getText() + "0");}
else if (matcher2.matches()) {textField.setText(textField.getText() + "00");}
else if (matcher3.matches()) {textField.setText(textField.getText() + ".00");
} else {};
}
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource() == computeButton){
if(checkIfOneTextFieldIsEmpty()){
double netValue, vatValue, grossValue;
if(netValueTextField.getText().isEmpty()){
vatValue = Double.parseDouble(vatValueTextField.getText());
grossValue = Double.parseDouble(grossValueTextField.getText());
netValue = 100 * grossValue / (100 + vatValue);
netValueTextField.setText(String.valueOf(netValue));
organizeAmount(netValueTextField);
}
else if (vatValueTextField.getText().isEmpty()) {
netValue = Double.parseDouble(netValueTextField.getText());
grossValue = Double.parseDouble(grossValueTextField.getText());
vatValue = (grossValue / netValue - 1) * 100;
vatValueTextField.setText(String.valueOf(vatValue));
organizeAmount(vatValueTextField);
}
else{
// gross value textField is empty
netValue = Double.parseDouble(netValueTextField.getText());
vatValue = Double.parseDouble(vatValueTextField.getText());
grossValue = netValue + (netValue * vatValue) / 100;
grossValueTextField.setText(String.valueOf(grossValue));
organizeAmount(grossValueTextField);
}
}
else{
JOptionPane.showMessageDialog(null, "Jedno pole musi pozostać wolne");
}
}
else{
netValueTextField.setText("");
vatValueTextField.setText("");
grossValueTextField.setText("");
}
}
public static void main(String[] args) {
new MainFrame().setVisible(true);
}
@Override
public void focusGained(FocusEvent e) {
}
@Override
public void focusLost(FocusEvent e) {
checkIfNumbersWereTyped(((JTextField)e.getSource()));
organizeAmount(((JTextField) e.getSource()));
}
}
| // pattern który będzie obsługiwał liczbę zakończoną przecinkiem lub kropką |
/*
Simply application for computing value added tax.
I used regular expressions to make code more readable.
This project is upgraded version of another project (Kalkulator VAT),
And this time I wanted to utilize my new skills acquired during solving
tasks on codewars.com. Enjoy! :)
Przemysław Poskrobko
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MainFrame extends JFrame implements ActionListener, FocusListener{
JButton computeButton, clearButton;
JLabel netValueLabel, vatValueLabel, grossValueLabel;
JTextField netValueTextField, vatValueTextField, grossValueTextField;
public MainFrame(){
super("Calculator 2.0");
this.setLayout(null);
this.getContentPane().setBackground(Color.white);
// adding components
netValueLabel = new JLabel("Net Value",null,SwingConstants.RIGHT);
netValueLabel.setBounds(76,62,75,17);
this.add(netValueLabel);
vatValueLabel = new JLabel("VAT Tax",null,SwingConstants.RIGHT);
vatValueLabel.setBounds(76, 95, 75, 17);
this.add(vatValueLabel);
grossValueLabel = new JLabel("Gross Value",null,SwingConstants.RIGHT);
grossValueLabel.setBounds(76, 127, 75, 17);
this.add(grossValueLabel);
netValueTextField = new JTextField();
netValueTextField.setBounds(160, 58, 150, 25);
this.add(netValueTextField);
vatValueTextField = new JTextField();
vatValueTextField.setBounds(160, 91, 150, 25);
this.add(vatValueTextField);
grossValueTextField = new JTextField();
grossValueTextField.setBounds(160, 123, 150, 25);
this.add(grossValueTextField);
computeButton = new JButton("Compute!");
computeButton.setBounds(116, 210, 90, 25);
this.add(computeButton);
clearButton = new JButton("Clear");
clearButton.setBounds(215, 210, 70, 25);
this.add(clearButton);
// add action listeners
computeButton.addActionListener(this);
clearButton.addActionListener(this);
// add lost listener
netValueTextField.addFocusListener(this);
vatValueTextField.addFocusListener(this);
grossValueTextField.addFocusListener(this);
this.setLayout(new BorderLayout());
this.setSize(400, 310);
this.setLocation(300, 310);
this.setVisible(true);
}
private static void checkIfNumbersWereTyped(JTextField textField){
Pattern appropriateFormatwithDecimal = Pattern.compile("^\\d+[.]?\\d*$");
Matcher matcher = appropriateFormatwithDecimal.matcher(textField.getText());
if (!matcher.matches() && !textField.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Napisz, proszę poprawny format liczby, pamiętaj proszę by zamiast przecinków używać kropek");
textField.requestFocus();
textField.setSelectionStart(0);
textField.setSelectionEnd(textField.getText().length());
}
}
public boolean checkIfOneTextFieldIsEmpty(){
int textFieldsInUse = 0;
if (!netValueTextField.getText().isEmpty()) textFieldsInUse ++ ;
if (!vatValueTextField.getText().isEmpty()) textFieldsInUse ++;
if (!grossValueTextField.getText().isEmpty()) textFieldsInUse ++;
return (textFieldsInUse == 2) ? true : false;
}
public static void organizeAmount (JTextField textField){
// pattern który będzie obsługiwał 3 cyfry i więcj po przecinku
Pattern pattern = Pattern.compile("^\\d+[.]?\\d{3,}");
Matcher matcher = pattern.matcher(textField.getText());
// pattern który będzie ossługiwał 1 cyfrę po przecinku
Pattern pattern1 = Pattern.compile("^\\d+[.]\\d$");
Matcher matcher1 = pattern1.matcher(textField.getText());
// pattern który <SUF>
Pattern pattern2 = Pattern.compile("^\\d+[.]$");
Matcher matcher2 = pattern2.matcher(textField.getText());
// pattern który obsłuży liczbę int
Pattern pattern3 = Pattern.compile("^\\d+$");
Matcher matcher3 = pattern3.matcher(textField.getText());
if (matcher.matches()){
double number;
number = Double.parseDouble(textField.getText());
double numberRounded;
numberRounded = (int) Math.round((number * 100));
textField.setText(String.valueOf(numberRounded/100));
} else if (matcher1.matches()) {textField.setText(textField.getText() + "0");}
else if (matcher2.matches()) {textField.setText(textField.getText() + "00");}
else if (matcher3.matches()) {textField.setText(textField.getText() + ".00");
} else {};
}
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource() == computeButton){
if(checkIfOneTextFieldIsEmpty()){
double netValue, vatValue, grossValue;
if(netValueTextField.getText().isEmpty()){
vatValue = Double.parseDouble(vatValueTextField.getText());
grossValue = Double.parseDouble(grossValueTextField.getText());
netValue = 100 * grossValue / (100 + vatValue);
netValueTextField.setText(String.valueOf(netValue));
organizeAmount(netValueTextField);
}
else if (vatValueTextField.getText().isEmpty()) {
netValue = Double.parseDouble(netValueTextField.getText());
grossValue = Double.parseDouble(grossValueTextField.getText());
vatValue = (grossValue / netValue - 1) * 100;
vatValueTextField.setText(String.valueOf(vatValue));
organizeAmount(vatValueTextField);
}
else{
// gross value textField is empty
netValue = Double.parseDouble(netValueTextField.getText());
vatValue = Double.parseDouble(vatValueTextField.getText());
grossValue = netValue + (netValue * vatValue) / 100;
grossValueTextField.setText(String.valueOf(grossValue));
organizeAmount(grossValueTextField);
}
}
else{
JOptionPane.showMessageDialog(null, "Jedno pole musi pozostać wolne");
}
}
else{
netValueTextField.setText("");
vatValueTextField.setText("");
grossValueTextField.setText("");
}
}
public static void main(String[] args) {
new MainFrame().setVisible(true);
}
@Override
public void focusGained(FocusEvent e) {
}
@Override
public void focusLost(FocusEvent e) {
checkIfNumbersWereTyped(((JTextField)e.getSource()));
organizeAmount(((JTextField) e.getSource()));
}
}
| f | null |
304 | 3997_0 | Przems0n711/JDK | 270 | lessons/3_simple_classes/StudentsTest.java | import edu.technischools.java.*; // importy pozwalają na używanie klas z innych pakietów
public class StudentsTest {
public static void main(String[] args) {
// Person p = new Person() //nie możemy użyć tej klasy, ponieważ ma ona domyślny
// modyfikator dostępu a jesteśmy w innym pakiecie!
Student s = new Student("Jan", "Kowalski"); // ale klasa student ma już dostęp publiczny, więc nic nie stoi na
// przeszkodzie żeby ją stworzyć
System.out.println(s.getFirstName() + " " + s.getLastName()); // ponieważ klasa Student rozszerza klasę Person,
// wszystkie widoczne metody z klasy Person są
// dostępne w klasie Student
s.setSchool("TechniSchools");
System.out.println(s.getSchool());
}
}
| // importy pozwalają na używanie klas z innych pakietów | import edu.technischools.java.*; // importy pozwalają <SUF>
public class StudentsTest {
public static void main(String[] args) {
// Person p = new Person() //nie możemy użyć tej klasy, ponieważ ma ona domyślny
// modyfikator dostępu a jesteśmy w innym pakiecie!
Student s = new Student("Jan", "Kowalski"); // ale klasa student ma już dostęp publiczny, więc nic nie stoi na
// przeszkodzie żeby ją stworzyć
System.out.println(s.getFirstName() + " " + s.getLastName()); // ponieważ klasa Student rozszerza klasę Person,
// wszystkie widoczne metody z klasy Person są
// dostępne w klasie Student
s.setSchool("TechniSchools");
System.out.println(s.getSchool());
}
}
| f | null |
306 | 9941_7 | RadandMoc/Projekt_Java | 823 | Projekt/Message.java | package Projekt;
import java.io.Serializable;
import java.util.Date;
/**
* Klasa Message reprezentuje pojedynczą wiadomość w systemie. Wiadomość może być wiadomością wychodzącą lub przychodzącą
* w zależności od tego kto otrzyma.
* Wiadomość zawiera treść, datę wysłania i klucz, który jest potrzebny do szyfrowania i deszyfrowania treści wiadomości.
*/
public class Message implements Serializable {
private static final long serialVersionUID = 1L;
private short[] content;
private Date date;
private boolean isOutgoing;
private String key;
/**
* Konstruktor Message tworzy nową wiadomość.
* @param content Treść wiadomości jako tablica short.
* @param date Data wysłania wiadomości.
* @param key Klucz używany do szyfrowania i deszyfrowania wiadomości.
*/
public Message(short[] content, Date date, String key) {
this.content = content;
this.date = date;
this.isOutgoing = true;
this.key = key;
}
/**
* Zwraca datę wysłania wiadomości.
* @return Data wysłania wiadomości.
*/
public Object getDate() {
return this.date;
}
/**
* Zwraca reprezentację string wiadomości, w tym informacje, czy jest to wiadomość wychodząca lub przychodząca,
* i datę wysłania.
* @return Reprezentacja string wiadomości.
*/
public String toString() {
return this.isOutgoing ? "Wiadomość wychodząca z dnia " + this.date.toString() : "Wiadomość przychodząca z dnia " + this.date.toString();
}
/**
* Sprawdza, czy wiadomość jest wiadomością wychodzącą.
* @return Prawda, jeśli wiadomość jest wychodząca, fałsz w przeciwnym razie.
*/
public boolean getIsOutcoming() {
return this.isOutgoing;
}
/**
* Ustawia, czy wiadomość jest wiadomością wychodzącą.
* @param b Prawda, jeśli wiadomość jest wychodząca, fałsz w przeciwnym razie.
*/
public void setIsOutgoing(boolean b) {
this.isOutgoing = b;
}
/**
* Zwraca treść wiadomości.
* @return Treść wiadomości jako tablica short.
*/
public short[] getContent() {
return this.content;
}
/**
* Zwraca klucz wiadomości.
* @return Klucz wiadomości jako string.
*/
public String getKey() {
return this.key;
}
}
| /**
* Zwraca klucz wiadomości.
* @return Klucz wiadomości jako string.
*/ | package Projekt;
import java.io.Serializable;
import java.util.Date;
/**
* Klasa Message reprezentuje pojedynczą wiadomość w systemie. Wiadomość może być wiadomością wychodzącą lub przychodzącą
* w zależności od tego kto otrzyma.
* Wiadomość zawiera treść, datę wysłania i klucz, który jest potrzebny do szyfrowania i deszyfrowania treści wiadomości.
*/
public class Message implements Serializable {
private static final long serialVersionUID = 1L;
private short[] content;
private Date date;
private boolean isOutgoing;
private String key;
/**
* Konstruktor Message tworzy nową wiadomość.
* @param content Treść wiadomości jako tablica short.
* @param date Data wysłania wiadomości.
* @param key Klucz używany do szyfrowania i deszyfrowania wiadomości.
*/
public Message(short[] content, Date date, String key) {
this.content = content;
this.date = date;
this.isOutgoing = true;
this.key = key;
}
/**
* Zwraca datę wysłania wiadomości.
* @return Data wysłania wiadomości.
*/
public Object getDate() {
return this.date;
}
/**
* Zwraca reprezentację string wiadomości, w tym informacje, czy jest to wiadomość wychodząca lub przychodząca,
* i datę wysłania.
* @return Reprezentacja string wiadomości.
*/
public String toString() {
return this.isOutgoing ? "Wiadomość wychodząca z dnia " + this.date.toString() : "Wiadomość przychodząca z dnia " + this.date.toString();
}
/**
* Sprawdza, czy wiadomość jest wiadomością wychodzącą.
* @return Prawda, jeśli wiadomość jest wychodząca, fałsz w przeciwnym razie.
*/
public boolean getIsOutcoming() {
return this.isOutgoing;
}
/**
* Ustawia, czy wiadomość jest wiadomością wychodzącą.
* @param b Prawda, jeśli wiadomość jest wychodząca, fałsz w przeciwnym razie.
*/
public void setIsOutgoing(boolean b) {
this.isOutgoing = b;
}
/**
* Zwraca treść wiadomości.
* @return Treść wiadomości jako tablica short.
*/
public short[] getContent() {
return this.content;
}
/**
* Zwraca klucz wiadomości. <SUF>*/
public String getKey() {
return this.key;
}
}
| f | null |
307 | 8163_8 | Radoslaw98/JelonBCONE | 741 | src/main/java/classes/OuterClass.java | package classes;
import java.util.ArrayList;
import java.util.List;
public class OuterClass {
private String message = "Outer class";
private static String staticMessage = "Outer class static";
public static int sum(int x, int y) {
return x + y;
}
public void printMessage() {
InnerClass innerClass = new InnerClass();
System.out.println(innerClass.message);
}
//1.Zwykła klasa wewnętrzna
public class InnerClass {
private String message = "Inner class";
public void printMessage() {
System.out.println(this.message);
}
}
//2.lokalna klasa wewnętrzna - klasa zdefiniowana w ciele metody
public void sayHello() {
//metoda ta staje się domyślnie finalna
String helloMessage = "Hello local class";
class LocalClass {
public void sayLocalHello() {
System.out.println("Outer class message: " + message);
System.out.println("Local class message: " + helloMessage);
}
}
LocalClass localClass = new LocalClass();
localClass.sayLocalHello();
}
// Klasa anonimowa - niemożliwe jest zainicjalizowanie interfejsu. Dlatego tworzymy na szybko potrzebną klasą umieszczając jej ciało między nawiasami klamrowymi
//W klasach anonimowych można korzystać ze zmiennych klasy zewnętrznej o raz finalych zmiennych metody, w której zaimplentowno klasę anonimową.
// Klasa anonimowa musi implementować wszystkie metody interfejsu. Może definiować też własne pola i metody
//Od Javy 8 takie proste implementacje w postaci klas anonimowych straciły znaczenie, ponieważ mogą być zastępowane wyrażeniami lambda.
Printer printer = new Printer() {
@Override
public void print(String message) {
System.out.println(message);
}
};
public void test() {
String text = "klasa anonimowa";
printer.print(message + " " + text);
}
//static - słowo kluczowe (keywords), używając static mówimy, że dana kalsa, metoda, pole nie należy do instancji klasy(czyli obiektu) tylko do klasy.
//Static nested class - mają one dostep tylko do statycznych pól klasy zewnętrznej
//Builder - przykład użycia
static class StaticInnerClass {
void printMessage() {
System.out.println("Static class" + staticMessage);
}
}
}
| //Static nested class - mają one dostep tylko do statycznych pól klasy zewnętrznej | package classes;
import java.util.ArrayList;
import java.util.List;
public class OuterClass {
private String message = "Outer class";
private static String staticMessage = "Outer class static";
public static int sum(int x, int y) {
return x + y;
}
public void printMessage() {
InnerClass innerClass = new InnerClass();
System.out.println(innerClass.message);
}
//1.Zwykła klasa wewnętrzna
public class InnerClass {
private String message = "Inner class";
public void printMessage() {
System.out.println(this.message);
}
}
//2.lokalna klasa wewnętrzna - klasa zdefiniowana w ciele metody
public void sayHello() {
//metoda ta staje się domyślnie finalna
String helloMessage = "Hello local class";
class LocalClass {
public void sayLocalHello() {
System.out.println("Outer class message: " + message);
System.out.println("Local class message: " + helloMessage);
}
}
LocalClass localClass = new LocalClass();
localClass.sayLocalHello();
}
// Klasa anonimowa - niemożliwe jest zainicjalizowanie interfejsu. Dlatego tworzymy na szybko potrzebną klasą umieszczając jej ciało między nawiasami klamrowymi
//W klasach anonimowych można korzystać ze zmiennych klasy zewnętrznej o raz finalych zmiennych metody, w której zaimplentowno klasę anonimową.
// Klasa anonimowa musi implementować wszystkie metody interfejsu. Może definiować też własne pola i metody
//Od Javy 8 takie proste implementacje w postaci klas anonimowych straciły znaczenie, ponieważ mogą być zastępowane wyrażeniami lambda.
Printer printer = new Printer() {
@Override
public void print(String message) {
System.out.println(message);
}
};
public void test() {
String text = "klasa anonimowa";
printer.print(message + " " + text);
}
//static - słowo kluczowe (keywords), używając static mówimy, że dana kalsa, metoda, pole nie należy do instancji klasy(czyli obiektu) tylko do klasy.
//Static nested <SUF>
//Builder - przykład użycia
static class StaticInnerClass {
void printMessage() {
System.out.println("Static class" + staticMessage);
}
}
}
| f | null |
308 | 9867_4 | Raeks0/UwUGra | 1,387 | src/Gra.java | import java.util.Random;
import java.util.Scanner;
public class Gra {
private static final Jednostka Boss = null;
private static Postac gracz = new Postac("Gracz1", 1000, 100);
private static Ekwipunek ekwipunek = new Ekwipunek(); // Dodajemy obiekt klasy Equipment
public static void rozpocznij() {
Scanner scanner = new Scanner(System.in);
boolean kontynuuj = true;
while (kontynuuj) {
System.out.println("Witaj w barze! Wybierz, co chcesz zrobić:");
System.out.println("1. Porozmawiaj z barmanem");
System.out.println("2. Spróbuj szczęścia na maszynie hazardowej");
System.out.println("3. Wyjdź z baru");
System.out.println("4. Wyświetl ekwipunek");
System.out.println("5. Wyjdź z gry");
int wybor = scanner.nextInt();
scanner.nextLine();
switch (wybor) {
case 1:
Barman.RozmowaZBarmanem(gracz);
break;
case 2:
Slotsy.graNaAutomacie(gracz);
break;
case 3:
System.out.println("Wychodzisz z baru. Co chcesz teraz zrobić?");
System.out.println("1. Rozejrzyj się po mieście");
System.out.println("2. Idź do lasu");
System.out.println("3. Idź do sklepu z bronią");
System.out.println("4. Wyświetl ekwipunek ");
System.out.println("5. Zaczynaj żebrać");
int wyborPoWyjsciu = scanner.nextInt();
scanner.nextLine();
switch (wyborPoWyjsciu) {
case 1:
System.out.println("Rozejrzeliście się po mieście.");
break;
case 2:
System.out.println("Poszli do lasu Poszli");
System.out.println("Po ziemi przebiegłą mysza i potem ...");
System.out.println("Spotkaliście GOBLINA Krzysia");
// Tworzenie obiektu Boss
Boss goblinKrzysio = new Boss("Goblin Krzysio", 100, 20, 10, 20);
// Tworzenie obiektu Walka
Walka walkaZGoblinem = new Walka(gracz, goblinKrzysio);
// Rozpoczęcie walki
walkaZGoblinem.rozpocznijWalke();
break;
case 3:
Sklepik.Sklep(gracz, ekwipunek); // tutaj bedzie ze wchodzisz se do sklepu noramlnie i masz ze ziutek mowi elo mam takie bronei na sprzedarz i mozesz se je kupic
break;
case 4:
System.out.println("Ekwipunek gracza:");
ekwipunek.wyswietlEkwipunek(); // Wywołujemy metodę z obiektu klasy Ekwipunek
break;
case 5:
if (losujSzansę(25)) { // Losowanie szansy 25%
gracz.dodajMonety(20); // Dodanie 20 monet
System.out.println("Dostajesz 20 monet!");
} else {
System.out.println("Zaczynasz żebrać, ale nikt wam nic nie dał.");
}
break;
default:
System.out.println("Nieprawidłowy wybór. Wróćmy do baru.");
break;
}
break;
case 4:
System.out.println("Ekwipunek gracza:");
ekwipunek.wyswietlEkwipunek(); // Wywołujemy metodę z obiektu klasy Ekwipunek
break;
case 5:
kontynuuj = false;
break;
default:
System.out.println("Nieprawidłowy wybór.");
}
}
System.out.println("Dziękujemy za grę! Do zobaczenia następnym razem.");
scanner.close();
}
private static boolean losujSzansę(int procent) {
Random random = new Random();
int losowaLiczba = random.nextInt(100); // Losujemy liczbę od 0 do 99
return losowaLiczba < procent; // Zwracamy true, jeśli liczba jest mniejsza od procentu
}
}
| // Wywołujemy metodę z obiektu klasy Ekwipunek | import java.util.Random;
import java.util.Scanner;
public class Gra {
private static final Jednostka Boss = null;
private static Postac gracz = new Postac("Gracz1", 1000, 100);
private static Ekwipunek ekwipunek = new Ekwipunek(); // Dodajemy obiekt klasy Equipment
public static void rozpocznij() {
Scanner scanner = new Scanner(System.in);
boolean kontynuuj = true;
while (kontynuuj) {
System.out.println("Witaj w barze! Wybierz, co chcesz zrobić:");
System.out.println("1. Porozmawiaj z barmanem");
System.out.println("2. Spróbuj szczęścia na maszynie hazardowej");
System.out.println("3. Wyjdź z baru");
System.out.println("4. Wyświetl ekwipunek");
System.out.println("5. Wyjdź z gry");
int wybor = scanner.nextInt();
scanner.nextLine();
switch (wybor) {
case 1:
Barman.RozmowaZBarmanem(gracz);
break;
case 2:
Slotsy.graNaAutomacie(gracz);
break;
case 3:
System.out.println("Wychodzisz z baru. Co chcesz teraz zrobić?");
System.out.println("1. Rozejrzyj się po mieście");
System.out.println("2. Idź do lasu");
System.out.println("3. Idź do sklepu z bronią");
System.out.println("4. Wyświetl ekwipunek ");
System.out.println("5. Zaczynaj żebrać");
int wyborPoWyjsciu = scanner.nextInt();
scanner.nextLine();
switch (wyborPoWyjsciu) {
case 1:
System.out.println("Rozejrzeliście się po mieście.");
break;
case 2:
System.out.println("Poszli do lasu Poszli");
System.out.println("Po ziemi przebiegłą mysza i potem ...");
System.out.println("Spotkaliście GOBLINA Krzysia");
// Tworzenie obiektu Boss
Boss goblinKrzysio = new Boss("Goblin Krzysio", 100, 20, 10, 20);
// Tworzenie obiektu Walka
Walka walkaZGoblinem = new Walka(gracz, goblinKrzysio);
// Rozpoczęcie walki
walkaZGoblinem.rozpocznijWalke();
break;
case 3:
Sklepik.Sklep(gracz, ekwipunek); // tutaj bedzie ze wchodzisz se do sklepu noramlnie i masz ze ziutek mowi elo mam takie bronei na sprzedarz i mozesz se je kupic
break;
case 4:
System.out.println("Ekwipunek gracza:");
ekwipunek.wyswietlEkwipunek(); // Wywołujemy metodę <SUF>
break;
case 5:
if (losujSzansę(25)) { // Losowanie szansy 25%
gracz.dodajMonety(20); // Dodanie 20 monet
System.out.println("Dostajesz 20 monet!");
} else {
System.out.println("Zaczynasz żebrać, ale nikt wam nic nie dał.");
}
break;
default:
System.out.println("Nieprawidłowy wybór. Wróćmy do baru.");
break;
}
break;
case 4:
System.out.println("Ekwipunek gracza:");
ekwipunek.wyswietlEkwipunek(); // Wywołujemy metodę z obiektu klasy Ekwipunek
break;
case 5:
kontynuuj = false;
break;
default:
System.out.println("Nieprawidłowy wybór.");
}
}
System.out.println("Dziękujemy za grę! Do zobaczenia następnym razem.");
scanner.close();
}
private static boolean losujSzansę(int procent) {
Random random = new Random();
int losowaLiczba = random.nextInt(100); // Losujemy liczbę od 0 do 99
return losowaLiczba < procent; // Zwracamy true, jeśli liczba jest mniejsza od procentu
}
}
| f | null |
309 | 5722_21 | RafalDaniliszyn/genetic-algorithm-simulation | 3,730 | src/AlgorytmGenetyczny.java | package pl.rafal;
import java.awt.*;
import java.util.Random;
public class AlgorytmGenetyczny implements Runnable{
Populacja populacja;
Populacja nowaPopulacja;
int generacja;
double najlepszaOcena;
Random random = new Random();
int liczbaPopulacji;
int stopienSelekcji;
int pBmutacji;
int noweKroki; //ilosc dodawanych krokow(genow) co ileś generacji lub po osiagnieciu celu
int kiedyDodacKroki = 10; // zlicza w ktorej kolejnej generacji dodac kroki
int kiedyDodawacKroki = 10; //zmienna do sumowania juz dodanych krokow
int czestotliwoscZakretow; //czym wyzsza tym rzadziej
int ileDodano = 0;
boolean koniecGeneracji = false;
public AlgorytmGenetyczny(int liczbaPopulacji, int dlugoscGenu, int stopienSelekcji, int pBmutacji, int czestotliwoscZakretow, double predkosc) {
this.czestotliwoscZakretow = czestotliwoscZakretow;
this.pBmutacji = pBmutacji;
this.stopienSelekcji = stopienSelekcji;
this.liczbaPopulacji = liczbaPopulacji;
this.noweKroki = dlugoscGenu;
populacja = new Populacja(liczbaPopulacji, dlugoscGenu, predkosc);
nowaPopulacja = new Populacja(liczbaPopulacji, dlugoscGenu, predkosc);
}
//selekcja
public void selekcja(){
for (int i = 0; i < stopienSelekcji; i++) {
double najwyzsza = populacja.najlepszy();
for (int j = 0; j < liczbaPopulacji; j++) {
if (populacja.osobniks[j].ocena == najwyzsza){
for (int k = 0; k < populacja.osobniks[0].gen.length; k++) {
nowaPopulacja.osobniks[i].gen[k] = populacja.osobniks[j].gen[k];
populacja.osobniks[j].ocena = 1000000;
}
break;
}else {
populacja.osobniks[j].color = Color.black;
}
}
}
}
//tworzenie brakujacych osobnikow po selekcji
public void reprodukcja(){
for (int i = stopienSelekcji; i < nowaPopulacja.osobniks.length; i++) {
//losowanie osobnikow do reprodukcji
int wybraniec1 = random.nextInt(liczbaPopulacji);
int wybraniec2 = random.nextInt(liczbaPopulacji);
//losowanie wybranych osobnikow w przypadku gdy poprzednie losowanie wybralo tych samych
while (wybraniec1 == wybraniec2) {
wybraniec1 = random.nextInt(liczbaPopulacji);
wybraniec2 = random.nextInt(liczbaPopulacji);
}
//losowanie miejsca preciecia genu z pominieciem przedzialu
// ktory zostaje zachowany w przypadku dodania nowej czesci genu
int miejscePrzeciecia = random.nextInt(populacja.osobniks[0].gen.length - ileDodano) + ileDodano;
//zamiana pierwszej czesci genu pomijajac czesc genu ktory zostaje zachowany
for (int j = ileDodano; j < miejscePrzeciecia; j++) {
nowaPopulacja.osobniks[i].gen[j] = populacja.osobniks[wybraniec1].gen[j];
nowaPopulacja.osobniks[i].genPredkosci[j] = populacja.osobniks[wybraniec1].genPredkosci[j];
}
//zamiana drugiej czesci genu
for (int j = miejscePrzeciecia; j < populacja.osobniks[0].dlugoscGenu; j++) {
nowaPopulacja.osobniks[i].gen[j] = populacja.osobniks[wybraniec2].gen[j];
nowaPopulacja.osobniks[i].genPredkosci[j] = populacja.osobniks[wybraniec2].genPredkosci[j];
}
//losowa mutacja
mutacja(i, this.pBmutacji);
}
//tworzenie populacji z nowej populacji
for (int i = 0; i < populacja.osobniks.length; i++) {
for (int j = 0; j < populacja.osobniks[0].dlugoscGenu; j++) {
populacja.osobniks[i].gen[j] = nowaPopulacja.osobniks[i].gen[j];
populacja.osobniks[i].genPredkosci[j] = nowaPopulacja.osobniks[i].genPredkosci[j];
}
}
}
void zerujOcene(Populacja populacjaDoWyzerowania){
for (int i = 0; i < populacjaDoWyzerowania.osobniks.length; i++) {
populacjaDoWyzerowania.osobniks[i].ocena = 0;
populacjaDoWyzerowania.osobniks[i].ocenaDoDodania = 0;
}
}
void mutacja(int i, int pBmutacji){
if (random.nextInt(100) < pBmutacji){ //prawdopodobienstwo mutacji
for (int j = ileDodano; j < populacja.osobniks[0].dlugoscGenu; j++) {
populacja.osobniks[i].gen[j] = random.nextInt(360);
populacja.osobniks[i].genPredkosci[j] = random.nextInt(populacja.osobniks[0].predkosc)+1;
}
}
}
public boolean celOsiagniety(double najlepszaOcena){
if (najlepszaOcena < 300){
return true;
}else {
return false;
}
}
public void pokazPoOsiagnieciuCelu(double najlepszaOcena){
for (int i = 0; i < populacja.osobniks.length; i++) {
if (populacja.osobniks[i].ocena == najlepszaOcena){
System.out.println(populacja.osobniks[i].x + " " + populacja.osobniks[i].y);
System.out.println(najlepszaOcena);
for (int j = 0; j < populacja.osobniks.length; j++) {
if (j!=i){
for (int k = 0; k < populacja.osobniks[0].gen.length; k++) {
populacja.osobniks[j].gen[k] = populacja.osobniks[i].gen[k];
populacja.osobniks[j].genPredkosci[k] = populacja.osobniks[i].genPredkosci[k];
}
}
}
break;
}
}
}
@Override
public void run() {
int ktoryGen = 0;
while (true){
//reset zmiennej ktoryGen i zakonczenie generacji
if (ktoryGen == populacja.osobniks[0].gen.length){
ktoryGen = 0;
koniecGeneracji = true;
}
//procedura zakonczenia generacji i tworzenie nowej w przypadku gdy nie dodajemy nowych krokow (genow)
if (koniecGeneracji == true && generacja != kiedyDodacKroki){
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.osobniks[i].zycie = true;
populacja.osobniks[i].ocen(1000,100);
}
//nadawanie koloru najlepszemu osobnikowi
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.najlepszy();
if (populacja.osobniks[i].najlepszy){
populacja.osobniks[i].color = Color.red;
najlepszaOcena = populacja.osobniks[i].ocena;
}
}
selekcja();
reprodukcja();
zerujOcene(populacja);
zerujOcene(nowaPopulacja);
populacja.resetujPozycje();
populacja.sciany[0].reset(200,200);
populacja.sciany[1].reset(300,20);
populacja.sciany[2].reset(600,100);
populacja.sciany[3].reset(450,20);
koniecGeneracji = false;
generacja+=1;
}
//procedura zakonczenia generacji w przypadku gdy dodajemy nowe kroki (genomy)
if (koniecGeneracji == true && generacja == kiedyDodacKroki){
kiedyDodacKroki += kiedyDodawacKroki;
System.out.println("dodanie krokow");
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.osobniks[i].ocen(1000,100);
}
//wyznaczenie najlepszego osobnika
populacja.najlepszy();
//dodawanie nowych genow do tablicy przy zachowaniu czesci z najlepszego genomu
for (int i = 0; i < populacja.osobniks.length; i++) {
//dodanie wszystkim osobnikom nowych genow z zachowaniem poczatku genomu od najlepszego osobnika
if (populacja.osobniks[i].najlepszy == true){
populacja.osobniks[i].color = Color.red;
for (int j = 0; j < populacja.osobniks.length; j++) {
//pominiecie najlepszego osobnika
if (j != i) {
populacja.osobniks[j].dodajKroki(populacja.osobniks[i].gen, populacja.osobniks[i].genPredkosci, noweKroki);
}
}
//zwiekszanie dlugosci genu najlepszemu osobnikowi
populacja.osobniks[i].dodajKroki(populacja.osobniks[i].gen, populacja.osobniks[i].genPredkosci, noweKroki);
//zwiekszanie tablicy nowej populacji
for (int j = 0; j < populacja.osobniks.length; j++) {
nowaPopulacja.osobniks[j].dodajKroki(populacja.osobniks[i].gen, populacja.osobniks[i].genPredkosci, noweKroki);
}
}
populacja.osobniks[i].zycie = true;
}
zerujOcene(populacja);
zerujOcene(nowaPopulacja);
populacja.resetujPozycje();
populacja.sciany[0].reset(200,200);
populacja.sciany[1].reset(300,20);
populacja.sciany[2].reset(600,100);
ileDodano +=noweKroki;
koniecGeneracji = false;
generacja +=1;
}
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.osobniks[i].obecnyKat = populacja.osobniks[i].gen[ktoryGen];
populacja.osobniks[i].obecnyGenPredkosci = populacja.osobniks[i].genPredkosci[ktoryGen];
}
//zmienna ktoryGen zlicza ktory gen zostal juz uzyty
ktoryGen+=1;
try {
Thread.sleep(this.czestotliwoscZakretow);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
| //zwiekszanie tablicy nowej populacji
| package pl.rafal;
import java.awt.*;
import java.util.Random;
public class AlgorytmGenetyczny implements Runnable{
Populacja populacja;
Populacja nowaPopulacja;
int generacja;
double najlepszaOcena;
Random random = new Random();
int liczbaPopulacji;
int stopienSelekcji;
int pBmutacji;
int noweKroki; //ilosc dodawanych krokow(genow) co ileś generacji lub po osiagnieciu celu
int kiedyDodacKroki = 10; // zlicza w ktorej kolejnej generacji dodac kroki
int kiedyDodawacKroki = 10; //zmienna do sumowania juz dodanych krokow
int czestotliwoscZakretow; //czym wyzsza tym rzadziej
int ileDodano = 0;
boolean koniecGeneracji = false;
public AlgorytmGenetyczny(int liczbaPopulacji, int dlugoscGenu, int stopienSelekcji, int pBmutacji, int czestotliwoscZakretow, double predkosc) {
this.czestotliwoscZakretow = czestotliwoscZakretow;
this.pBmutacji = pBmutacji;
this.stopienSelekcji = stopienSelekcji;
this.liczbaPopulacji = liczbaPopulacji;
this.noweKroki = dlugoscGenu;
populacja = new Populacja(liczbaPopulacji, dlugoscGenu, predkosc);
nowaPopulacja = new Populacja(liczbaPopulacji, dlugoscGenu, predkosc);
}
//selekcja
public void selekcja(){
for (int i = 0; i < stopienSelekcji; i++) {
double najwyzsza = populacja.najlepszy();
for (int j = 0; j < liczbaPopulacji; j++) {
if (populacja.osobniks[j].ocena == najwyzsza){
for (int k = 0; k < populacja.osobniks[0].gen.length; k++) {
nowaPopulacja.osobniks[i].gen[k] = populacja.osobniks[j].gen[k];
populacja.osobniks[j].ocena = 1000000;
}
break;
}else {
populacja.osobniks[j].color = Color.black;
}
}
}
}
//tworzenie brakujacych osobnikow po selekcji
public void reprodukcja(){
for (int i = stopienSelekcji; i < nowaPopulacja.osobniks.length; i++) {
//losowanie osobnikow do reprodukcji
int wybraniec1 = random.nextInt(liczbaPopulacji);
int wybraniec2 = random.nextInt(liczbaPopulacji);
//losowanie wybranych osobnikow w przypadku gdy poprzednie losowanie wybralo tych samych
while (wybraniec1 == wybraniec2) {
wybraniec1 = random.nextInt(liczbaPopulacji);
wybraniec2 = random.nextInt(liczbaPopulacji);
}
//losowanie miejsca preciecia genu z pominieciem przedzialu
// ktory zostaje zachowany w przypadku dodania nowej czesci genu
int miejscePrzeciecia = random.nextInt(populacja.osobniks[0].gen.length - ileDodano) + ileDodano;
//zamiana pierwszej czesci genu pomijajac czesc genu ktory zostaje zachowany
for (int j = ileDodano; j < miejscePrzeciecia; j++) {
nowaPopulacja.osobniks[i].gen[j] = populacja.osobniks[wybraniec1].gen[j];
nowaPopulacja.osobniks[i].genPredkosci[j] = populacja.osobniks[wybraniec1].genPredkosci[j];
}
//zamiana drugiej czesci genu
for (int j = miejscePrzeciecia; j < populacja.osobniks[0].dlugoscGenu; j++) {
nowaPopulacja.osobniks[i].gen[j] = populacja.osobniks[wybraniec2].gen[j];
nowaPopulacja.osobniks[i].genPredkosci[j] = populacja.osobniks[wybraniec2].genPredkosci[j];
}
//losowa mutacja
mutacja(i, this.pBmutacji);
}
//tworzenie populacji z nowej populacji
for (int i = 0; i < populacja.osobniks.length; i++) {
for (int j = 0; j < populacja.osobniks[0].dlugoscGenu; j++) {
populacja.osobniks[i].gen[j] = nowaPopulacja.osobniks[i].gen[j];
populacja.osobniks[i].genPredkosci[j] = nowaPopulacja.osobniks[i].genPredkosci[j];
}
}
}
void zerujOcene(Populacja populacjaDoWyzerowania){
for (int i = 0; i < populacjaDoWyzerowania.osobniks.length; i++) {
populacjaDoWyzerowania.osobniks[i].ocena = 0;
populacjaDoWyzerowania.osobniks[i].ocenaDoDodania = 0;
}
}
void mutacja(int i, int pBmutacji){
if (random.nextInt(100) < pBmutacji){ //prawdopodobienstwo mutacji
for (int j = ileDodano; j < populacja.osobniks[0].dlugoscGenu; j++) {
populacja.osobniks[i].gen[j] = random.nextInt(360);
populacja.osobniks[i].genPredkosci[j] = random.nextInt(populacja.osobniks[0].predkosc)+1;
}
}
}
public boolean celOsiagniety(double najlepszaOcena){
if (najlepszaOcena < 300){
return true;
}else {
return false;
}
}
public void pokazPoOsiagnieciuCelu(double najlepszaOcena){
for (int i = 0; i < populacja.osobniks.length; i++) {
if (populacja.osobniks[i].ocena == najlepszaOcena){
System.out.println(populacja.osobniks[i].x + " " + populacja.osobniks[i].y);
System.out.println(najlepszaOcena);
for (int j = 0; j < populacja.osobniks.length; j++) {
if (j!=i){
for (int k = 0; k < populacja.osobniks[0].gen.length; k++) {
populacja.osobniks[j].gen[k] = populacja.osobniks[i].gen[k];
populacja.osobniks[j].genPredkosci[k] = populacja.osobniks[i].genPredkosci[k];
}
}
}
break;
}
}
}
@Override
public void run() {
int ktoryGen = 0;
while (true){
//reset zmiennej ktoryGen i zakonczenie generacji
if (ktoryGen == populacja.osobniks[0].gen.length){
ktoryGen = 0;
koniecGeneracji = true;
}
//procedura zakonczenia generacji i tworzenie nowej w przypadku gdy nie dodajemy nowych krokow (genow)
if (koniecGeneracji == true && generacja != kiedyDodacKroki){
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.osobniks[i].zycie = true;
populacja.osobniks[i].ocen(1000,100);
}
//nadawanie koloru najlepszemu osobnikowi
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.najlepszy();
if (populacja.osobniks[i].najlepszy){
populacja.osobniks[i].color = Color.red;
najlepszaOcena = populacja.osobniks[i].ocena;
}
}
selekcja();
reprodukcja();
zerujOcene(populacja);
zerujOcene(nowaPopulacja);
populacja.resetujPozycje();
populacja.sciany[0].reset(200,200);
populacja.sciany[1].reset(300,20);
populacja.sciany[2].reset(600,100);
populacja.sciany[3].reset(450,20);
koniecGeneracji = false;
generacja+=1;
}
//procedura zakonczenia generacji w przypadku gdy dodajemy nowe kroki (genomy)
if (koniecGeneracji == true && generacja == kiedyDodacKroki){
kiedyDodacKroki += kiedyDodawacKroki;
System.out.println("dodanie krokow");
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.osobniks[i].ocen(1000,100);
}
//wyznaczenie najlepszego osobnika
populacja.najlepszy();
//dodawanie nowych genow do tablicy przy zachowaniu czesci z najlepszego genomu
for (int i = 0; i < populacja.osobniks.length; i++) {
//dodanie wszystkim osobnikom nowych genow z zachowaniem poczatku genomu od najlepszego osobnika
if (populacja.osobniks[i].najlepszy == true){
populacja.osobniks[i].color = Color.red;
for (int j = 0; j < populacja.osobniks.length; j++) {
//pominiecie najlepszego osobnika
if (j != i) {
populacja.osobniks[j].dodajKroki(populacja.osobniks[i].gen, populacja.osobniks[i].genPredkosci, noweKroki);
}
}
//zwiekszanie dlugosci genu najlepszemu osobnikowi
populacja.osobniks[i].dodajKroki(populacja.osobniks[i].gen, populacja.osobniks[i].genPredkosci, noweKroki);
//zwiekszanie tablicy <SUF>
for (int j = 0; j < populacja.osobniks.length; j++) {
nowaPopulacja.osobniks[j].dodajKroki(populacja.osobniks[i].gen, populacja.osobniks[i].genPredkosci, noweKroki);
}
}
populacja.osobniks[i].zycie = true;
}
zerujOcene(populacja);
zerujOcene(nowaPopulacja);
populacja.resetujPozycje();
populacja.sciany[0].reset(200,200);
populacja.sciany[1].reset(300,20);
populacja.sciany[2].reset(600,100);
ileDodano +=noweKroki;
koniecGeneracji = false;
generacja +=1;
}
for (int i = 0; i < populacja.osobniks.length; i++) {
populacja.osobniks[i].obecnyKat = populacja.osobniks[i].gen[ktoryGen];
populacja.osobniks[i].obecnyGenPredkosci = populacja.osobniks[i].genPredkosci[ktoryGen];
}
//zmienna ktoryGen zlicza ktory gen zostal juz uzyty
ktoryGen+=1;
try {
Thread.sleep(this.czestotliwoscZakretow);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
| f | null |
310 | 6373_0 | RafalLeja/UWr | 172 | POO/lista3/zad5.java |
public interface List<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
// może być bardzo powolne dla LinkedList
E get(int index);
void add(int index, E element);
E remove(int index);
}
// ----------------------------------------------
public interface Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
// ... other collection methods
}
public interface IndexedCollection<E> extends Collection<E> {
E get(int index);
void add(int index, E element);
E remove(int index);
// ... other indexed methods
} | // może być bardzo powolne dla LinkedList |
public interface List<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
// może być <SUF>
E get(int index);
void add(int index, E element);
E remove(int index);
}
// ----------------------------------------------
public interface Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
// ... other collection methods
}
public interface IndexedCollection<E> extends Collection<E> {
E get(int index);
void add(int index, E element);
E remove(int index);
// ... other indexed methods
} | f | null |
311 | 4096_0 | Rafu7s/Java_sampless | 201 | Project-java-sampless/src/dev/Zadania_presentation/Zad8.java | package dev.Zadania_presentation;
public class Zad8 {
public static void main(String[] args) {
//Instrukcje sterujące
// Sprawdź pojedyncze wyrażenie if
if (4 + 2 == 7) {
System.out.println("Jest dobrze");
}
// Sprawdź if else
else {
System.out.println("Nie jest dobrze");
}
// Sprawdź if else if , if else if else
if (false) {
System.out.println(1);
}
else if (false) {
System.out.println(2);
}
else {
System.out.println(3);
}
}
}
| // Sprawdź pojedyncze wyrażenie if | package dev.Zadania_presentation;
public class Zad8 {
public static void main(String[] args) {
//Instrukcje sterujące
// Sprawdź pojedyncze <SUF>
if (4 + 2 == 7) {
System.out.println("Jest dobrze");
}
// Sprawdź if else
else {
System.out.println("Nie jest dobrze");
}
// Sprawdź if else if , if else if else
if (false) {
System.out.println(1);
}
else if (false) {
System.out.println(2);
}
else {
System.out.println(3);
}
}
}
| f | null |
313 | 6931_9 | ReaufSG/KK_3p | 1,715 | src/lekcja4/zad23.java | package lekcja4;
import java.awt.*;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class zad23 {
public static void main(String[] args) throws IOException {
//23. Generator osobistych stron internetowych
//Napisz program, który wyświetla prośbę o podanie imienia użytkownika, a następnie
//o wpisanie opisującego go zdania. Oto przykładowy przebieg programu:
//Podaj swoje imię: Julia Tracz [Enter]
//Opisz siebie: Studiuję informatykę, należę do zespołu jazzowego, a po studiach chcę
//pracować jako programistka aplikacji internetowych. [Enter]
//Po wprowadzeniu przez użytkownika żądanych danych wejściowych program powinien
//generować plik HTML z tymi danymi, tworząc w ten sposób prostą stronę internetową.
//Oto przykładowy kod w HTML-u oparty na pokazanych wcześniej danych
//wejściowych:
//<html>
//<head>
//</head>
//<body>
//<center>
//<h1>Julia Tracz</h1>
//</center>
//<hr />
//Studiuję informatykę, należę do zespołu jazzowego, a po studiach chcę
//pracować jako programistka aplikacji internetowych.
//<hr />
//</body>
//</html
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj swoje imię: ");
String name = scanner.nextLine();
System.out.println("Opisz siebie: ");
String description = scanner.nextLine();
System.out.println("Podaj kolor tła: ");
String color = scanner.nextLine();
System.out.println("Podaj kolor czcionki: ");
String fontColor = scanner.nextLine();
System.out.println("Podaj kolor nagłówka: ");
String headerColor = scanner.nextLine();
FileWriter fileWriter = new FileWriter("index.html");
PrintWriter writer = new PrintWriter(fileWriter);
writer.println("<!DOCTYPE html>");
writer.println("<html>");
writer.println("<head>");
writer.println("<link rel=\"stylesheet\" type=\"text/css\" href=\"styl.css\">");
writer.println("<script defer src=\"skrypt.js\"></script>");
writer.println("</head>");
writer.println("<body>");
writer.println("<center>");
writer.println("<h1>" + name + "</h1>");
writer.println("<span class=\"website-counter\">To Twoja pierwsza wizyta na naszej stronie!</span>");
writer.println("</center>");
writer.println("<hr/>");
writer.println("<p>" + description + "</p>");
writer.println("<hr/>");
writer.println("<button onclick=\"window.location.href='styl.css'\">Styl</button>");
writer.println("<button onclick=\"window.location.href='skrypt.js'\">Skrypt</button>");
writer.println("<button onclick=\"al()\">Klik!</button>");
writer.println("<button id=\"reset\">Reset</button>");
writer.println("</body>");
writer.println("</html>");
FileWriter fileWriter2 = new FileWriter("styl.css");
PrintWriter writer2 = new PrintWriter(fileWriter2);
writer2.println("body {background-color: " + color + ";}");
writer2.println("h1 {color: " + headerColor + ";}");
writer2.println("p {color: " + fontColor + ";}");
writer2.close();
fileWriter2.close();
FileWriter fileWriter3 = new FileWriter("skrypt.js");
PrintWriter writer3 = new PrintWriter(fileWriter3);
writer3.println("function al() {");
writer3.println("alert(\"Hello! I am an alert box!\");");
writer3.println("}");
//var counterContainer = document.querySelector(".website-counter");
//var resetButton = document.querySelector("#reset");
//var visitCount = localStorage.getItem("page_view");
//
//// Check if page_view entry is present
//if (visitCount) {
// visitCount = Number(visitCount) + 1;
// localStorage.setItem("page_view", visitCount);
//} else {
// visitCount = 1;
// localStorage.setItem("page_view", 1);
//}
//counterContainer.innerHTML = visitCount;
//
//// Adding onClick event listener
//resetButton.addEventListener("click", () => {
// visitCount = 1;
// localStorage.setItem("page_view", 1);
// counterContainer.innerHTML = visitCount;
//});
writer3.println("var counterContainer = document.querySelector(\".website-counter\");");
writer3.println("var resetButton = document.querySelector(\"#reset\");");
writer3.println("var visitCount = localStorage.getItem(\"page_view\");");
writer3.println("if (visitCount) {");
writer3.println("visitCount = Number(visitCount) + 1;");
writer3.println("localStorage.setItem(\"page_view\", visitCount);");
writer3.println("} else {");
writer3.println("visitCount = 1;");
writer3.println("localStorage.setItem(\"page_view\", 1);");
writer3.println("}");
writer3.println("counterContainer.innerHTML = \"To Twoja: \" +visitCount+ \" wizyta na naszej stronie!\";");
writer3.println("resetButton.addEventListener(\"click\", () => {");
writer3.println("visitCount = 1;");
writer3.println("localStorage.setItem(\"page_view\", 1);");
writer3.println("counterContainer.innerHTML = \"To Twoja pierwsza wizyta na naszej stronie!\";");
writer3.println("});");
writer3.close();
fileWriter3.close();
writer.close();
fileWriter.close();
File htmlFile = new File("index.html");
Desktop.getDesktop().browse(htmlFile.toURI());
}
}
| //Studiuję informatykę, należę do zespołu jazzowego, a po studiach chcę | package lekcja4;
import java.awt.*;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class zad23 {
public static void main(String[] args) throws IOException {
//23. Generator osobistych stron internetowych
//Napisz program, który wyświetla prośbę o podanie imienia użytkownika, a następnie
//o wpisanie opisującego go zdania. Oto przykładowy przebieg programu:
//Podaj swoje imię: Julia Tracz [Enter]
//Opisz siebie: Studiuję informatykę, należę do zespołu jazzowego, a po studiach chcę
//pracować jako programistka aplikacji internetowych. [Enter]
//Po wprowadzeniu przez użytkownika żądanych danych wejściowych program powinien
//generować plik HTML z tymi danymi, tworząc w ten sposób prostą stronę internetową.
//Oto przykładowy kod w HTML-u oparty na pokazanych wcześniej danych
//wejściowych:
//<html>
//<head>
//</head>
//<body>
//<center>
//<h1>Julia Tracz</h1>
//</center>
//<hr />
//Studiuję informatykę, <SUF>
//pracować jako programistka aplikacji internetowych.
//<hr />
//</body>
//</html
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj swoje imię: ");
String name = scanner.nextLine();
System.out.println("Opisz siebie: ");
String description = scanner.nextLine();
System.out.println("Podaj kolor tła: ");
String color = scanner.nextLine();
System.out.println("Podaj kolor czcionki: ");
String fontColor = scanner.nextLine();
System.out.println("Podaj kolor nagłówka: ");
String headerColor = scanner.nextLine();
FileWriter fileWriter = new FileWriter("index.html");
PrintWriter writer = new PrintWriter(fileWriter);
writer.println("<!DOCTYPE html>");
writer.println("<html>");
writer.println("<head>");
writer.println("<link rel=\"stylesheet\" type=\"text/css\" href=\"styl.css\">");
writer.println("<script defer src=\"skrypt.js\"></script>");
writer.println("</head>");
writer.println("<body>");
writer.println("<center>");
writer.println("<h1>" + name + "</h1>");
writer.println("<span class=\"website-counter\">To Twoja pierwsza wizyta na naszej stronie!</span>");
writer.println("</center>");
writer.println("<hr/>");
writer.println("<p>" + description + "</p>");
writer.println("<hr/>");
writer.println("<button onclick=\"window.location.href='styl.css'\">Styl</button>");
writer.println("<button onclick=\"window.location.href='skrypt.js'\">Skrypt</button>");
writer.println("<button onclick=\"al()\">Klik!</button>");
writer.println("<button id=\"reset\">Reset</button>");
writer.println("</body>");
writer.println("</html>");
FileWriter fileWriter2 = new FileWriter("styl.css");
PrintWriter writer2 = new PrintWriter(fileWriter2);
writer2.println("body {background-color: " + color + ";}");
writer2.println("h1 {color: " + headerColor + ";}");
writer2.println("p {color: " + fontColor + ";}");
writer2.close();
fileWriter2.close();
FileWriter fileWriter3 = new FileWriter("skrypt.js");
PrintWriter writer3 = new PrintWriter(fileWriter3);
writer3.println("function al() {");
writer3.println("alert(\"Hello! I am an alert box!\");");
writer3.println("}");
//var counterContainer = document.querySelector(".website-counter");
//var resetButton = document.querySelector("#reset");
//var visitCount = localStorage.getItem("page_view");
//
//// Check if page_view entry is present
//if (visitCount) {
// visitCount = Number(visitCount) + 1;
// localStorage.setItem("page_view", visitCount);
//} else {
// visitCount = 1;
// localStorage.setItem("page_view", 1);
//}
//counterContainer.innerHTML = visitCount;
//
//// Adding onClick event listener
//resetButton.addEventListener("click", () => {
// visitCount = 1;
// localStorage.setItem("page_view", 1);
// counterContainer.innerHTML = visitCount;
//});
writer3.println("var counterContainer = document.querySelector(\".website-counter\");");
writer3.println("var resetButton = document.querySelector(\"#reset\");");
writer3.println("var visitCount = localStorage.getItem(\"page_view\");");
writer3.println("if (visitCount) {");
writer3.println("visitCount = Number(visitCount) + 1;");
writer3.println("localStorage.setItem(\"page_view\", visitCount);");
writer3.println("} else {");
writer3.println("visitCount = 1;");
writer3.println("localStorage.setItem(\"page_view\", 1);");
writer3.println("}");
writer3.println("counterContainer.innerHTML = \"To Twoja: \" +visitCount+ \" wizyta na naszej stronie!\";");
writer3.println("resetButton.addEventListener(\"click\", () => {");
writer3.println("visitCount = 1;");
writer3.println("localStorage.setItem(\"page_view\", 1);");
writer3.println("counterContainer.innerHTML = \"To Twoja pierwsza wizyta na naszej stronie!\";");
writer3.println("});");
writer3.close();
fileWriter3.close();
writer.close();
fileWriter.close();
File htmlFile = new File("index.html");
Desktop.getDesktop().browse(htmlFile.toURI());
}
}
| f | null |
314 | 6206_6 | Reicsen/gra_w_go | 752 | src/main/java/com/go/GUI/PrzyciskPionek.java | package com.go.GUI;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Line;
import com.go.Gra.Klienci.Klient;
public class PrzyciskPionek extends Button
{
PrzyciskPionek(Klient gracz, int x, int y){
//Stworzenie przycisku który ma na sobie grafike (krzyż)
super();
setMaxSize(26, 26);
Line cross1 = new Line(13, 0, 13, 26);
Line cross2 = new Line(0, 13, 26, 13);
cross1.setStroke(Color.BLACK);
cross2.setStroke(Color.BLACK);
cross1.setStrokeWidth(3);
cross2.setStrokeWidth(3);
StackPane stackPane = new StackPane();
stackPane.getChildren().addAll(cross1, cross2);
setGraphic(stackPane);
//Ustawienie akcji że po naciśnięciu w przycisk gracz spróbuje postawić pionek w to miejsce
setOnAction(event -> {
gracz.wykonajRuch(y, x);
});
}
//Funkcja która zmienia grafike na przycisku
//krzyż zmieniany jest na koło
//Ta funkcja jest potrzebna aby po udanym postawieniu pionka w dane miejsce dało się "zobaczyć" na planszy, że jest tam pionek
public void zmienPrzyciskNaKolo(Button button, Color kolor) {
Circle circle = new Circle(13, kolor);
circle.setStroke(Color.BLACK);
circle.setStrokeWidth(3);
button.setGraphic(circle);
}
//Funkcja która zmienia grafike na przycisku
//koło zmieniane jest na krzyż
//Ta funkcja jest potrzebna aby po usunięciu pionka dało się "zobaczyć" na planszy, że go tam nie ma
public void zmienPrzyciskNaKrzyzyk(Button button){
Line cross1 = new Line(13, 0, 13, 26);
Line cross2 = new Line(0, 13, 26, 13);
cross1.setStroke(Color.BLACK);
cross2.setStroke(Color.BLACK);
cross1.setStrokeWidth(3);
cross2.setStrokeWidth(3);
StackPane stackPane = new StackPane();
stackPane.getChildren().addAll(cross1, cross2);
button.setGraphic(stackPane);
}
}
| //koło zmieniane jest na krzyż | package com.go.GUI;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Line;
import com.go.Gra.Klienci.Klient;
public class PrzyciskPionek extends Button
{
PrzyciskPionek(Klient gracz, int x, int y){
//Stworzenie przycisku który ma na sobie grafike (krzyż)
super();
setMaxSize(26, 26);
Line cross1 = new Line(13, 0, 13, 26);
Line cross2 = new Line(0, 13, 26, 13);
cross1.setStroke(Color.BLACK);
cross2.setStroke(Color.BLACK);
cross1.setStrokeWidth(3);
cross2.setStrokeWidth(3);
StackPane stackPane = new StackPane();
stackPane.getChildren().addAll(cross1, cross2);
setGraphic(stackPane);
//Ustawienie akcji że po naciśnięciu w przycisk gracz spróbuje postawić pionek w to miejsce
setOnAction(event -> {
gracz.wykonajRuch(y, x);
});
}
//Funkcja która zmienia grafike na przycisku
//krzyż zmieniany jest na koło
//Ta funkcja jest potrzebna aby po udanym postawieniu pionka w dane miejsce dało się "zobaczyć" na planszy, że jest tam pionek
public void zmienPrzyciskNaKolo(Button button, Color kolor) {
Circle circle = new Circle(13, kolor);
circle.setStroke(Color.BLACK);
circle.setStrokeWidth(3);
button.setGraphic(circle);
}
//Funkcja która zmienia grafike na przycisku
//koło zmieniane <SUF>
//Ta funkcja jest potrzebna aby po usunięciu pionka dało się "zobaczyć" na planszy, że go tam nie ma
public void zmienPrzyciskNaKrzyzyk(Button button){
Line cross1 = new Line(13, 0, 13, 26);
Line cross2 = new Line(0, 13, 26, 13);
cross1.setStroke(Color.BLACK);
cross2.setStroke(Color.BLACK);
cross1.setStrokeWidth(3);
cross2.setStrokeWidth(3);
StackPane stackPane = new StackPane();
stackPane.getChildren().addAll(cross1, cross2);
button.setGraphic(stackPane);
}
}
| f | null |
316 | 3815_0 | Rentib/mimuw | 1,678 | sem2/po/lab/10/Zasoby.java | class MójBłąd extends Exception {
private String plik;
MójBłąd(String plik) {
this.plik = plik;
}
@Override
public String toString() {
return super.toString() + "(" + plik + ")";
}
}
class BłądOtwierania extends MójBłąd {
BłądOtwierania(String plik) {
super(plik);
}
}
class BłądCzytania extends Exception {
BłądCzytania(String plik) {
super(plik);
}
}
class Zasób1 implements AutoCloseable {
private boolean czyMa = false;
private String nazwa;
public Zasób1(String nazwa) throws BłądOtwierania {
if (Math.random() > 0.75)
throw new BłądOtwierania(nazwa);
this.nazwa = nazwa;
System.out.printf("Zasób1(%s) otwarty.\n", nazwa);
}
public boolean maLiczbę() {
return czyMa = Math.random() > 0.5;
}
public int dajLiczbę() throws BłądCzytania {
if (!czyMa || Math.random() > 0.9)
throw new BłądCzytania(nazwa);
else
return (int) (Math.random() * 42);
}
@Override
public void close() {
System.out.printf("Zasób1(%s) zamknięty!\n", nazwa);
}
}
class Zasób2 implements AutoCloseable {
public Zasób2() {
System.out.println("Zasób2 otwarty.");
}
public void zróbCoś() {
}
@Override
public void close() {
System.out.println("Zasób2 zamknięty!");
}
}
public class Zasoby {
public int m(String[] nazwyPlików, int k) throws Exception {
Zasób2 z2 = new Zasób2();
if (k == 0)
return -1;
for (int i = 0; i < nazwyPlików.length; i++) {
Zasób1 z = new Zasób1(nazwyPlików[i]);
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
return wyn;
}
}
}
return 0;
}
// try-catch
public int m1(String[] nazwyPlików, int k) throws BłądOtwierania, BłądCzytania {
if (k == 0)
return -1;
Zasób2 z2 = new Zasób2();
try {
for (int i = 0; i < nazwyPlików.length; i++) {
Zasób1 z = new Zasób1(nazwyPlików[i]);
try {
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
z.close();
z2.close();
return wyn;
}
}
} catch (BłądCzytania e) {
z.close();
throw e;
}
z.close();
}
} catch (BłądOtwierania|BłądCzytania e) {
z2.close();
throw e;
}
z2.close();
return 0;
}
// try-finally
public int m2(String[] nazwyPlików, int k) throws BłądOtwierania, BłądCzytania {
if (k == 0)
return -1;
Zasób2 z2 = new Zasób2();
try {
for (int i = 0; i < nazwyPlików.length; i++) {
Zasób1 z = new Zasób1(nazwyPlików[i]);
try {
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
return wyn;
}
}
} finally {
z.close();
}
}
} finally {
z2.close();
}
return 0;
}
// try z zasobami
public int m3(String[] nazwyPlików, int k) throws BłądOtwierania, BłądCzytania {
try (Zasób2 z2 = new Zasób2()) {
if (k == 0)
return -1;
for (int i = 0; i < nazwyPlików.length; i++) {
try (Zasób1 z = new Zasób1((nazwyPlików[i]))) {
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
return wyn;
}
}
}
}
}
return 0;
}
public static void main(String[] args) {
Zasoby z = new Zasoby();
System.out.printf("m1\n");
try {
z.m1(new String[]{"raz", "dwa", "trzy", "cztery"}, 13);
} catch (BłądOtwierania|BłądCzytania e) {
System.out.println(e);
}
System.out.printf("m2\n");
try {
z.m2(new String[]{"raz", "dwa", "trzy", "cztery"}, 13);
} catch (BłądOtwierania|BłądCzytania e) {
System.out.println(e);
}
System.out.printf("m3\n");
try {
z.m3(new String[]{"raz", "dwa", "trzy", "cztery"}, 13);
} catch (BłądOtwierania|BłądCzytania e) {
System.out.println(e);
}
}
}
| // try z zasobami | class MójBłąd extends Exception {
private String plik;
MójBłąd(String plik) {
this.plik = plik;
}
@Override
public String toString() {
return super.toString() + "(" + plik + ")";
}
}
class BłądOtwierania extends MójBłąd {
BłądOtwierania(String plik) {
super(plik);
}
}
class BłądCzytania extends Exception {
BłądCzytania(String plik) {
super(plik);
}
}
class Zasób1 implements AutoCloseable {
private boolean czyMa = false;
private String nazwa;
public Zasób1(String nazwa) throws BłądOtwierania {
if (Math.random() > 0.75)
throw new BłądOtwierania(nazwa);
this.nazwa = nazwa;
System.out.printf("Zasób1(%s) otwarty.\n", nazwa);
}
public boolean maLiczbę() {
return czyMa = Math.random() > 0.5;
}
public int dajLiczbę() throws BłądCzytania {
if (!czyMa || Math.random() > 0.9)
throw new BłądCzytania(nazwa);
else
return (int) (Math.random() * 42);
}
@Override
public void close() {
System.out.printf("Zasób1(%s) zamknięty!\n", nazwa);
}
}
class Zasób2 implements AutoCloseable {
public Zasób2() {
System.out.println("Zasób2 otwarty.");
}
public void zróbCoś() {
}
@Override
public void close() {
System.out.println("Zasób2 zamknięty!");
}
}
public class Zasoby {
public int m(String[] nazwyPlików, int k) throws Exception {
Zasób2 z2 = new Zasób2();
if (k == 0)
return -1;
for (int i = 0; i < nazwyPlików.length; i++) {
Zasób1 z = new Zasób1(nazwyPlików[i]);
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
return wyn;
}
}
}
return 0;
}
// try-catch
public int m1(String[] nazwyPlików, int k) throws BłądOtwierania, BłądCzytania {
if (k == 0)
return -1;
Zasób2 z2 = new Zasób2();
try {
for (int i = 0; i < nazwyPlików.length; i++) {
Zasób1 z = new Zasób1(nazwyPlików[i]);
try {
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
z.close();
z2.close();
return wyn;
}
}
} catch (BłądCzytania e) {
z.close();
throw e;
}
z.close();
}
} catch (BłądOtwierania|BłądCzytania e) {
z2.close();
throw e;
}
z2.close();
return 0;
}
// try-finally
public int m2(String[] nazwyPlików, int k) throws BłądOtwierania, BłądCzytania {
if (k == 0)
return -1;
Zasób2 z2 = new Zasób2();
try {
for (int i = 0; i < nazwyPlików.length; i++) {
Zasób1 z = new Zasób1(nazwyPlików[i]);
try {
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
return wyn;
}
}
} finally {
z.close();
}
}
} finally {
z2.close();
}
return 0;
}
// try z <SUF>
public int m3(String[] nazwyPlików, int k) throws BłądOtwierania, BłądCzytania {
try (Zasób2 z2 = new Zasób2()) {
if (k == 0)
return -1;
for (int i = 0; i < nazwyPlików.length; i++) {
try (Zasób1 z = new Zasób1((nazwyPlików[i]))) {
while (z.maLiczbę()) {
int wyn = z.dajLiczbę();
if (wyn % k == 0) {
return wyn;
}
}
}
}
}
return 0;
}
public static void main(String[] args) {
Zasoby z = new Zasoby();
System.out.printf("m1\n");
try {
z.m1(new String[]{"raz", "dwa", "trzy", "cztery"}, 13);
} catch (BłądOtwierania|BłądCzytania e) {
System.out.println(e);
}
System.out.printf("m2\n");
try {
z.m2(new String[]{"raz", "dwa", "trzy", "cztery"}, 13);
} catch (BłądOtwierania|BłądCzytania e) {
System.out.println(e);
}
System.out.printf("m3\n");
try {
z.m3(new String[]{"raz", "dwa", "trzy", "cztery"}, 13);
} catch (BłądOtwierania|BłądCzytania e) {
System.out.println(e);
}
}
}
| f | null |
317 | 6553_17 | RoboCap/mindstorms | 1,241 | leJOS/workspace/NXTTest/src/pl/robocap/RobotStroz.java | package pl.robocap;
import lejos.nxt.Button;
import lejos.nxt.ColorSensor;
import lejos.nxt.LCD;
import lejos.nxt.Motor;
import lejos.nxt.SensorPort;
import lejos.nxt.Sound;
import lejos.nxt.UltrasonicSensor;
import lejos.robotics.navigation.DifferentialPilot;
import lejos.robotics.subsumption.Arbitrator;
import lejos.robotics.subsumption.Behavior;
import lejos.util.Delay;
/**
* Wszytskie czesci robota patrolujacego zlozone razem
*/
public class RobotStroz {
// pilot do sterowania ruchu robota
static DifferentialPilot pilot = new DifferentialPilot(3.5f, 19f, Motor.B, Motor.C);
static class ZachowanieRobotaWCzasiePatrolu implements Behavior {
private boolean czyZatrzymacPatrolowanie;
public boolean takeControl() {
return true; // to nasza podstawowa czynnosc.
}
public void suppress() {
czyZatrzymacPatrolowanie = true;
}
public void action() {
czyZatrzymacPatrolowanie = false;
// jedź po prostej
RobotStroz.pilot.travel(40, true);
while (!czyZatrzymacPatrolowanie && RobotStroz.pilot.isMoving()) {
Thread.yield(); // czekaj aż dojedziesz
}
// albo dojechałeś, albo zaczął się atak: zatrzymaj silniki
RobotStroz.pilot.stop();
// jeśli nie było akcji ataku, to możesz zawrócić
if (!czyZatrzymacPatrolowanie) {
RobotStroz.pilot.rotate(180);
}
}
}
static class ZachowanieRobotaWCzasieAtaku implements Behavior {
private UltrasonicSensor sonar = new UltrasonicSensor(SensorPort.S4);
public boolean takeControl() {
// rozpocznij akcje ataku gdy intruz w zasiegu
sonar.ping();
return sonar.getDistance() < 25;
}
public void suppress() {
}
public void action() {
ColorSensor armata = new ColorSensor(SensorPort.S3);
// sprawdz czy wykrywasz intruza
sonar.ping();
if (sonar.getDistance() < 25) {
// jesli TAK: ostrzez dzwiekiem
Sound.playNote(Sound.FLUTE, Sound.C2, 500);
// poczekaj 3 sekundy
Delay.msDelay(3000);
// sprawdz czy nadal wykrywasz intruza
sonar.ping();
// jesli TAK: ostrzelaj dzialkiem
if (sonar.getDistance() < 25) {
armata.setFloodlight(true);
}
} else {
// jesli NIE: wylacz dzialko
armata.setFloodlight(false);
}
}
}
/**
* glowny blok programu
*/
public static void main(String[] args) {
// przygotuj akcje robota
Behavior akcjaPatrolowania = new ZachowanieRobotaWCzasiePatrolu();
Behavior akcjaAtaku = new ZachowanieRobotaWCzasieAtaku();
Behavior[] akcjeRobota = { akcjaPatrolowania, akcjaAtaku };
// specjalny koordynator akcji
Arbitrator arbitrator = new Arbitrator(akcjeRobota);
// wyświetl informację
LCD.drawString("Robot Stroz gotowy!", 0, 1);
// poczekaj na naciśnięcie jakiegokolwiek przycisku
Button.waitForAnyPress();
// rozpocznij akcje
arbitrator.start();
}
}
| // poczekaj na naciśnięcie jakiegokolwiek przycisku | package pl.robocap;
import lejos.nxt.Button;
import lejos.nxt.ColorSensor;
import lejos.nxt.LCD;
import lejos.nxt.Motor;
import lejos.nxt.SensorPort;
import lejos.nxt.Sound;
import lejos.nxt.UltrasonicSensor;
import lejos.robotics.navigation.DifferentialPilot;
import lejos.robotics.subsumption.Arbitrator;
import lejos.robotics.subsumption.Behavior;
import lejos.util.Delay;
/**
* Wszytskie czesci robota patrolujacego zlozone razem
*/
public class RobotStroz {
// pilot do sterowania ruchu robota
static DifferentialPilot pilot = new DifferentialPilot(3.5f, 19f, Motor.B, Motor.C);
static class ZachowanieRobotaWCzasiePatrolu implements Behavior {
private boolean czyZatrzymacPatrolowanie;
public boolean takeControl() {
return true; // to nasza podstawowa czynnosc.
}
public void suppress() {
czyZatrzymacPatrolowanie = true;
}
public void action() {
czyZatrzymacPatrolowanie = false;
// jedź po prostej
RobotStroz.pilot.travel(40, true);
while (!czyZatrzymacPatrolowanie && RobotStroz.pilot.isMoving()) {
Thread.yield(); // czekaj aż dojedziesz
}
// albo dojechałeś, albo zaczął się atak: zatrzymaj silniki
RobotStroz.pilot.stop();
// jeśli nie było akcji ataku, to możesz zawrócić
if (!czyZatrzymacPatrolowanie) {
RobotStroz.pilot.rotate(180);
}
}
}
static class ZachowanieRobotaWCzasieAtaku implements Behavior {
private UltrasonicSensor sonar = new UltrasonicSensor(SensorPort.S4);
public boolean takeControl() {
// rozpocznij akcje ataku gdy intruz w zasiegu
sonar.ping();
return sonar.getDistance() < 25;
}
public void suppress() {
}
public void action() {
ColorSensor armata = new ColorSensor(SensorPort.S3);
// sprawdz czy wykrywasz intruza
sonar.ping();
if (sonar.getDistance() < 25) {
// jesli TAK: ostrzez dzwiekiem
Sound.playNote(Sound.FLUTE, Sound.C2, 500);
// poczekaj 3 sekundy
Delay.msDelay(3000);
// sprawdz czy nadal wykrywasz intruza
sonar.ping();
// jesli TAK: ostrzelaj dzialkiem
if (sonar.getDistance() < 25) {
armata.setFloodlight(true);
}
} else {
// jesli NIE: wylacz dzialko
armata.setFloodlight(false);
}
}
}
/**
* glowny blok programu
*/
public static void main(String[] args) {
// przygotuj akcje robota
Behavior akcjaPatrolowania = new ZachowanieRobotaWCzasiePatrolu();
Behavior akcjaAtaku = new ZachowanieRobotaWCzasieAtaku();
Behavior[] akcjeRobota = { akcjaPatrolowania, akcjaAtaku };
// specjalny koordynator akcji
Arbitrator arbitrator = new Arbitrator(akcjeRobota);
// wyświetl informację
LCD.drawString("Robot Stroz gotowy!", 0, 1);
// poczekaj na <SUF>
Button.waitForAnyPress();
// rozpocznij akcje
arbitrator.start();
}
}
| f | null |
318 | 3971_0 | Rolaski/Java-Studies | 309 | Shop Project/src/clientWallet.java | public class clientWallet
{
public static void clientWalletCheck(String login)
{
int walletCatch;
DataBase wallet = new DataBase("SELECT wallet FROM jdbc.customers WHERE login ='"+login+"';");
walletCatch = wallet.walletUser();
System.out.println("Your current funds: "+walletCatch);
}
public static void clientWalletUpdate(String login)
{
//żeby wpłacić hajs trzeba wiedzieć ile użytkownik go ma
//więc sprawdzimy i dodamy nową kwotę a sumę wrzucamy do bazy
int walletCatch;
DataBase wallet = new DataBase("SELECT wallet FROM jdbc.customers WHERE login ='"+login+"';");
walletCatch = wallet.walletUser();
int walletUpdate = inputs.inputIntMessage("Enter the amount to be deposited: ");
DataBase walletInsert = new DataBase("UPDATE `jdbc`.`customers` SET `wallet` = '"+(walletCatch + walletUpdate)+"' WHERE (`login` = '"+login+"');");
walletInsert.productInput();
}
}
| //żeby wpłacić hajs trzeba wiedzieć ile użytkownik go ma | public class clientWallet
{
public static void clientWalletCheck(String login)
{
int walletCatch;
DataBase wallet = new DataBase("SELECT wallet FROM jdbc.customers WHERE login ='"+login+"';");
walletCatch = wallet.walletUser();
System.out.println("Your current funds: "+walletCatch);
}
public static void clientWalletUpdate(String login)
{
//żeby wpłacić <SUF>
//więc sprawdzimy i dodamy nową kwotę a sumę wrzucamy do bazy
int walletCatch;
DataBase wallet = new DataBase("SELECT wallet FROM jdbc.customers WHERE login ='"+login+"';");
walletCatch = wallet.walletUser();
int walletUpdate = inputs.inputIntMessage("Enter the amount to be deposited: ");
DataBase walletInsert = new DataBase("UPDATE `jdbc`.`customers` SET `wallet` = '"+(walletCatch + walletUpdate)+"' WHERE (`login` = '"+login+"');");
walletInsert.productInput();
}
}
| f | null |
320 | 10356_5 | Rosenya/BilbiotekaWirtualna | 719 | src/main/java/com/ArkadiaPlocienniczak/BilbiotekaWirtualna/config/WebSecurityConfig.java | package com.ArkadiaPlocienniczak.BilbiotekaWirtualna.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
/*
@return validation methods on backend side. due to lack of time i failed to set roles on a frontend side.
i've only started a validation process via log in. i'd like to continue that part with a next sprint
*/
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("user").password(passwordEncoder().encode("user")).roles("USER")
.and()
.withUser("admin").password(passwordEncoder().encode("admin")).roles("ADMIN");
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/AdminPanel")//mają dostęp wszyscy użytkownicy ROLE_ADMIN
.hasRole("ADMIN")
.and()
.csrf().disable() // wyłączamy zabezpieczenie CSRF w celu użycia np Postmana
.headers().frameOptions().disable()
.and()
.formLogin()//wskazuje, że teraz będę konfigurował formularz autoryzacji
.loginPage("/login") //wskazuje enpoint w którym będzie odbywać się autoryzacja
.usernameParameter("username") // nadajemy nazwę jaka będzie jako name w inpucie loginu w formularzu
.passwordParameter("password") // // nadajemy nazwę jaka będzie jako name w inpucie hasła w formularzu
.loginProcessingUrl("/login")
.failureForwardUrl("/login?error") // co się stanie kiedy wpiszesz zły login lub hasło
.defaultSuccessUrl("/") // co się stanie w momenice prawidłowego wpisania loginu i hasła
.and()
.logout() // mówimy springowi że przechodzimy do obsłużenia logout
.logoutSuccessUrl("/login");
}
} | // nadajemy nazwę jaka będzie jako name w inpucie loginu w formularzu | package com.ArkadiaPlocienniczak.BilbiotekaWirtualna.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
/*
@return validation methods on backend side. due to lack of time i failed to set roles on a frontend side.
i've only started a validation process via log in. i'd like to continue that part with a next sprint
*/
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("user").password(passwordEncoder().encode("user")).roles("USER")
.and()
.withUser("admin").password(passwordEncoder().encode("admin")).roles("ADMIN");
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/AdminPanel")//mają dostęp wszyscy użytkownicy ROLE_ADMIN
.hasRole("ADMIN")
.and()
.csrf().disable() // wyłączamy zabezpieczenie CSRF w celu użycia np Postmana
.headers().frameOptions().disable()
.and()
.formLogin()//wskazuje, że teraz będę konfigurował formularz autoryzacji
.loginPage("/login") //wskazuje enpoint w którym będzie odbywać się autoryzacja
.usernameParameter("username") // nadajemy nazwę <SUF>
.passwordParameter("password") // // nadajemy nazwę jaka będzie jako name w inpucie hasła w formularzu
.loginProcessingUrl("/login")
.failureForwardUrl("/login?error") // co się stanie kiedy wpiszesz zły login lub hasło
.defaultSuccessUrl("/") // co się stanie w momenice prawidłowego wpisania loginu i hasła
.and()
.logout() // mówimy springowi że przechodzimy do obsłużenia logout
.logoutSuccessUrl("/login");
}
} | f | null |
321 | 3505_5 | Rudzix77/UTP | 709 | UTP13_JM_S16842/src/Cre1.java | import java.sql.*;
public class Cre1 {
static public void main(String[] args) {
new Cre1();
}
Statement stmt;
Cre1() {
Connection con = null;
try {
Class.forName("org.apache.derby.jdbc.ClientDriver").newInstance();
con = DriverManager.getConnection("jdbc:derby://localhost:1527//Users/yaneek/tmp2/ksidb-copy");
stmt = con.createStatement();
} catch (Exception exc) {
System.out.println(exc);
System.exit(1);
}
// metoda dropTable jest naszą własną metodą napisaną dla skrócenia programu
// usuwa ona tabelę podaną jako argument
// Aby w każdych okolicznościach stworzyć nową tabelę AUTOR
// musimy usunąć ew. już istniejącą tabelę AUTOR
dropTable("POZYCJE"); // usunięcie tabeli pochodnej, będącej w relacji z tabelą AUTOR
dropTable("AUTOR"); // usunięcie tabeli AUTOR
String crestmt = "create table AUTOR (AUTID integer not null generated by default as identity, NAME varchar(255) not null, PRIMARY KEY(AUTID))";
try {
stmt.execute(crestmt);
} catch (SQLException exc) { // przechwycenie wyjątku:
System.out.println("SQL except.: " + exc.getMessage());
System.out.println("SQL state : " + exc.getSQLState());
System.out.println("Vendor errc: " + exc.getErrorCode());
System.exit(1);
} finally {
try {
stmt.close();
con.close();
} catch (SQLException exc) {
System.out.println(exc);
System.exit(1);
}
}
}
private void dropTable(String name){
try {
stmt.execute("DROP TABLE " + name);
} catch (SQLException exc) { // przechwycenie wyjątku:
System.out.println("SQL except.: " + exc.getMessage());
System.out.println("SQL state : " + exc.getSQLState());
System.out.println("Vendor errc: " + exc.getErrorCode());
System.exit(1);
}
}
} | // usunięcie tabeli AUTOR | import java.sql.*;
public class Cre1 {
static public void main(String[] args) {
new Cre1();
}
Statement stmt;
Cre1() {
Connection con = null;
try {
Class.forName("org.apache.derby.jdbc.ClientDriver").newInstance();
con = DriverManager.getConnection("jdbc:derby://localhost:1527//Users/yaneek/tmp2/ksidb-copy");
stmt = con.createStatement();
} catch (Exception exc) {
System.out.println(exc);
System.exit(1);
}
// metoda dropTable jest naszą własną metodą napisaną dla skrócenia programu
// usuwa ona tabelę podaną jako argument
// Aby w każdych okolicznościach stworzyć nową tabelę AUTOR
// musimy usunąć ew. już istniejącą tabelę AUTOR
dropTable("POZYCJE"); // usunięcie tabeli pochodnej, będącej w relacji z tabelą AUTOR
dropTable("AUTOR"); // usunięcie tabeli <SUF>
String crestmt = "create table AUTOR (AUTID integer not null generated by default as identity, NAME varchar(255) not null, PRIMARY KEY(AUTID))";
try {
stmt.execute(crestmt);
} catch (SQLException exc) { // przechwycenie wyjątku:
System.out.println("SQL except.: " + exc.getMessage());
System.out.println("SQL state : " + exc.getSQLState());
System.out.println("Vendor errc: " + exc.getErrorCode());
System.exit(1);
} finally {
try {
stmt.close();
con.close();
} catch (SQLException exc) {
System.out.println(exc);
System.exit(1);
}
}
}
private void dropTable(String name){
try {
stmt.execute("DROP TABLE " + name);
} catch (SQLException exc) { // przechwycenie wyjątku:
System.out.println("SQL except.: " + exc.getMessage());
System.out.println("SQL state : " + exc.getSQLState());
System.out.println("Vendor errc: " + exc.getErrorCode());
System.exit(1);
}
}
} | f | null |
322 | 5220_11 | Rughalt/mini-objective-java | 915 | basic-arrays/src/mini/java/basic/arrays/MathVector.java | package mini.java.basic.arrays;
import java.util.Arrays;
public class MathVector {
/**
* Tablica licz reprezentująca wektor
*/
protected int[] i;
/**
* Zmienna reprezentująca informację czy wektor jest zrandomizowany
*/
protected boolean randomized = false;
/**
* Tworzy instancję obiektu MathVector z tablicy liczb.
* @implNote int... (zmienna liczba argumentów) jest innym sposobem zapisu int[] przy przekazywaniu jako parametr funkcji
* @param i Tablica liczb do utowrzenia obiektu
*/
public MathVector(int... i) {
this.i = i;
}
/**
* Prosty getter, zwraca tablicę i
* @return tablica liczb i
*/
public int[] getI() {
return i;
}
/**
* Prosty setter, ustawia wartość tablicy i (przypisuje zmiennej i przekazaną tablicę)
* @param i
*/
public void setI(int[] i) {
this.i = i;
}
/**
*
* @param o
* @return true jeżeli obiekty są identyczne, false jeżeli nie
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || !o.getClass().equals(this.getClass())) return false;
MathVector that = (MathVector) o;
return Arrays.equals(getI(), that.getI());
}
/**
* Wylicza hashcode dla obiektu
* @return hashcode
*/
@Override
public int hashCode() {
return Arrays.hashCode(getI());
}
/**
* Zwraca tekst będący reprezentacją obiektu
* @return tekst reprezentujący obiekt
*/
@Override
public String toString() {
return "MathVector{" +
"i=" + Arrays.toString(i) +
'}';
}
/**
* Zwraca nowy wektor będący iloczynem skalarnym tego wektora oraz liczby s
* @param s
* @return wektor
*/
public MathVector multiplyByScalar(int s) {
int[] j = new int[this.i.length];
for( int idx = 0; idx < this.i.length; idx++) {
j[idx] = this.i[idx] * s;
}
return new MathVector(j);
}
/**
* Zwraca długość tablicy i
* @return długość tablicy i
*/
public int getLength() {
return i.length;
}
/**
* Getter dla zmiennej randomized (mówiącej czy wektor jest losowy)
* @return
*/
public boolean isRandomized() {
return randomized;
}
/**
* Setter dla zmiennej randomized (mówiącej czy wektor jest losowy)
*/
public void setRandomized(boolean randomized) {
this.randomized = randomized;
}
/**
* Metoda zwracającz informację czy wektor jest zrandomizowany
* @return
*/
public boolean isRandomizedMethod() {
return false;
}
}
| /**
* Setter dla zmiennej randomized (mówiącej czy wektor jest losowy)
*/ | package mini.java.basic.arrays;
import java.util.Arrays;
public class MathVector {
/**
* Tablica licz reprezentująca wektor
*/
protected int[] i;
/**
* Zmienna reprezentująca informację czy wektor jest zrandomizowany
*/
protected boolean randomized = false;
/**
* Tworzy instancję obiektu MathVector z tablicy liczb.
* @implNote int... (zmienna liczba argumentów) jest innym sposobem zapisu int[] przy przekazywaniu jako parametr funkcji
* @param i Tablica liczb do utowrzenia obiektu
*/
public MathVector(int... i) {
this.i = i;
}
/**
* Prosty getter, zwraca tablicę i
* @return tablica liczb i
*/
public int[] getI() {
return i;
}
/**
* Prosty setter, ustawia wartość tablicy i (przypisuje zmiennej i przekazaną tablicę)
* @param i
*/
public void setI(int[] i) {
this.i = i;
}
/**
*
* @param o
* @return true jeżeli obiekty są identyczne, false jeżeli nie
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || !o.getClass().equals(this.getClass())) return false;
MathVector that = (MathVector) o;
return Arrays.equals(getI(), that.getI());
}
/**
* Wylicza hashcode dla obiektu
* @return hashcode
*/
@Override
public int hashCode() {
return Arrays.hashCode(getI());
}
/**
* Zwraca tekst będący reprezentacją obiektu
* @return tekst reprezentujący obiekt
*/
@Override
public String toString() {
return "MathVector{" +
"i=" + Arrays.toString(i) +
'}';
}
/**
* Zwraca nowy wektor będący iloczynem skalarnym tego wektora oraz liczby s
* @param s
* @return wektor
*/
public MathVector multiplyByScalar(int s) {
int[] j = new int[this.i.length];
for( int idx = 0; idx < this.i.length; idx++) {
j[idx] = this.i[idx] * s;
}
return new MathVector(j);
}
/**
* Zwraca długość tablicy i
* @return długość tablicy i
*/
public int getLength() {
return i.length;
}
/**
* Getter dla zmiennej randomized (mówiącej czy wektor jest losowy)
* @return
*/
public boolean isRandomized() {
return randomized;
}
/**
* Setter dla zmiennej <SUF>*/
public void setRandomized(boolean randomized) {
this.randomized = randomized;
}
/**
* Metoda zwracającz informację czy wektor jest zrandomizowany
* @return
*/
public boolean isRandomizedMethod() {
return false;
}
}
| f | null |
323 | 5955_1 | Rzeju/ZDJAVApol132_java_podstawy | 462 | src/standard_in_out/StdInOutExample.java | package standard_in_out;
import java.util.Scanner;
public class StdInOutExample {
public static void main(String[] args) {
//Utworzenie scanner czytającego dane wejściowe z konsoli
Scanner scanner = new Scanner(System.in);
//Wczytanie wartości z konosli jak String (kolejna linia)
//Pamiętaj aby wprowadzić coś w do konsoli
//Program czeka na wprowadzenie przez Ciebie danych
String nextLine = scanner.nextLine();
System.out.println(scanner);
System.out.println(nextLine);
//Wczytanie liczby z konsoli
//Pamiętaj aby wprowadzić coś w do konsoli
//Program czeka na wprowadzenie przez Ciebie danych
//Podanie innych danych niż liczby całkowitej spowoduje błąd
int nextInt = scanner.nextInt();
System.out.println(nextInt);
//Wczytanie liczby z konsoli
//Pamiętaj aby wprowadzić coś w do konsoli
//Program czeka na wprowadzenie przez Ciebie danych
//Podanie innych danych niż liczby zmiennoprzecinkowej spowoduje błąd
//(Użyj "," -> np. 4,32 lub 10,0
double nextDouble = scanner.nextDouble();
System.out.println(nextDouble);
//Wszytanie wartości logicznej
//Można wprowadzić jedynie 2 wartości true lub false
boolean nextBoolean = scanner.nextBoolean();
System.out.println(nextBoolean);
}
}
| //Wczytanie wartości z konosli jak String (kolejna linia) | package standard_in_out;
import java.util.Scanner;
public class StdInOutExample {
public static void main(String[] args) {
//Utworzenie scanner czytającego dane wejściowe z konsoli
Scanner scanner = new Scanner(System.in);
//Wczytanie wartości <SUF>
//Pamiętaj aby wprowadzić coś w do konsoli
//Program czeka na wprowadzenie przez Ciebie danych
String nextLine = scanner.nextLine();
System.out.println(scanner);
System.out.println(nextLine);
//Wczytanie liczby z konsoli
//Pamiętaj aby wprowadzić coś w do konsoli
//Program czeka na wprowadzenie przez Ciebie danych
//Podanie innych danych niż liczby całkowitej spowoduje błąd
int nextInt = scanner.nextInt();
System.out.println(nextInt);
//Wczytanie liczby z konsoli
//Pamiętaj aby wprowadzić coś w do konsoli
//Program czeka na wprowadzenie przez Ciebie danych
//Podanie innych danych niż liczby zmiennoprzecinkowej spowoduje błąd
//(Użyj "," -> np. 4,32 lub 10,0
double nextDouble = scanner.nextDouble();
System.out.println(nextDouble);
//Wszytanie wartości logicznej
//Można wprowadzić jedynie 2 wartości true lub false
boolean nextBoolean = scanner.nextBoolean();
System.out.println(nextBoolean);
}
}
| f | null |
325 | 5270_0 | S-Maciejewski/SymulatorGieldy | 488 | src/Model/Aktywa.java | package Model;
import java.io.Serializable;
import java.util.ArrayList;
/**
* Klasa, w której zgromazone są wszystkie aktywa obecne na rynku
*/
public class Aktywa implements Serializable{
private ArrayList<Spolka> spolki = new ArrayList<>();
private ArrayList<Surowiec> surowce = new ArrayList<>();
private ArrayList<Waluta> waluty = new ArrayList<>();
private ArrayList<Fundusz> funduszeInwestycyjne = new ArrayList<>();
public ArrayList<Waluta> getWaluty() {
return waluty;
}
public void dodajWalute(Waluta waluta) {
waluty.add(waluta);
}
public ArrayList<Surowiec> getSurowce() {
return surowce;
}
public void dodajSurowiec(Surowiec surowiec) {
surowce.add(surowiec);
}
public ArrayList<Spolka> getSpolki() {
return spolki;
}
public void dodajSpolke(Spolka spolka) {
spolki.add(spolka);
}
public ArrayList<Fundusz> getFunduszeInwestycyjne() {
return funduszeInwestycyjne;
}
public void dodajFundusz(Fundusz fundusz) {
funduszeInwestycyjne.add(fundusz);
}
public void removeSpolka(Spolka spolka) {
spolki.remove(spolka);
}
public void removeWaluta(Waluta waluta) {
waluty.remove(waluta);
}
public void removeSurowiec(Surowiec surowiec){
surowce.remove(surowiec);
}
}
| /**
* Klasa, w której zgromazone są wszystkie aktywa obecne na rynku
*/ | package Model;
import java.io.Serializable;
import java.util.ArrayList;
/**
* Klasa, w której <SUF>*/
public class Aktywa implements Serializable{
private ArrayList<Spolka> spolki = new ArrayList<>();
private ArrayList<Surowiec> surowce = new ArrayList<>();
private ArrayList<Waluta> waluty = new ArrayList<>();
private ArrayList<Fundusz> funduszeInwestycyjne = new ArrayList<>();
public ArrayList<Waluta> getWaluty() {
return waluty;
}
public void dodajWalute(Waluta waluta) {
waluty.add(waluta);
}
public ArrayList<Surowiec> getSurowce() {
return surowce;
}
public void dodajSurowiec(Surowiec surowiec) {
surowce.add(surowiec);
}
public ArrayList<Spolka> getSpolki() {
return spolki;
}
public void dodajSpolke(Spolka spolka) {
spolki.add(spolka);
}
public ArrayList<Fundusz> getFunduszeInwestycyjne() {
return funduszeInwestycyjne;
}
public void dodajFundusz(Fundusz fundusz) {
funduszeInwestycyjne.add(fundusz);
}
public void removeSpolka(Spolka spolka) {
spolki.remove(spolka);
}
public void removeWaluta(Waluta waluta) {
waluty.remove(waluta);
}
public void removeSurowiec(Surowiec surowiec){
surowce.remove(surowiec);
}
}
| f | null |
327 | 6968_3 | SP8EBC/MKS_JG | 7,025 | src/pl/jeleniagora/mks/gui/CompManagerWindowEditCompetition.java | package pl.jeleniagora.mks.gui;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import net.miginfocom.swing.MigLayout;
import pl.jeleniagora.mks.exceptions.UninitializedCompEx;
import pl.jeleniagora.mks.rte.RTE_GUI;
import pl.jeleniagora.mks.rte.RTE_ST;
import pl.jeleniagora.mks.start.order.FilOrder;
import pl.jeleniagora.mks.start.order.SimpleOrder;
import pl.jeleniagora.mks.start.order.StartOrderInterface;
import pl.jeleniagora.mks.types.Competition;
import pl.jeleniagora.mks.types.Competitions;
import pl.jeleniagora.mks.types.LugerCompetitor;
import pl.jeleniagora.mks.types.Reserve;
import pl.jeleniagora.mks.types.Run;
import javax.swing.JComboBox;
import javax.swing.ButtonGroup;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Alignment;
import javax.swing.LayoutStyle.ComponentPlacement;
import javax.swing.border.LineBorder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import java.awt.Color;
import javax.swing.JTextField;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.LocalTime;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Vector;
import javax.swing.JRadioButton;
import javax.swing.JSpinner;
import javax.swing.JButton;
import javax.swing.SpinnerNumberModel;
@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class CompManagerWindowEditCompetition extends JFrame {
/**
*
*/
private static final long serialVersionUID = -7099964404892224928L;
private JPanel contentPane;
private JTextField textFieldName;
@Autowired
RTE_GUI rte_gui;
@Autowired
RTE_ST rte_st;
CompManagerWindowEditCompetition window;
StartOrderInterface choosenStartOrder;
JComboBox<Competition> comboBoxCompetition;
Competition chosenCompetition;
/**
* Ilość ślizgów treningowych dla konkurencji wybranej z listy rozwijanej
*/
int trainingRunsForChosen;
/**
* Ilość ślizgów punktwanych dla konkurencji wybraej z listy rozwijanej
*/
int scoredRunsForChosen;
/**
* Indek ostatniego ślizgu treningowego w konkurencji
*/
int indexOfLastTrainingRun;
Run lastTrainingRun;
/**
* Indeks pierwszego punktowanego ślizgu w wektorze Run
*/
int indexOfFirstScored;
Run firstScored;
/**
* Nazwa konkurencji wybranej z listy rozwijanej
*/
String nameForChoosen;
/**
* Spinner do zmiany ilości ślizgów treningowych
*/
JSpinner spinnerTrainingRuns;
/**
* Spinner do zmiany ilości ślizgów punktowanych
*/
JSpinner spinnerScoredRuns;
JRadioButton rdbtnUproszczonaWg;
JRadioButton rdbtnZgodnaZRegulamnem;
JComboBox<String> comboBox;
public void updateContent(Competitions competitions) {
if (competitions.competitions.size() == 0)
return;
comboBoxCompetition.removeAllItems();
// dodawanie od nowa wszystkich aktualnie zdefiniowanych
for (Competition c : competitions.competitions) {
comboBoxCompetition.addItem(c);
}
comboBoxCompetition.setSelectedItem(competitions.competitions.get(0));
}
private void updateContent(Competition competition) {
nameForChoosen = competition.name;
trainingRunsForChosen = competition.numberOfTrainingRuns;
scoredRunsForChosen = competition.numberOfAllRuns - trainingRunsForChosen;
for (Run r : competition.runsTimes) {
// pętla chodzi po wszystkich ślizgach - zjazdach w tej konkurencji
if (!r.trainingOrScored) {
// co do zasady ślizgi są posortowane w kolejności najpierw treingowe
// potem punktowane. Dlatego ostatni ślizg, który zostanie tutaj
indexOfLastTrainingRun = competition.runsTimes.indexOf(r);
lastTrainingRun = r;
}
}
indexOfFirstScored = indexOfLastTrainingRun + 1;
firstScored = competition.runsTimes.elementAt(indexOfFirstScored);
spinnerTrainingRuns.setValue(trainingRunsForChosen);
spinnerScoredRuns.setValue(scoredRunsForChosen);
textFieldName.setText(nameForChoosen);
if (competition.trainingOrContest) {
// jeżeli ustawiono konkurencję jako konkurencje w zawodach
comboBox.setSelectedItem("Zawody - tylko po punktowanych");
}
else {
// jeżeli ustawiono jako trening
comboBox.setSelectedItem("Trening - po każdym ślizgu");
}
if (competition.startOrder instanceof SimpleOrder) {
rdbtnUproszczonaWg.setSelected(true);
rdbtnZgodnaZRegulamnem.setSelected(false);
}
else if (competition.startOrder instanceof FilOrder) {
rdbtnZgodnaZRegulamnem.setSelected(true);
rdbtnUproszczonaWg.setSelected(false);
}
}
/**
* Create the frame.
*/
public CompManagerWindowEditCompetition() {
this.window = this;
setResizable(false);
setTitle("Edytuj parametry konkurencji");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setBounds(100, 100, 574, 345);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
JLabel lblWybierzKonkurencjDo = new JLabel("Wybierz konkurencję do edycji:");
comboBoxCompetition = new JComboBox<Competition>();
comboBoxCompetition.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
Object actionSource = arg0.getSource();
@SuppressWarnings("unchecked")
JComboBox<Competition> castedSource = (JComboBox<Competition>)actionSource;
chosenCompetition = (Competition)castedSource.getSelectedItem();
updateContent(chosenCompetition);
}
});
JPanel competitionParametersPanel = new JPanel();
competitionParametersPanel.setBorder(new LineBorder(new Color(0, 0, 0), 1, true));
GroupLayout gl_contentPane = new GroupLayout(contentPane);
gl_contentPane.setHorizontalGroup(
gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addComponent(lblWybierzKonkurencjDo, GroupLayout.PREFERRED_SIZE, 221, GroupLayout.PREFERRED_SIZE)
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(comboBoxCompetition, 0, 288, Short.MAX_VALUE))
.addComponent(competitionParametersPanel, GroupLayout.DEFAULT_SIZE, 521, Short.MAX_VALUE)
);
gl_contentPane.setVerticalGroup(
gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addGroup(gl_contentPane.createParallelGroup(Alignment.BASELINE)
.addComponent(lblWybierzKonkurencjDo)
.addComponent(comboBoxCompetition, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(competitionParametersPanel, GroupLayout.DEFAULT_SIZE, 228, Short.MAX_VALUE))
);
competitionParametersPanel.setLayout(new MigLayout("", "[][grow][grow][][][][][][3.00][]", "[][][][][][][][]"));
JLabel lblNazwaKonkurencji = new JLabel("Nazwa konkurencji:");
competitionParametersPanel.add(lblNazwaKonkurencji, "cell 0 0,alignx trailing");
textFieldName = new JTextField();
textFieldName.setFont(new Font("Dialog", Font.PLAIN, 16));
competitionParametersPanel.add(textFieldName, "cell 1 0 8 1,grow");
textFieldName.setColumns(10);
JLabel lblKolejnoStartowa = new JLabel("Kolejność startowa:");
competitionParametersPanel.add(lblKolejnoStartowa, "cell 0 1");
ButtonGroup startOrderGroup = new ButtonGroup();
rdbtnUproszczonaWg = new JRadioButton("Uproszczona - wg numerów startowych rosnąco");
competitionParametersPanel.add(rdbtnUproszczonaWg, "cell 1 1 8 1");
rdbtnZgodnaZRegulamnem = new JRadioButton("Zgodna z regulamnem sportowym FIL");
competitionParametersPanel.add(rdbtnZgodnaZRegulamnem, "cell 1 2 8 1");
startOrderGroup.add(rdbtnZgodnaZRegulamnem);
startOrderGroup.add(rdbtnUproszczonaWg);
JLabel lblUwagaZmianaKolejoci = new JLabel("<html><p align='center'>Uwaga! Zmiana kolejości startowej zostanie wprowadzona dopiero po zakończeniu aktualnego ślizgu!</p></html>");
lblUwagaZmianaKolejoci.setForeground(Color.RED);
competitionParametersPanel.add(lblUwagaZmianaKolejoci, "cell 0 3 9 1");
JLabel lblZmieIlolizgw = new JLabel("Ilość ślizgów w konkurencji:");
competitionParametersPanel.add(lblZmieIlolizgw, "cell 0 4 2 1");
JLabel lblTreningowe = new JLabel("Treningowe");
competitionParametersPanel.add(lblTreningowe, "cell 3 4");
spinnerTrainingRuns = new JSpinner();
spinnerTrainingRuns.setModel(new SpinnerNumberModel(0, 0, 9, 1));
competitionParametersPanel.add(spinnerTrainingRuns, "cell 4 4");
JLabel lblPunktowane = new JLabel("Punktowane");
competitionParametersPanel.add(lblPunktowane, "cell 6 4");
spinnerScoredRuns = new JSpinner();
spinnerScoredRuns.setModel(new SpinnerNumberModel(1, 1, 9, 1));
competitionParametersPanel.add(spinnerScoredRuns, "cell 7 4");
JLabel lbluwagaZmniejszenieLiczby = new JLabel("<html><p align='center'>Uwaga! Zmniejszenie liczby ślizgów i zatwierdzenie zmian spowoduje bezpowrotne usunięcie części czasów.</p></html>");
lbluwagaZmniejszenieLiczby.setForeground(Color.RED);
competitionParametersPanel.add(lbluwagaZmniejszenieLiczby, "cell 0 5 9 1");
JButton btnZapiszIZamknij = new JButton("Zapisz i zamknij");
btnZapiszIZamknij.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
short j = 0;
short k = 0;
if (comboBox.getSelectedItem().equals("Zawody - tylko po punktowanych")) {
chosenCompetition.trainingOrContest = true;
}
else if (comboBox.getSelectedItem().equals("Trening - po każdym ślizgu")) {
chosenCompetition.trainingOrContest = false;
}
else;
if (textFieldName.getText().length() > 0) {
chosenCompetition.name = textFieldName.getText();
}
else {
chosenCompetition.name = chosenCompetition.toString();
}
// sprawdzanie czy użytkownik nie próbuje zmniejszyć ilości ślizgów
if( (int)spinnerScoredRuns.getValue() < scoredRunsForChosen ||
(int)spinnerTrainingRuns.getValue() < trainingRunsForChosen) {
Competition c = chosenCompetition;
int answer = JOptionPane.showConfirmDialog(window, "Czy na pewno chcesz zmniejszyć liczbę ślizgów i usunąć część czasów?", "Pozor!", JOptionPane.YES_NO_OPTION);
if (answer == JOptionPane.YES_OPTION) {
//zmniejszanie ilości ślizgów przez usunięcie ostatnich ślizgów odpowiednio treningowych a potem punktowanych;
// indeks pierwszego ślizgu treningowego do usunięcia
int firstTrainingToRemove = trainingRunsForChosen - (trainingRunsForChosen - (int)spinnerTrainingRuns.getValue());
// sprawdzenie czy w ogóle należy usuwać jakiekolwiek treningowe (może chcieć tylko punktowane)
if (firstTrainingToRemove < trainingRunsForChosen) {
// usuwanie ślizgów treningowych
for (int i = firstTrainingToRemove; i <= indexOfLastTrainingRun; i++) {
c.runsTimes.remove(i);
}
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : c.runsTimes) {
r.number = j++;
r.numberInScoredOrTrainingRuns = k++;
}
trainingRunsForChosen = (int)spinnerTrainingRuns.getValue(); // numberOfTrainingsRuns
c.numberOfTrainingRuns = trainingRunsForChosen;
c.numberOfAllRuns = trainingRunsForChosen + scoredRunsForChosen;
}
// powtórne odszukiwanie indeksów ostatniego treningowego i pierwszego punktowanego
// gdyż operacja usuwania z wektora powoduje przesuwanie następnych elementów w lewo
for (Run r : c.runsTimes) {
// pętla chodzi po wszystkich ślizgach - zjazdach w tej konkurencji
if (!r.trainingOrScored) {
// co do zasady ślizgi są posortowane w kolejności najpierw treingowe
// potem punktowane. Dlatego ostatni ślizg, który zostanie tutaj
indexOfLastTrainingRun = chosenCompetition.runsTimes.indexOf(r);
lastTrainingRun = r;
}
}
indexOfFirstScored = indexOfLastTrainingRun + 1;
firstScored = chosenCompetition.runsTimes.elementAt(indexOfFirstScored);
// wyciąganie aktualnej liczby wszystkich ślizgów/zjazdów
int runsCount = c.runsTimes.size();
// znajdywanie pierwszego indeksu ślizgu punktowanego do usunięcia (punktowane są zawsze po treningach)
int firstScoredToRemove = runsCount - (scoredRunsForChosen - (int)spinnerScoredRuns.getValue());
if (firstScoredToRemove < runsCount) {
for (int i = firstScoredToRemove; i < runsCount; i++) {
c.runsTimes.remove(i);
}
j = 0;
k = 0;
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : c.runsTimes) {
r.number = j++;
r.numberInScoredOrTrainingRuns = k++;
}
scoredRunsForChosen = (int)spinnerScoredRuns.getValue();
chosenCompetition.numberOfAllRuns = trainingRunsForChosen + scoredRunsForChosen;
}
}
if (answer == JOptionPane.NO_OPTION) {
;
}
}
// sprawdzanie czy użytkownik nie chcę dodać nowych ślizgów / zjazdów do konkurencji
else if ((int)spinnerScoredRuns.getValue() > scoredRunsForChosen ||
(int)spinnerTrainingRuns.getValue() > trainingRunsForChosen)
{
int scoredToAdd = (int)spinnerScoredRuns.getValue() - scoredRunsForChosen;
int trainingToAdd = (int)spinnerTrainingRuns.getValue() - trainingRunsForChosen;
// tworzenie wektora z saneczkarzami z tej konkurencji na podstawie listy czasów
// z innego ślizgu z tej konkurencji
Set<Entry<LugerCompetitor, LocalTime>> set = firstScored.totalTimes.entrySet();
// wektor na saneczkarzy do dodania do kolejnego ślizgu
Vector<LugerCompetitor> cmptr = new Vector<LugerCompetitor>();
for (Entry<LugerCompetitor, LocalTime> elem : set) {
LugerCompetitor key = elem.getKey();
cmptr.addElement(key);
}
// sprawdzanie czy trzeba dodać jakiś ślizg punktowany
if (scoredToAdd > 0) {
// jeżeli trzeba dodać to trzeba go dodać na samym końcu
for (int i = 0; i < scoredToAdd; i++) {
Run toAdd = new Run(cmptr, (byte)1);
chosenCompetition.runsTimes.add(toAdd);
chosenCompetition.numberOfAllRuns++;
}
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : chosenCompetition.runsTimes) {
r.number = j++;
}
}
if (trainingToAdd > 0) {
for (int i = 0; i < trainingToAdd; i++) {
// każdy ślizg treningowy powinien zostać dodany po ostatnim treningowym
Run toAdd = new Run(cmptr, (byte)0);
chosenCompetition.runsTimes.add(i + trainingRunsForChosen, toAdd);
chosenCompetition.numberOfAllRuns++;
chosenCompetition.numberOfTrainingRuns++;
}
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : chosenCompetition.runsTimes) {
r.number = j++;
}
}
}
else;
if (rte_gui.competitionBeingShown.equals(rte_st.currentCompetition)) {
try {
rte_gui.compManagerScoreModel.updateTableData(chosenCompetition, false);
rte_gui.compManagerScoreModel.updateTableHeading(chosenCompetition, false);
} catch (UninitializedCompEx | Reserve e1) {
e1.printStackTrace();
}
rte_gui.compManagerScoreModel.fireTableStructureChanged();
rte_gui.compManagerScoreModel.fireTableDataChanged();
}
window.dispose();
}
});
comboBox = new JComboBox<String>();
competitionParametersPanel.add(comboBox, "cell 2 6 6 1,growx");
competitionParametersPanel.add(btnZapiszIZamknij, "cell 0 7 3 1,growx");
comboBox.addItem("Trening - po każdym ślizgu");
comboBox.addItem("Zawody - tylko po punktowanych");
JButton btnWyjdBezZapisu = new JButton("Wyjdź bez zapisu");
btnWyjdBezZapisu.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
window.dispose();
}
});
competitionParametersPanel.add(btnWyjdBezZapisu, "cell 4 7 6 1,growx");
JLabel lblSposbObliczaniaLokat = new JLabel("<html><p align='center'>Sposób obliczania lokat:</p></html>");
competitionParametersPanel.add(lblSposbObliczaniaLokat, "cell 0 6 2 1");
contentPane.setLayout(gl_contentPane);
}
}
| /**
* Indeks pierwszego punktowanego ślizgu w wektorze Run
*/ | package pl.jeleniagora.mks.gui;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import net.miginfocom.swing.MigLayout;
import pl.jeleniagora.mks.exceptions.UninitializedCompEx;
import pl.jeleniagora.mks.rte.RTE_GUI;
import pl.jeleniagora.mks.rte.RTE_ST;
import pl.jeleniagora.mks.start.order.FilOrder;
import pl.jeleniagora.mks.start.order.SimpleOrder;
import pl.jeleniagora.mks.start.order.StartOrderInterface;
import pl.jeleniagora.mks.types.Competition;
import pl.jeleniagora.mks.types.Competitions;
import pl.jeleniagora.mks.types.LugerCompetitor;
import pl.jeleniagora.mks.types.Reserve;
import pl.jeleniagora.mks.types.Run;
import javax.swing.JComboBox;
import javax.swing.ButtonGroup;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Alignment;
import javax.swing.LayoutStyle.ComponentPlacement;
import javax.swing.border.LineBorder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import java.awt.Color;
import javax.swing.JTextField;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.LocalTime;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Vector;
import javax.swing.JRadioButton;
import javax.swing.JSpinner;
import javax.swing.JButton;
import javax.swing.SpinnerNumberModel;
@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class CompManagerWindowEditCompetition extends JFrame {
/**
*
*/
private static final long serialVersionUID = -7099964404892224928L;
private JPanel contentPane;
private JTextField textFieldName;
@Autowired
RTE_GUI rte_gui;
@Autowired
RTE_ST rte_st;
CompManagerWindowEditCompetition window;
StartOrderInterface choosenStartOrder;
JComboBox<Competition> comboBoxCompetition;
Competition chosenCompetition;
/**
* Ilość ślizgów treningowych dla konkurencji wybranej z listy rozwijanej
*/
int trainingRunsForChosen;
/**
* Ilość ślizgów punktwanych dla konkurencji wybraej z listy rozwijanej
*/
int scoredRunsForChosen;
/**
* Indek ostatniego ślizgu treningowego w konkurencji
*/
int indexOfLastTrainingRun;
Run lastTrainingRun;
/**
* Indeks pierwszego punktowanego <SUF>*/
int indexOfFirstScored;
Run firstScored;
/**
* Nazwa konkurencji wybranej z listy rozwijanej
*/
String nameForChoosen;
/**
* Spinner do zmiany ilości ślizgów treningowych
*/
JSpinner spinnerTrainingRuns;
/**
* Spinner do zmiany ilości ślizgów punktowanych
*/
JSpinner spinnerScoredRuns;
JRadioButton rdbtnUproszczonaWg;
JRadioButton rdbtnZgodnaZRegulamnem;
JComboBox<String> comboBox;
public void updateContent(Competitions competitions) {
if (competitions.competitions.size() == 0)
return;
comboBoxCompetition.removeAllItems();
// dodawanie od nowa wszystkich aktualnie zdefiniowanych
for (Competition c : competitions.competitions) {
comboBoxCompetition.addItem(c);
}
comboBoxCompetition.setSelectedItem(competitions.competitions.get(0));
}
private void updateContent(Competition competition) {
nameForChoosen = competition.name;
trainingRunsForChosen = competition.numberOfTrainingRuns;
scoredRunsForChosen = competition.numberOfAllRuns - trainingRunsForChosen;
for (Run r : competition.runsTimes) {
// pętla chodzi po wszystkich ślizgach - zjazdach w tej konkurencji
if (!r.trainingOrScored) {
// co do zasady ślizgi są posortowane w kolejności najpierw treingowe
// potem punktowane. Dlatego ostatni ślizg, który zostanie tutaj
indexOfLastTrainingRun = competition.runsTimes.indexOf(r);
lastTrainingRun = r;
}
}
indexOfFirstScored = indexOfLastTrainingRun + 1;
firstScored = competition.runsTimes.elementAt(indexOfFirstScored);
spinnerTrainingRuns.setValue(trainingRunsForChosen);
spinnerScoredRuns.setValue(scoredRunsForChosen);
textFieldName.setText(nameForChoosen);
if (competition.trainingOrContest) {
// jeżeli ustawiono konkurencję jako konkurencje w zawodach
comboBox.setSelectedItem("Zawody - tylko po punktowanych");
}
else {
// jeżeli ustawiono jako trening
comboBox.setSelectedItem("Trening - po każdym ślizgu");
}
if (competition.startOrder instanceof SimpleOrder) {
rdbtnUproszczonaWg.setSelected(true);
rdbtnZgodnaZRegulamnem.setSelected(false);
}
else if (competition.startOrder instanceof FilOrder) {
rdbtnZgodnaZRegulamnem.setSelected(true);
rdbtnUproszczonaWg.setSelected(false);
}
}
/**
* Create the frame.
*/
public CompManagerWindowEditCompetition() {
this.window = this;
setResizable(false);
setTitle("Edytuj parametry konkurencji");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
setBounds(100, 100, 574, 345);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
JLabel lblWybierzKonkurencjDo = new JLabel("Wybierz konkurencję do edycji:");
comboBoxCompetition = new JComboBox<Competition>();
comboBoxCompetition.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
Object actionSource = arg0.getSource();
@SuppressWarnings("unchecked")
JComboBox<Competition> castedSource = (JComboBox<Competition>)actionSource;
chosenCompetition = (Competition)castedSource.getSelectedItem();
updateContent(chosenCompetition);
}
});
JPanel competitionParametersPanel = new JPanel();
competitionParametersPanel.setBorder(new LineBorder(new Color(0, 0, 0), 1, true));
GroupLayout gl_contentPane = new GroupLayout(contentPane);
gl_contentPane.setHorizontalGroup(
gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addComponent(lblWybierzKonkurencjDo, GroupLayout.PREFERRED_SIZE, 221, GroupLayout.PREFERRED_SIZE)
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(comboBoxCompetition, 0, 288, Short.MAX_VALUE))
.addComponent(competitionParametersPanel, GroupLayout.DEFAULT_SIZE, 521, Short.MAX_VALUE)
);
gl_contentPane.setVerticalGroup(
gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addGroup(gl_contentPane.createParallelGroup(Alignment.BASELINE)
.addComponent(lblWybierzKonkurencjDo)
.addComponent(comboBoxCompetition, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(competitionParametersPanel, GroupLayout.DEFAULT_SIZE, 228, Short.MAX_VALUE))
);
competitionParametersPanel.setLayout(new MigLayout("", "[][grow][grow][][][][][][3.00][]", "[][][][][][][][]"));
JLabel lblNazwaKonkurencji = new JLabel("Nazwa konkurencji:");
competitionParametersPanel.add(lblNazwaKonkurencji, "cell 0 0,alignx trailing");
textFieldName = new JTextField();
textFieldName.setFont(new Font("Dialog", Font.PLAIN, 16));
competitionParametersPanel.add(textFieldName, "cell 1 0 8 1,grow");
textFieldName.setColumns(10);
JLabel lblKolejnoStartowa = new JLabel("Kolejność startowa:");
competitionParametersPanel.add(lblKolejnoStartowa, "cell 0 1");
ButtonGroup startOrderGroup = new ButtonGroup();
rdbtnUproszczonaWg = new JRadioButton("Uproszczona - wg numerów startowych rosnąco");
competitionParametersPanel.add(rdbtnUproszczonaWg, "cell 1 1 8 1");
rdbtnZgodnaZRegulamnem = new JRadioButton("Zgodna z regulamnem sportowym FIL");
competitionParametersPanel.add(rdbtnZgodnaZRegulamnem, "cell 1 2 8 1");
startOrderGroup.add(rdbtnZgodnaZRegulamnem);
startOrderGroup.add(rdbtnUproszczonaWg);
JLabel lblUwagaZmianaKolejoci = new JLabel("<html><p align='center'>Uwaga! Zmiana kolejości startowej zostanie wprowadzona dopiero po zakończeniu aktualnego ślizgu!</p></html>");
lblUwagaZmianaKolejoci.setForeground(Color.RED);
competitionParametersPanel.add(lblUwagaZmianaKolejoci, "cell 0 3 9 1");
JLabel lblZmieIlolizgw = new JLabel("Ilość ślizgów w konkurencji:");
competitionParametersPanel.add(lblZmieIlolizgw, "cell 0 4 2 1");
JLabel lblTreningowe = new JLabel("Treningowe");
competitionParametersPanel.add(lblTreningowe, "cell 3 4");
spinnerTrainingRuns = new JSpinner();
spinnerTrainingRuns.setModel(new SpinnerNumberModel(0, 0, 9, 1));
competitionParametersPanel.add(spinnerTrainingRuns, "cell 4 4");
JLabel lblPunktowane = new JLabel("Punktowane");
competitionParametersPanel.add(lblPunktowane, "cell 6 4");
spinnerScoredRuns = new JSpinner();
spinnerScoredRuns.setModel(new SpinnerNumberModel(1, 1, 9, 1));
competitionParametersPanel.add(spinnerScoredRuns, "cell 7 4");
JLabel lbluwagaZmniejszenieLiczby = new JLabel("<html><p align='center'>Uwaga! Zmniejszenie liczby ślizgów i zatwierdzenie zmian spowoduje bezpowrotne usunięcie części czasów.</p></html>");
lbluwagaZmniejszenieLiczby.setForeground(Color.RED);
competitionParametersPanel.add(lbluwagaZmniejszenieLiczby, "cell 0 5 9 1");
JButton btnZapiszIZamknij = new JButton("Zapisz i zamknij");
btnZapiszIZamknij.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
short j = 0;
short k = 0;
if (comboBox.getSelectedItem().equals("Zawody - tylko po punktowanych")) {
chosenCompetition.trainingOrContest = true;
}
else if (comboBox.getSelectedItem().equals("Trening - po każdym ślizgu")) {
chosenCompetition.trainingOrContest = false;
}
else;
if (textFieldName.getText().length() > 0) {
chosenCompetition.name = textFieldName.getText();
}
else {
chosenCompetition.name = chosenCompetition.toString();
}
// sprawdzanie czy użytkownik nie próbuje zmniejszyć ilości ślizgów
if( (int)spinnerScoredRuns.getValue() < scoredRunsForChosen ||
(int)spinnerTrainingRuns.getValue() < trainingRunsForChosen) {
Competition c = chosenCompetition;
int answer = JOptionPane.showConfirmDialog(window, "Czy na pewno chcesz zmniejszyć liczbę ślizgów i usunąć część czasów?", "Pozor!", JOptionPane.YES_NO_OPTION);
if (answer == JOptionPane.YES_OPTION) {
//zmniejszanie ilości ślizgów przez usunięcie ostatnich ślizgów odpowiednio treningowych a potem punktowanych;
// indeks pierwszego ślizgu treningowego do usunięcia
int firstTrainingToRemove = trainingRunsForChosen - (trainingRunsForChosen - (int)spinnerTrainingRuns.getValue());
// sprawdzenie czy w ogóle należy usuwać jakiekolwiek treningowe (może chcieć tylko punktowane)
if (firstTrainingToRemove < trainingRunsForChosen) {
// usuwanie ślizgów treningowych
for (int i = firstTrainingToRemove; i <= indexOfLastTrainingRun; i++) {
c.runsTimes.remove(i);
}
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : c.runsTimes) {
r.number = j++;
r.numberInScoredOrTrainingRuns = k++;
}
trainingRunsForChosen = (int)spinnerTrainingRuns.getValue(); // numberOfTrainingsRuns
c.numberOfTrainingRuns = trainingRunsForChosen;
c.numberOfAllRuns = trainingRunsForChosen + scoredRunsForChosen;
}
// powtórne odszukiwanie indeksów ostatniego treningowego i pierwszego punktowanego
// gdyż operacja usuwania z wektora powoduje przesuwanie następnych elementów w lewo
for (Run r : c.runsTimes) {
// pętla chodzi po wszystkich ślizgach - zjazdach w tej konkurencji
if (!r.trainingOrScored) {
// co do zasady ślizgi są posortowane w kolejności najpierw treingowe
// potem punktowane. Dlatego ostatni ślizg, który zostanie tutaj
indexOfLastTrainingRun = chosenCompetition.runsTimes.indexOf(r);
lastTrainingRun = r;
}
}
indexOfFirstScored = indexOfLastTrainingRun + 1;
firstScored = chosenCompetition.runsTimes.elementAt(indexOfFirstScored);
// wyciąganie aktualnej liczby wszystkich ślizgów/zjazdów
int runsCount = c.runsTimes.size();
// znajdywanie pierwszego indeksu ślizgu punktowanego do usunięcia (punktowane są zawsze po treningach)
int firstScoredToRemove = runsCount - (scoredRunsForChosen - (int)spinnerScoredRuns.getValue());
if (firstScoredToRemove < runsCount) {
for (int i = firstScoredToRemove; i < runsCount; i++) {
c.runsTimes.remove(i);
}
j = 0;
k = 0;
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : c.runsTimes) {
r.number = j++;
r.numberInScoredOrTrainingRuns = k++;
}
scoredRunsForChosen = (int)spinnerScoredRuns.getValue();
chosenCompetition.numberOfAllRuns = trainingRunsForChosen + scoredRunsForChosen;
}
}
if (answer == JOptionPane.NO_OPTION) {
;
}
}
// sprawdzanie czy użytkownik nie chcę dodać nowych ślizgów / zjazdów do konkurencji
else if ((int)spinnerScoredRuns.getValue() > scoredRunsForChosen ||
(int)spinnerTrainingRuns.getValue() > trainingRunsForChosen)
{
int scoredToAdd = (int)spinnerScoredRuns.getValue() - scoredRunsForChosen;
int trainingToAdd = (int)spinnerTrainingRuns.getValue() - trainingRunsForChosen;
// tworzenie wektora z saneczkarzami z tej konkurencji na podstawie listy czasów
// z innego ślizgu z tej konkurencji
Set<Entry<LugerCompetitor, LocalTime>> set = firstScored.totalTimes.entrySet();
// wektor na saneczkarzy do dodania do kolejnego ślizgu
Vector<LugerCompetitor> cmptr = new Vector<LugerCompetitor>();
for (Entry<LugerCompetitor, LocalTime> elem : set) {
LugerCompetitor key = elem.getKey();
cmptr.addElement(key);
}
// sprawdzanie czy trzeba dodać jakiś ślizg punktowany
if (scoredToAdd > 0) {
// jeżeli trzeba dodać to trzeba go dodać na samym końcu
for (int i = 0; i < scoredToAdd; i++) {
Run toAdd = new Run(cmptr, (byte)1);
chosenCompetition.runsTimes.add(toAdd);
chosenCompetition.numberOfAllRuns++;
}
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : chosenCompetition.runsTimes) {
r.number = j++;
}
}
if (trainingToAdd > 0) {
for (int i = 0; i < trainingToAdd; i++) {
// każdy ślizg treningowy powinien zostać dodany po ostatnim treningowym
Run toAdd = new Run(cmptr, (byte)0);
chosenCompetition.runsTimes.add(i + trainingRunsForChosen, toAdd);
chosenCompetition.numberOfAllRuns++;
chosenCompetition.numberOfTrainingRuns++;
}
// poprawianie numerów kolejnych ślizgów tj pola Run.number
for (Run r : chosenCompetition.runsTimes) {
r.number = j++;
}
}
}
else;
if (rte_gui.competitionBeingShown.equals(rte_st.currentCompetition)) {
try {
rte_gui.compManagerScoreModel.updateTableData(chosenCompetition, false);
rte_gui.compManagerScoreModel.updateTableHeading(chosenCompetition, false);
} catch (UninitializedCompEx | Reserve e1) {
e1.printStackTrace();
}
rte_gui.compManagerScoreModel.fireTableStructureChanged();
rte_gui.compManagerScoreModel.fireTableDataChanged();
}
window.dispose();
}
});
comboBox = new JComboBox<String>();
competitionParametersPanel.add(comboBox, "cell 2 6 6 1,growx");
competitionParametersPanel.add(btnZapiszIZamknij, "cell 0 7 3 1,growx");
comboBox.addItem("Trening - po każdym ślizgu");
comboBox.addItem("Zawody - tylko po punktowanych");
JButton btnWyjdBezZapisu = new JButton("Wyjdź bez zapisu");
btnWyjdBezZapisu.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
window.dispose();
}
});
competitionParametersPanel.add(btnWyjdBezZapisu, "cell 4 7 6 1,growx");
JLabel lblSposbObliczaniaLokat = new JLabel("<html><p align='center'>Sposób obliczania lokat:</p></html>");
competitionParametersPanel.add(lblSposbObliczaniaLokat, "cell 0 6 2 1");
contentPane.setLayout(gl_contentPane);
}
}
| f | null |
328 | 10289_0 | Sahyas/zad3 | 492 | src/main/java/pl/lodz/p/it/isrp/SortTabNumbers.java | package pl.lodz.p.it.isrp;
import java.util.Arrays;
/**
* Uwaga: Klasa zawiera błędy, które trzeba zidentyfikować i usunąć z
* zastosowaniem trybu debug (nadzorowane wykonanie z wykorzystanie debuggera), tak by
* tablica była inicjowana wartościami losowymi a następnie sortowana.
*/
public class SortTabNumbers {
private final long tab[];
public SortTabNumbers(final int max) {
tab = new long[max];
int i;
for (i = 0; i < max;) {
tab[i] = (long) (Math.random() * Long.MAX_VALUE);
i++;
}
}
/*
* W metodzie należy zminimalizować liczbę wykonywanych porównań
* opdpowiednio ustalając wartości początkową dla zmienej j.
*/
public void sort() {
for (int i = 0; i < tab.length; i++) {
for (int j = i + 1; j < tab.length; j++) {
if (tab[i] > tab[j]) {
swap(i, j);
}
}
}
}
private void swap(final int i, final int j) {
long tmp = tab[i];
tab[i] = tab[j];
tab[j] = tmp;
}
public boolean checkMinOrderSort() {
for (int k = 0; k < tab.length - 1; k++) {
if (tab[k] > tab[k + 1]) {
return false;
}
}
return true;
}
@Override
public String toString() {
return "tab=" + Arrays.toString(tab);
}
}
| /**
* Uwaga: Klasa zawiera błędy, które trzeba zidentyfikować i usunąć z
* zastosowaniem trybu debug (nadzorowane wykonanie z wykorzystanie debuggera), tak by
* tablica była inicjowana wartościami losowymi a następnie sortowana.
*/ | package pl.lodz.p.it.isrp;
import java.util.Arrays;
/**
* Uwaga: Klasa zawiera <SUF>*/
public class SortTabNumbers {
private final long tab[];
public SortTabNumbers(final int max) {
tab = new long[max];
int i;
for (i = 0; i < max;) {
tab[i] = (long) (Math.random() * Long.MAX_VALUE);
i++;
}
}
/*
* W metodzie należy zminimalizować liczbę wykonywanych porównań
* opdpowiednio ustalając wartości początkową dla zmienej j.
*/
public void sort() {
for (int i = 0; i < tab.length; i++) {
for (int j = i + 1; j < tab.length; j++) {
if (tab[i] > tab[j]) {
swap(i, j);
}
}
}
}
private void swap(final int i, final int j) {
long tmp = tab[i];
tab[i] = tab[j];
tab[j] = tmp;
}
public boolean checkMinOrderSort() {
for (int k = 0; k < tab.length - 1; k++) {
if (tab[k] > tab[k + 1]) {
return false;
}
}
return true;
}
@Override
public String toString() {
return "tab=" + Arrays.toString(tab);
}
}
| f | null |
329 | 10283_2 | SaintAmeN/j133-hibernate-relations | 324 | src/main/java/pl/sda/hibernate/model/Student.java | package pl.sda.hibernate.model;
import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.Formula;
import java.util.Set;
/**
* @author Paweł Recław, AmeN
* @project j133-hibernate-relations
* @created 27.11.2022
*/
@Data
@Entity
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String imie;
@Column(nullable = false)
private String nazwisko;
// @Column(nullable = false)
private int rokRozpoczeciaStudiow;
// nie chcemy, aby to była kolumna
@Formula("(SELECT AVG(o.wartosc) FROM Ocena o WHERE o.uczen_id=id)")
private Double sredniaOcen;
// RELACJE
@ToString.Exclude
@EqualsAndHashCode.Exclude
@OneToMany(mappedBy = "uczen")
private Set<Ocena> oceny;
}
| // nie chcemy, aby to była kolumna | package pl.sda.hibernate.model;
import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.Formula;
import java.util.Set;
/**
* @author Paweł Recław, AmeN
* @project j133-hibernate-relations
* @created 27.11.2022
*/
@Data
@Entity
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Student {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String imie;
@Column(nullable = false)
private String nazwisko;
// @Column(nullable = false)
private int rokRozpoczeciaStudiow;
// nie chcemy, <SUF>
@Formula("(SELECT AVG(o.wartosc) FROM Ocena o WHERE o.uczen_id=id)")
private Double sredniaOcen;
// RELACJE
@ToString.Exclude
@EqualsAndHashCode.Exclude
@OneToMany(mappedBy = "uczen")
private Set<Ocena> oceny;
}
| f | null |
330 | 6885_0 | SaySaeqo/programming-magic-jee | 2,988 | src/main/java/programmingmagic/init/DataStoreInitializer.java | package programmingmagic.init;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.security.DeclareRoles;
import jakarta.annotation.security.RunAs;
import jakarta.ejb.*;
import jakarta.inject.Inject;
import jakarta.security.enterprise.SecurityContext;
import jakarta.security.enterprise.identitystore.Pbkdf2PasswordHash;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import programmingmagic.FileSystemController;
import programmingmagic.domain.program.Program;
import programmingmagic.domain.program.ProgramService;
import programmingmagic.domain.programmer.Programmer;
import programmingmagic.domain.programmer.ProgrammerService;
import programmingmagic.domain.programmer.model.ProgrammerLevel;
import programmingmagic.domain.programminglanguage.ProgrammingLanguage;
import programmingmagic.domain.programminglanguage.ProgrammingLanguageService;
import programmingmagic.domain.programminglanguage.model.ProgrammingLanguageType;
import programmingmagic.domain.technology.Technology;
import programmingmagic.domain.technology.TechnologyService;
import programmingmagic.security.User;
import programmingmagic.security.UserRoles;
import programmingmagic.security.UserService;
import java.io.*;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@Singleton
@Startup
@TransactionAttribute(value = TransactionAttributeType.NOT_SUPPORTED)
@DependsOn("InitializeAdminService")
@DeclareRoles({UserRoles.ADMIN, UserRoles.USER})
@RunAs(UserRoles.ADMIN)
@NoArgsConstructor
public class DataStoreInitializer {
Logger log = LoggerFactory.getLogger(this.getClass().getSimpleName());
ProgramService programService;
ProgrammerService programmerService;
ProgrammingLanguageService programmingLanguageService;
TechnologyService technologyService;
UserService userService;
Pbkdf2PasswordHash passwordHash;
@Inject
public DataStoreInitializer(Pbkdf2PasswordHash passwordHash) {
this.passwordHash = passwordHash;
}
@EJB
public void setProgrammerService(ProgrammerService programmerService) {
this.programmerService = programmerService;
}
@EJB
public void setProgramService(ProgramService programService) {
this.programService = programService;
}
@EJB
public void setProgrammingLanguageService(ProgrammingLanguageService programmingLanguageService) {
this.programmingLanguageService = programmingLanguageService;
}
@EJB
public void setTechnologyService(TechnologyService technologyService) {
this.technologyService = technologyService;
}
@EJB
public void setUserService(UserService userService) {
this.userService = userService;
}
// albo też bez @Startup jako zwykła klasa, która byłaby tworzona i wywoływana w servlecie w metodzie init
@PostConstruct
public void init() {
log.info ("Initializing data store");
Programmer programmer1 = new Programmer("Andrzej", LocalDate.of(1999, 1, 1), ProgrammerLevel.JUNIOR);
save(programmer1);
Programmer programmer2 = new Programmer("Bartek", LocalDate.of(1998, 1, 1), ProgrammerLevel.ROOKIE);
save(programmer2);
Programmer programmer3 = new Programmer("Ania", LocalDate.of(1997, 1, 1), ProgrammerLevel.MASTER);
save(programmer3);
Programmer programmer4 = new Programmer("Karolina", LocalDate.of(1996, 1, 1), ProgrammerLevel.SENIOR);
save(programmer4);
Programmer programmer5 = new Programmer("Edward", LocalDate.of(1995, 1, 1), ProgrammerLevel.SCHOLAR);
save(programmer5);
String projectDir = "/home/saysaeqo/javaProjects/programming-magic-4";
String testSubDir = "src/main/resources/pl/edu/pg/eti/kask/s180171/programmingmagic/portrait";
String fullPath = Paths.get (projectDir,testSubDir).toString();
// iterate throuth all files in directory
String portraitDir = Paths.get(projectDir, "portraits").toString();
File[] currentPortraits = new File(portraitDir).listFiles();
if (currentPortraits == null) {
log.error(String.format("Error while reading directory %s", portraitDir));
return;
}
for (File file : currentPortraits){
file.delete();
}
Map<UUID, byte[]> portraits = new HashMap<>();
// iterate throuth all files in directory
File[] files = new File(fullPath).listFiles();
if (files == null) {
log.error(String.format("Error while reading directory %s", fullPath));
return;
}
for (File file : files){
String fileName = file.getName();
String fileExtension = fileName.substring(fileName.lastIndexOf('.') + 1);
if (!fileExtension.equals("png")) continue;
byte[] fileContent;
try (InputStream inputStream = new FileInputStream(file)) {
fileContent = inputStream.readAllBytes();
} catch (IOException e) {
log.error(String.format("Error while reading file %s", fileName));
continue;
}
String fileNameWithoutExtension = fileName.substring(0, fileName.lastIndexOf('.'));
String programmerName = fileNameWithoutExtension.substring(0, 1).toUpperCase() + fileNameWithoutExtension.substring(1);
try {
UUID programmerUuid = programmerService.getByName(programmerName).getUuid();
if (programmerUuid != null) portraits.put(programmerUuid, fileContent);
} catch (Exception ignored) {
log.error(String.format("Programmer with name %s not found", programmerName));
}
}
FileSystemController fsc = new FileSystemController();
fsc.setDirPath(Paths.get(projectDir, "portraits").toString());
portraits.forEach(((uuid, bytes) -> {
try {
fsc.save(bytes, uuid.toString()+ ".png");
} catch (IOException e) {
log.error(String.format("Pls no! %s", e));
}
}));
Programmer testProgrammer = programmerService.getByName("Andrzej");
Programmer testProgrammer2 = programmerService.getByName("Bartek");
Program program1 = new Program(
"NWD",
"Największy wspólny dzielnik",
"int nwd(int a, int b){\n" +
" if (b == 0) return a;\n" +
" return nwd(b, a % b);\n" +
"}",
LocalDate.of(2021, 1, 1),
testProgrammer
);
Program program2 = new Program(
"Minimum",
"Znajdowanie minimum z tablicy",
"int min(int[] tab){\n" +
" int min = tab[0];\n" +
" for (int i = 1; i < tab.length; i++) {\n" +
" if (tab[i] < min) min = tab[i];\n" +
" }\n" +
" return min;\n" +
"}",
LocalDate.of(2021, 1, 2),
testProgrammer
);
Program program3 = new Program(
"Snake",
"Gra w snake'a",
"...",
LocalDate.of(2021, 1, 3),
testProgrammer2
);
Program program4 = new Program(
"Tetris",
"Gra w tetrisa",
"...",
LocalDate.of(2021, 1, 4),
testProgrammer2
);
ProgrammingLanguage language1 = new ProgrammingLanguage(
"Java",
ProgrammingLanguageType.HIGH_LEVEL,
true,
true
);
ProgrammingLanguage language2 = new ProgrammingLanguage(
"C++",
ProgrammingLanguageType.LOW_LEVEL,
true,
true
);
ProgrammingLanguage language3 = new ProgrammingLanguage(
"Python",
ProgrammingLanguageType.HIGH_LEVEL,
false,
false
);
ProgrammingLanguage language4 = new ProgrammingLanguage(
"assembler",
ProgrammingLanguageType.BYTECODE,
true,
false
);
Technology technology1 = new Technology(
"Spring",
true,
LocalDate.of(2004, 1, 1)
);
Technology technology2 = new Technology(
"Grails",
true,
LocalDate.of(2008, 1, 1)
);
Technology technology3 = new Technology(
"React",
false,
LocalDate.of(2013, 1, 1)
);
Technology technology4 = new Technology(
"PyGame",
false,
LocalDate.of(2000, 1, 1)
);
User user1 = User.builder()
.login("adm") // DLACZEGO NIE MOŻE BYĆ "admin"?!?!
.password(passwordHash.generate("admin".toCharArray()))
.roles(List.of(UserRoles.ADMIN, UserRoles.USER))
.build();
User user2 = User.builder()
.login("user")
.password(passwordHash.generate("user".toCharArray()))
.roles(List.of(UserRoles.USER))
.build();
save(program1);
save(program2);
save(program3);
save(program4);
save(language1);
save(language2);
save(language3);
save(language4);
save(technology1);
save(technology2);
save(technology3);
save(technology4);
save(user1);
save(user2);
}
private void save(Programmer programmer) {
programmerService.save(programmer);
}
private void save(Program program) {
programService.save(program);
}
private void save(ProgrammingLanguage programmingLanguage) {
programmingLanguageService.save(programmingLanguage);
}
private void save(Technology technology) {
technologyService.save(technology);
}
private void save(User user) {
userService.save(user);
}
}
| // albo też bez @Startup jako zwykła klasa, która byłaby tworzona i wywoływana w servlecie w metodzie init
| package programmingmagic.init;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.security.DeclareRoles;
import jakarta.annotation.security.RunAs;
import jakarta.ejb.*;
import jakarta.inject.Inject;
import jakarta.security.enterprise.SecurityContext;
import jakarta.security.enterprise.identitystore.Pbkdf2PasswordHash;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import programmingmagic.FileSystemController;
import programmingmagic.domain.program.Program;
import programmingmagic.domain.program.ProgramService;
import programmingmagic.domain.programmer.Programmer;
import programmingmagic.domain.programmer.ProgrammerService;
import programmingmagic.domain.programmer.model.ProgrammerLevel;
import programmingmagic.domain.programminglanguage.ProgrammingLanguage;
import programmingmagic.domain.programminglanguage.ProgrammingLanguageService;
import programmingmagic.domain.programminglanguage.model.ProgrammingLanguageType;
import programmingmagic.domain.technology.Technology;
import programmingmagic.domain.technology.TechnologyService;
import programmingmagic.security.User;
import programmingmagic.security.UserRoles;
import programmingmagic.security.UserService;
import java.io.*;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@Singleton
@Startup
@TransactionAttribute(value = TransactionAttributeType.NOT_SUPPORTED)
@DependsOn("InitializeAdminService")
@DeclareRoles({UserRoles.ADMIN, UserRoles.USER})
@RunAs(UserRoles.ADMIN)
@NoArgsConstructor
public class DataStoreInitializer {
Logger log = LoggerFactory.getLogger(this.getClass().getSimpleName());
ProgramService programService;
ProgrammerService programmerService;
ProgrammingLanguageService programmingLanguageService;
TechnologyService technologyService;
UserService userService;
Pbkdf2PasswordHash passwordHash;
@Inject
public DataStoreInitializer(Pbkdf2PasswordHash passwordHash) {
this.passwordHash = passwordHash;
}
@EJB
public void setProgrammerService(ProgrammerService programmerService) {
this.programmerService = programmerService;
}
@EJB
public void setProgramService(ProgramService programService) {
this.programService = programService;
}
@EJB
public void setProgrammingLanguageService(ProgrammingLanguageService programmingLanguageService) {
this.programmingLanguageService = programmingLanguageService;
}
@EJB
public void setTechnologyService(TechnologyService technologyService) {
this.technologyService = technologyService;
}
@EJB
public void setUserService(UserService userService) {
this.userService = userService;
}
// albo też <SUF>
@PostConstruct
public void init() {
log.info ("Initializing data store");
Programmer programmer1 = new Programmer("Andrzej", LocalDate.of(1999, 1, 1), ProgrammerLevel.JUNIOR);
save(programmer1);
Programmer programmer2 = new Programmer("Bartek", LocalDate.of(1998, 1, 1), ProgrammerLevel.ROOKIE);
save(programmer2);
Programmer programmer3 = new Programmer("Ania", LocalDate.of(1997, 1, 1), ProgrammerLevel.MASTER);
save(programmer3);
Programmer programmer4 = new Programmer("Karolina", LocalDate.of(1996, 1, 1), ProgrammerLevel.SENIOR);
save(programmer4);
Programmer programmer5 = new Programmer("Edward", LocalDate.of(1995, 1, 1), ProgrammerLevel.SCHOLAR);
save(programmer5);
String projectDir = "/home/saysaeqo/javaProjects/programming-magic-4";
String testSubDir = "src/main/resources/pl/edu/pg/eti/kask/s180171/programmingmagic/portrait";
String fullPath = Paths.get (projectDir,testSubDir).toString();
// iterate throuth all files in directory
String portraitDir = Paths.get(projectDir, "portraits").toString();
File[] currentPortraits = new File(portraitDir).listFiles();
if (currentPortraits == null) {
log.error(String.format("Error while reading directory %s", portraitDir));
return;
}
for (File file : currentPortraits){
file.delete();
}
Map<UUID, byte[]> portraits = new HashMap<>();
// iterate throuth all files in directory
File[] files = new File(fullPath).listFiles();
if (files == null) {
log.error(String.format("Error while reading directory %s", fullPath));
return;
}
for (File file : files){
String fileName = file.getName();
String fileExtension = fileName.substring(fileName.lastIndexOf('.') + 1);
if (!fileExtension.equals("png")) continue;
byte[] fileContent;
try (InputStream inputStream = new FileInputStream(file)) {
fileContent = inputStream.readAllBytes();
} catch (IOException e) {
log.error(String.format("Error while reading file %s", fileName));
continue;
}
String fileNameWithoutExtension = fileName.substring(0, fileName.lastIndexOf('.'));
String programmerName = fileNameWithoutExtension.substring(0, 1).toUpperCase() + fileNameWithoutExtension.substring(1);
try {
UUID programmerUuid = programmerService.getByName(programmerName).getUuid();
if (programmerUuid != null) portraits.put(programmerUuid, fileContent);
} catch (Exception ignored) {
log.error(String.format("Programmer with name %s not found", programmerName));
}
}
FileSystemController fsc = new FileSystemController();
fsc.setDirPath(Paths.get(projectDir, "portraits").toString());
portraits.forEach(((uuid, bytes) -> {
try {
fsc.save(bytes, uuid.toString()+ ".png");
} catch (IOException e) {
log.error(String.format("Pls no! %s", e));
}
}));
Programmer testProgrammer = programmerService.getByName("Andrzej");
Programmer testProgrammer2 = programmerService.getByName("Bartek");
Program program1 = new Program(
"NWD",
"Największy wspólny dzielnik",
"int nwd(int a, int b){\n" +
" if (b == 0) return a;\n" +
" return nwd(b, a % b);\n" +
"}",
LocalDate.of(2021, 1, 1),
testProgrammer
);
Program program2 = new Program(
"Minimum",
"Znajdowanie minimum z tablicy",
"int min(int[] tab){\n" +
" int min = tab[0];\n" +
" for (int i = 1; i < tab.length; i++) {\n" +
" if (tab[i] < min) min = tab[i];\n" +
" }\n" +
" return min;\n" +
"}",
LocalDate.of(2021, 1, 2),
testProgrammer
);
Program program3 = new Program(
"Snake",
"Gra w snake'a",
"...",
LocalDate.of(2021, 1, 3),
testProgrammer2
);
Program program4 = new Program(
"Tetris",
"Gra w tetrisa",
"...",
LocalDate.of(2021, 1, 4),
testProgrammer2
);
ProgrammingLanguage language1 = new ProgrammingLanguage(
"Java",
ProgrammingLanguageType.HIGH_LEVEL,
true,
true
);
ProgrammingLanguage language2 = new ProgrammingLanguage(
"C++",
ProgrammingLanguageType.LOW_LEVEL,
true,
true
);
ProgrammingLanguage language3 = new ProgrammingLanguage(
"Python",
ProgrammingLanguageType.HIGH_LEVEL,
false,
false
);
ProgrammingLanguage language4 = new ProgrammingLanguage(
"assembler",
ProgrammingLanguageType.BYTECODE,
true,
false
);
Technology technology1 = new Technology(
"Spring",
true,
LocalDate.of(2004, 1, 1)
);
Technology technology2 = new Technology(
"Grails",
true,
LocalDate.of(2008, 1, 1)
);
Technology technology3 = new Technology(
"React",
false,
LocalDate.of(2013, 1, 1)
);
Technology technology4 = new Technology(
"PyGame",
false,
LocalDate.of(2000, 1, 1)
);
User user1 = User.builder()
.login("adm") // DLACZEGO NIE MOŻE BYĆ "admin"?!?!
.password(passwordHash.generate("admin".toCharArray()))
.roles(List.of(UserRoles.ADMIN, UserRoles.USER))
.build();
User user2 = User.builder()
.login("user")
.password(passwordHash.generate("user".toCharArray()))
.roles(List.of(UserRoles.USER))
.build();
save(program1);
save(program2);
save(program3);
save(program4);
save(language1);
save(language2);
save(language3);
save(language4);
save(technology1);
save(technology2);
save(technology3);
save(technology4);
save(user1);
save(user2);
}
private void save(Programmer programmer) {
programmerService.save(programmer);
}
private void save(Program program) {
programService.save(program);
}
private void save(ProgrammingLanguage programmingLanguage) {
programmingLanguageService.save(programmingLanguage);
}
private void save(Technology technology) {
technologyService.save(technology);
}
private void save(User user) {
userService.save(user);
}
}
| f | null |
331 | 10339_0 | Scholfernus/Dominik-Replay-05-02-2024-StudentAp | 671 | src/main/java/com/example/student/config/AuthConfig.java | package com.example.student.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import java.util.Arrays;
@Configuration
@EnableWebSecurity
public class AuthConfig {
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public InMemoryUserDetailsManager get() {
UserDetails user = User.withUsername("test")
.password(passwordEncoder().encode("test"))
.roles("USER")
.build();
UserDetails admin = User.withUsername("admin")
.password(passwordEncoder().encode("admin"))
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(Arrays.asList(user, admin));
}
@Bean
protected SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.authorizeHttpRequests()
.antMatchers("/students").hasAnyRole("USER")
.antMatchers("/tasks").hasAnyRole("ADMIN")
.antMatchers("/").permitAll()
.and()
.csrf().disable()
.headers().frameOptions().disable()
.and()
.formLogin() // teraz będę konfigurował formularz autoryzacji
.loginPage("/login")
.usernameParameter("username") // nadajemy nazwę jaka będzie jako name w inpucie loginu formularza
.passwordParameter("password")// nadajemy nazwę jaka będzie jako name w inpucie hasła formularza
.loginProcessingUrl("/login")
.failureForwardUrl("/login?error") // co się stanie w momencie wpisania błędnych danych
.defaultSuccessUrl("/")// co się stanie w momencie prawidłowego uwierzytelnienia
.and()
.logout() // mówimy springowi, że przechodzimy do obsłużenia logout
.logoutSuccessUrl("/login")
.logoutUrl("/logout");
return http.build();
}
}
| // teraz będę konfigurował formularz autoryzacji | package com.example.student.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import java.util.Arrays;
@Configuration
@EnableWebSecurity
public class AuthConfig {
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public InMemoryUserDetailsManager get() {
UserDetails user = User.withUsername("test")
.password(passwordEncoder().encode("test"))
.roles("USER")
.build();
UserDetails admin = User.withUsername("admin")
.password(passwordEncoder().encode("admin"))
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(Arrays.asList(user, admin));
}
@Bean
protected SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.authorizeHttpRequests()
.antMatchers("/students").hasAnyRole("USER")
.antMatchers("/tasks").hasAnyRole("ADMIN")
.antMatchers("/").permitAll()
.and()
.csrf().disable()
.headers().frameOptions().disable()
.and()
.formLogin() // teraz będę <SUF>
.loginPage("/login")
.usernameParameter("username") // nadajemy nazwę jaka będzie jako name w inpucie loginu formularza
.passwordParameter("password")// nadajemy nazwę jaka będzie jako name w inpucie hasła formularza
.loginProcessingUrl("/login")
.failureForwardUrl("/login?error") // co się stanie w momencie wpisania błędnych danych
.defaultSuccessUrl("/")// co się stanie w momencie prawidłowego uwierzytelnienia
.and()
.logout() // mówimy springowi, że przechodzimy do obsłużenia logout
.logoutSuccessUrl("/login")
.logoutUrl("/logout");
return http.build();
}
}
| f | null |
332 | 5978_2 | Scholfernus/codeWarsExcercises | 289 | src/main/java/org/example/streamExc/StreamExc4.java | package org.example.streamExc;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExc4 {
// Załóżmy, że masz listę napisów (String) i chcesz wyfiltrować tylko te napisy, które zaczynają się od litery "A"
// i mają długość większą niż 3 Następnie chcesz posortować te napisy alfabetycznie. Moje zadanie dla Ciebie
// polega na napisaniu kodu, który wykona te operacje przy użyciu strumieni.
public static void main(String[] args) {
List<String> strings = Arrays.asList("Apple", "Banana", "Avocado", "Pear", "Apricot", "Orange");
List<String> collect = strings.stream().filter(s -> s.startsWith("A"))
.filter(s -> s.length() > 3)
.sorted().collect(Collectors.toList());
System.out.println(collect);
}
}
| // polega na napisaniu kodu, który wykona te operacje przy użyciu strumieni. | package org.example.streamExc;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExc4 {
// Załóżmy, że masz listę napisów (String) i chcesz wyfiltrować tylko te napisy, które zaczynają się od litery "A"
// i mają długość większą niż 3 Następnie chcesz posortować te napisy alfabetycznie. Moje zadanie dla Ciebie
// polega na <SUF>
public static void main(String[] args) {
List<String> strings = Arrays.asList("Apple", "Banana", "Avocado", "Pear", "Apricot", "Orange");
List<String> collect = strings.stream().filter(s -> s.startsWith("A"))
.filter(s -> s.length() > 3)
.sorted().collect(Collectors.toList());
System.out.println(collect);
}
}
| f | null |
333 | 6864_1 | SciSoftwareSlawomirCichy/ccrto-openapi | 1,551 | src/main/java/org/ccrto/openapi/core/ContextSaveRequest.java | package org.ccrto.openapi.core;
import java.io.Serializable;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
*
* ContextSaveRequest parametry kontekstu definiowane podczas wprowadzania
* zmiany do systemu.
*
* @author Sławomir Cichy <[email protected]>
* @version $Revision: 1.1 $
*
*/
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class ContextSaveRequest implements Serializable {
private static final long serialVersionUID = -8104067213080716088L;
/** Komentarz użytkownika (dlaczego wykonuje daną akcję) */
@JsonProperty(required = true)
@XmlElement(required = true)
private String modifyComment;
/** Nazwa typu/identyfikator typu pod jakim ma zostać zapisana sprawa */
@JsonInclude(Include.NON_NULL)
@JsonProperty(required = false)
@XmlElement(required = false)
private CaseType saveCaseAsType;
/**
* Czy jeżeli pola nie istnieją w żądaniu zapisu sprawy (nie zostały przesłane
* pola obiektu), to ustawiać je na wartość {@code null} ?
*/
@JsonInclude(Include.NON_NULL)
@JsonProperty(required = false, defaultValue = "false")
@XmlElement(required = false, defaultValue = "false")
private Boolean valueIsNullIfFieldNotExisisInRequest = false;
/**
* @return the {@link #modifyComment}
*/
public String getModifyComment() {
return modifyComment;
}
/**
* @param modifyComment
* the {@link #modifyComment} to set
*/
public void setModifyComment(String modifyComment) {
this.modifyComment = modifyComment;
}
/**
* @return the {@link #saveCaseAsType}
*/
public CaseType getSaveCaseAsType() {
return saveCaseAsType;
}
/**
* @param saveCaseAsType
* the {@link #saveCaseAsType} to set
*/
public void setSaveCaseAsType(CaseType saveCaseAsType) {
this.saveCaseAsType = saveCaseAsType;
}
/**
* @return the {@link #valueIsNullIfFieldNotExisisInRequest}
*/
public Boolean getValueIsNullIfFieldNotExisisInRequest() {
return valueIsNullIfFieldNotExisisInRequest;
}
/**
* @param valueIsNullIfFieldNotExisisInRequest
* the {@link #valueIsNullIfFieldNotExisisInRequest} to set
*/
public void setValueIsNullIfFieldNotExisisInRequest(Boolean valueIsNullIfFieldNotExisisInRequest) {
this.valueIsNullIfFieldNotExisisInRequest = valueIsNullIfFieldNotExisisInRequest;
}
/**
* Tworzenie kopii obecnej instancji obiektu
*
* @return kopia instancji
*/
public ContextSaveRequest copy() {
ContextSaveRequest copy = new ContextSaveRequest();
copy.modifyComment = this.modifyComment;
copy.saveCaseAsType = this.saveCaseAsType;
copy.valueIsNullIfFieldNotExisisInRequest = this.valueIsNullIfFieldNotExisisInRequest;
return copy;
}
/* Overridden (non-Javadoc) */
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((modifyComment == null) ? 0 : modifyComment.hashCode());
result = prime * result + ((saveCaseAsType == null) ? 0 : saveCaseAsType.hashCode());
result = prime * result + ((valueIsNullIfFieldNotExisisInRequest == null) ? 0
: valueIsNullIfFieldNotExisisInRequest.hashCode());
return result;
}
/* Overridden (non-Javadoc) */
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof ContextSaveRequest)) {
return false;
}
ContextSaveRequest other = (ContextSaveRequest) obj;
if (modifyComment == null) {
if (other.modifyComment != null) {
return false;
}
} else if (!modifyComment.equals(other.modifyComment)) {
return false;
}
if (saveCaseAsType == null) {
if (other.saveCaseAsType != null) {
return false;
}
} else if (!saveCaseAsType.equals(other.saveCaseAsType)) {
return false;
}
if (valueIsNullIfFieldNotExisisInRequest == null) {
if (other.valueIsNullIfFieldNotExisisInRequest != null) {
return false;
}
} else if (!valueIsNullIfFieldNotExisisInRequest.equals(other.valueIsNullIfFieldNotExisisInRequest)) {
return false;
}
return true;
}
}
| /** Komentarz użytkownika (dlaczego wykonuje daną akcję) */ | package org.ccrto.openapi.core;
import java.io.Serializable;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
*
* ContextSaveRequest parametry kontekstu definiowane podczas wprowadzania
* zmiany do systemu.
*
* @author Sławomir Cichy <[email protected]>
* @version $Revision: 1.1 $
*
*/
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class ContextSaveRequest implements Serializable {
private static final long serialVersionUID = -8104067213080716088L;
/** Komentarz użytkownika (dlaczego <SUF>*/
@JsonProperty(required = true)
@XmlElement(required = true)
private String modifyComment;
/** Nazwa typu/identyfikator typu pod jakim ma zostać zapisana sprawa */
@JsonInclude(Include.NON_NULL)
@JsonProperty(required = false)
@XmlElement(required = false)
private CaseType saveCaseAsType;
/**
* Czy jeżeli pola nie istnieją w żądaniu zapisu sprawy (nie zostały przesłane
* pola obiektu), to ustawiać je na wartość {@code null} ?
*/
@JsonInclude(Include.NON_NULL)
@JsonProperty(required = false, defaultValue = "false")
@XmlElement(required = false, defaultValue = "false")
private Boolean valueIsNullIfFieldNotExisisInRequest = false;
/**
* @return the {@link #modifyComment}
*/
public String getModifyComment() {
return modifyComment;
}
/**
* @param modifyComment
* the {@link #modifyComment} to set
*/
public void setModifyComment(String modifyComment) {
this.modifyComment = modifyComment;
}
/**
* @return the {@link #saveCaseAsType}
*/
public CaseType getSaveCaseAsType() {
return saveCaseAsType;
}
/**
* @param saveCaseAsType
* the {@link #saveCaseAsType} to set
*/
public void setSaveCaseAsType(CaseType saveCaseAsType) {
this.saveCaseAsType = saveCaseAsType;
}
/**
* @return the {@link #valueIsNullIfFieldNotExisisInRequest}
*/
public Boolean getValueIsNullIfFieldNotExisisInRequest() {
return valueIsNullIfFieldNotExisisInRequest;
}
/**
* @param valueIsNullIfFieldNotExisisInRequest
* the {@link #valueIsNullIfFieldNotExisisInRequest} to set
*/
public void setValueIsNullIfFieldNotExisisInRequest(Boolean valueIsNullIfFieldNotExisisInRequest) {
this.valueIsNullIfFieldNotExisisInRequest = valueIsNullIfFieldNotExisisInRequest;
}
/**
* Tworzenie kopii obecnej instancji obiektu
*
* @return kopia instancji
*/
public ContextSaveRequest copy() {
ContextSaveRequest copy = new ContextSaveRequest();
copy.modifyComment = this.modifyComment;
copy.saveCaseAsType = this.saveCaseAsType;
copy.valueIsNullIfFieldNotExisisInRequest = this.valueIsNullIfFieldNotExisisInRequest;
return copy;
}
/* Overridden (non-Javadoc) */
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((modifyComment == null) ? 0 : modifyComment.hashCode());
result = prime * result + ((saveCaseAsType == null) ? 0 : saveCaseAsType.hashCode());
result = prime * result + ((valueIsNullIfFieldNotExisisInRequest == null) ? 0
: valueIsNullIfFieldNotExisisInRequest.hashCode());
return result;
}
/* Overridden (non-Javadoc) */
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof ContextSaveRequest)) {
return false;
}
ContextSaveRequest other = (ContextSaveRequest) obj;
if (modifyComment == null) {
if (other.modifyComment != null) {
return false;
}
} else if (!modifyComment.equals(other.modifyComment)) {
return false;
}
if (saveCaseAsType == null) {
if (other.saveCaseAsType != null) {
return false;
}
} else if (!saveCaseAsType.equals(other.saveCaseAsType)) {
return false;
}
if (valueIsNullIfFieldNotExisisInRequest == null) {
if (other.valueIsNullIfFieldNotExisisInRequest != null) {
return false;
}
} else if (!valueIsNullIfFieldNotExisisInRequest.equals(other.valueIsNullIfFieldNotExisisInRequest)) {
return false;
}
return true;
}
}
| f | null |
335 | 3471_17 | SebastianFiecko/waip | 5,669 | Feature.java | /*
* **************************************************************************
* * *
* * Ericsson hereby grants to the user a royalty-free, irrevocable, *
* * worldwide, nonexclusive, paid-up license to copy, display, perform, *
* * prepare and have prepared derivative works based upon the source code *
* * in this sample application, and distribute the sample source code and *
* * derivative works thereof and to grant others the foregoing rights. *
* * *
* * ERICSSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, *
* * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. *
* * IN NO EVENT SHALL ERICSSON BE LIABLE FOR ANY SPECIAL, INDIRECT OR *
* * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS *
* * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE *
* * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE *
* * OR PERFORMANCE OF THIS SOFTWARE. *
* * *
* **************************************************************************
*/
package com.ericsson.nrgsdk.examples.applications.whereami;
import java.io.Console;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Date;
import javax.swing.ImageIcon;
import com.ericsson.hosasdk.api.HOSAMonitor;
import com.ericsson.hosasdk.api.TpAddress;
import com.ericsson.hosasdk.api.TpHosaSendMessageError;
import com.ericsson.hosasdk.api.TpHosaSendMessageReport;
import com.ericsson.hosasdk.api.TpHosaUIMessageDeliveryStatus;
import com.ericsson.hosasdk.api.fw.P_UNKNOWN_SERVICE_TYPE;
import com.ericsson.hosasdk.api.hui.IpAppHosaUIManager;
import com.ericsson.hosasdk.api.hui.IpHosaUIManager;
import com.ericsson.hosasdk.api.mm.ul.IpUserLocation;
import com.ericsson.hosasdk.api.ui.IpAppUI;
import com.ericsson.hosasdk.api.ui.TpUIEventInfo;
import com.ericsson.hosasdk.api.ui.TpUIEventNotificationInfo;
import com.ericsson.hosasdk.api.ui.TpUIIdentifier;
import com.ericsson.hosasdk.utility.framework.FWproxy;
import com.ericsson.nrgsdk.examples.tools.SDKToolkit;
/**
* This class implements the logic of the application. It uses processors to
* interact with Ericsson Network Resource Gateway.
*/
public class Feature{
private FWproxy itsFramework;
private IpHosaUIManager itsHosaUIManager;
private IpUserLocation itsOsaULManager;
private SMSProcessor itsSMSProcessor;
private MMSProcessor itsMMSProcessor;
private LocationProcessor itsLocationProcessor;
private GUI theGUI;
private Integer assignmentId;
private Service service;
private ArrayList<Worker> allWorkers; // lista wszystkich abonentow
private String locationCheck = "";
private List<String> managementNumbers;
/**
* Initializes a new instance, without starting interaction with Ericsson
* Network Resource Gateway (see start)
*
* @param aGUI
* the GUI of the application
*/
public Feature(GUI aGUI) {
theGUI = aGUI;
aGUI.setTitle("Worker control application");
aGUI.addTab("Description", getDescription());
}
/**
* Starts interaction with the Ericsson Network Resource Gateway. Note: this
* method is intended to be called at most once.
*/
protected void start() {
HOSAMonitor.addListener(SDKToolkit.LOGGER);
itsFramework = new FWproxy(Configuration.INSTANCE);
try
{
itsHosaUIManager = (IpHosaUIManager) itsFramework
.obtainSCF("SP_HOSA_USER_INTERACTION");
itsOsaULManager = (IpUserLocation) itsFramework
.obtainSCF("P_USER_LOCATION");
}
catch (P_UNKNOWN_SERVICE_TYPE anException)
{
System.err.println("Service not found. Please refer to the Ericsson Network Resource Gateway User Guide for "
+ "a list of which applications that are able to run on which test tools\n"
+ anException);
}
itsSMSProcessor = new SMSProcessor(itsHosaUIManager, this);
itsMMSProcessor = new MMSProcessor(itsHosaUIManager, this);
itsLocationProcessor = new LocationProcessor(itsOsaULManager, this);
System.out.println("Starting SMS notification");
assignmentId = new Integer(itsSMSProcessor.startNotifications(Configuration.INSTANCE.getProperty("serviceNumber")));
managementNumbers = Arrays.asList("0001", "0002", "0003", "0004");
allWorkers = new ArrayList<Worker>();
service = new Service(this);
}
/**
* Stops interaction with the Ericsson Network Resource Gateway and disposes
* of all resources allocated by this instance. Note: this method is
* intended to be called at most once.
*/
public void stop() {
System.out.println("Stopping SMS notification");
if (assignmentId != null) {
itsSMSProcessor.stopNotifications(assignmentId.intValue());
}
assignmentId = null;
System.out.println("Disposing processor");
if (itsSMSProcessor != null) {
itsSMSProcessor.dispose();
}
if (itsMMSProcessor != null) {
itsMMSProcessor.dispose();
}
if (itsLocationProcessor != null) {
itsLocationProcessor.dispose();
}
System.out.println("Disposing service manager");
if (itsHosaUIManager != null) {
itsFramework.releaseSCF(itsHosaUIManager);
}
if (itsOsaULManager != null) {
itsFramework.releaseSCF(itsOsaULManager);
}
System.out.println("Disposing framework");
if (itsFramework != null) {
itsFramework.endAccess();
itsFramework.dispose();
}
System.out.println("Stopping Parlay tracing");
HOSAMonitor.removeListener(SDKToolkit.LOGGER);
System.exit(0);
}
/**
* Invoked by the SMSProcessor, when a notification is received.
* @throws Exception
*/
protected void smsReceived(String aSender, String aReceiver,
String aMessageContent) {
System.out.println("Odebrano SMS-a o tresci: " + aMessageContent);
Worker worker = checkList(aSender); // dostajemy naszego pracownika, ktory wyslal SMS'a
//Rejestracja uzytkownika
if (aMessageContent.toLowerCase().matches("imie:(.*)") && worker == null ) {
worker = new Worker(aSender, getName(aMessageContent), 8, itsLocationProcessor);
service.addWorker(worker);
System.out.println("Dodano pracownika o numerze: " + worker.getNumer());
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Jestes nowym uzytkownikiem serwisu");
} else if(aMessageContent.toLowerCase().equals("rejestracja") && worker != null) {
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Nie musisz sie rejestrowac, jestes juz czlonkiem serwisu");
}
//worker chce zaczac monitorowac czas pracy
//jezeli wszystko git, zaczynamy liczenie czasu od momentu request'a
if (aMessageContent.toLowerCase().equals("start") && worker != null ) { //sprawdzamy pracownika
locationCheck="";
itsLocationProcessor.requestLocation(aSender); //sprawdzamy lokalizacje - nie mamy zwrotki od funkcji, trzeba dorobic!
if(locationCheck.matches(aSender+":"+"at_work")){
LocalDateTime workerStartedAt = LocalDate.now();
worker.setStartedWorkAt(workerStartedAt);
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Witaj w pracy!");
locationCheck="";
}
else{
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Nie znajdujesz sie w pracy!");
locationCheck="";
}
}
//Zatrzymanie rejestrowania czasu pracy przez pracownika
if (aMessageContent.toLowerCase().equals("stop") && worker != null ) {
LocalDateTime workerEndedAt = LocalDateTime.now();
worker.setStartedWorkAt(workerEndedAt);
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Do zobaczenia jutro :>!");
}
/* 15 minut przerwy
zacznij rejestrowac czas pracy po czasie przerwy - sprawdzajac najpierw lokalizacje, czy pracownik jest w pracy
jezeli nie ma go w pracy po przerwie, zakoncz prace */
if (aMessageContent.toLowerCase().equals("pauza") && worker != null ) {
LocalDateTime pauseStartedAt = LocalDateTime.now();
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Zaczynasz pauze, odpocznij, masz 15 minut! :>!");
/*pytanie, jak po tych "15 minutach" sprawdzic, czy pracownik wrocil do firmy, bo interesuje nas jego polozenie,
czy robimy thread.sleep i czekamy, czy wychodzimy stad i za jakis czas powrot do sprawdzenia?
*/
if(ChronoUnit.MINUTES.between(pauseStartedAt, LocalDateTime.now()) >= 15){
itsLocationProcessor.requestLocation(aSender); //sprawdzamy lokalizacje - nie mamy zwrotki od funkcji, trzeba dorobic!
//jezeli jest w robocie, to nic sie nie dzieje, czas leci sobie dalej
//jezeli patalacha nie ma w robocie, to stopujemy czas pracy i czekamy az sie pojawi, zeby mu go wystartowac
//TODO: obsluga pauzowania
}
}
if (aMessageContent.toLowerCase().equals("lokalizacja") && worker != null ) {
itsLocationProcessor.requestLocation(aSender);
}
if (aMessageContent.toLowerCase().matches("zapkalendarz:(.*)") && worker != null){
String day = getDay(aMessageContent);
String hour = getHour(aMessageContent);
if(worker.setCalendar(Integer.parseInt(day),Integer.parseInt(hour)) == 0){
System.out.println("Pomyślnie dokonano wpisu do kalendarza dnia "+day+" o godzinie "+hour);
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Pomyślnie dokonano wpisu do kalendarza dnia "+day+" o godzinie "+hour);
}else{
System.out.println("Termin dnia "+day+" o godzinie "+hour+" jest już zajęty");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Termin dnia "+day+" o godzinie "+hour+" jest już zajęty");
}
}
if (aMessageContent.toLowerCase().matches("sprkalendarz:(.*)") && worker != null){
String day = getDay(aMessageContent);
String hour = getHour(aMessageContent);
if(worker.setCalendar(Integer.parseInt(day),Integer.parseInt(hour)) == 0){
System.out.println("Termin dnia "+day+" o godzinie "+hour+" jest wolny");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Termin dnia "+day+" o godzinie "+hour+" jest wolny");
}else{
System.out.println("Termin dnia "+day+" o godzinie "+hour+" jest zajęty");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Termin dnia "+day+" o godzinie "+hour+" jest zajęty");
}
}
if (aMessageContent.toLowerCase().equals("status") && worker != null ) {
//musimy zwrocic informacje od klasy Worker ile czasu zostalo do konca pracy, czy to procentowo, czy w godzinach
}
if (aMessageContent.toLowerCase().matches("gdzie:(.*)") && worker != null){ //zapytanie o lokalizację danego numeru
if (worker.getNumer() == "2222") { //sprawdzamy czy numer danej osoby ma uprawnienia
//wez
String reqNum = aMessageContent.split(":")[1];
if (checkList(reqNum) != null){
itsLocationProcessor.requestLocation(reqNum);
if (locationCheck != ""){
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Pracownik używający numeru " + reqNum + " jest w pracy");
} else {
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Pracownika używającego numeru " + reqNum + " nie ma w pracy");
}
} else {
System.out.println("Nie ma takiego numeru");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Nie ma takiego numeru");
}
} else {
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Nie masz uprawnien do tych danych!");
}
}
if(worker == null){
// TODO: rzucamy wyjatek, ale gdzie go zlapiemy? ;)
}
}
private String getName(String aMessageContent){
return aMessageContent.substring(5);
}
private String getDay(String aMessageContent){
return aMessageContent.substring(13,15);
}
private String getHour(String aMessageContent){
return aMessageContent.substring(16,18);
}
private Worker checkList(String numer)
{
for (Worker w : service.getUserOfService())
if (w.getNumer().equalsIgnoreCase(numer))
return w;
return null;
}
//TODO: funkcja ta musi jakos zwracac, czy uzytkownik jest w pracy, czy nie, aby mozna bylo egzekwowac czas pracy
public void locationReceived(String user, float latitude, float longitude) {
try {
//Map
ImageIcon map = Configuration.INSTANCE.getImage("map.gif");
int wm = map.getIconWidth();
int hm = map.getIconHeight();
//Phone
ImageIcon phone = Configuration.INSTANCE.getImage("phone.png");
int wp = phone.getIconWidth();
int hp = phone.getIconHeight();
if (latitude < 0) {
latitude = 0;
}
if (latitude > 1) {
latitude = 1;
}
if (longitude < 0) {
longitude = 0;
}
if (longitude > 1) {
longitude = 1;
}
int x = (int) (latitude * wm - wp / 2);
int y = (int) (longitude * hm - hp / 2);
Plotter plotter = new Plotter(wm, hm);
plotter.drawImage(map.getImage(), 0, 0, theGUI);
plotter.drawImage(phone.getImage(), x, y, theGUI);
MMSMessageContent messageContent = new MMSMessageContent();
messageContent.addMedia(plotter.createDataSource());
itsMMSProcessor.sendMMS(Configuration.INSTANCE.getProperty("serviceNumber"), user, messageContent
.getBinaryContent(), "Current location");
if(latitude > 0.59 && latitude < 0.68 && longitude > 0.28 && longitude < 0.4) {
System.out.println("Witaj w pracy korposzczurku!");
locationCheck = user.toString() + ":" + "at_work";
}
else{
System.out.println("Nie znajdujesz się w pracy!");
locationCheck = user.toString() + ":" + "not_at_work";
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* @return a descriptive text that explains the application and its
* configuration.
*/
private String getDescription() {
String s = "Nacisnij START, aby sie polaczyc z symulatorem";
s += "\n";
s += "Pracownik moze wysylac SMS na numer " + Configuration.INSTANCE.getProperty("serviceNumber") + " z nastepujacymi poleceniami ";
s += "\n-------------------------------------------\n";
s += "\"imie:TWOJE_IMIE\" pozwala uzytkownikowi na rejestracje w systemie \n";
s += "\"start\" pozwala uzytkownikowi na rozpoczecie rejestrowania czasu pracy \n";
s += "\"stop\" pozwala uzytkownikowi na zakonczenie rejestrowania czasu pracy \n";
s += "\"pauza\" pozwala uzytkownikowi rozpoczecie 15 minutowej przerwy \n";
s += "\"status\" pozwala uzytkownikowi na sprawdzenie czasu pracy do konca dnia \n";
s += "\"lokalizacja \" pozwala uzytkownikowi na zwrocenie aktualnej lokalizacji \n";
s += "\"zapkalendarz:DZIEN_MIESIACA(DD),GODZINA(HH) \" pozwala uzytkownikowi na zajęcie terminu w kalendarzu(np. zapkalendarz:02,14) \n";
s += "\"sprkalendarz:DZIEN_MIESIACA(DD),GODZINA(HH) \" pozwala uzytkownikowi na sprawdzenie czy w danym terminie jest zajęty (np. sprkalendarz:31,06)\n";
s += "\"gdzie:NUMER_PRACOWNIKA \" pozwala uzytkownikowi będącemu w zarządzie na sprawdzenie czy pracownik jest w pracy\n";
s += "\n-------------------------------------------\n";
s += "Nacisnij STOP, aby zatrzymac aplikacje.\n";
return s;
}
}
| //TODO: obsluga pauzowania
| /*
* **************************************************************************
* * *
* * Ericsson hereby grants to the user a royalty-free, irrevocable, *
* * worldwide, nonexclusive, paid-up license to copy, display, perform, *
* * prepare and have prepared derivative works based upon the source code *
* * in this sample application, and distribute the sample source code and *
* * derivative works thereof and to grant others the foregoing rights. *
* * *
* * ERICSSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, *
* * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. *
* * IN NO EVENT SHALL ERICSSON BE LIABLE FOR ANY SPECIAL, INDIRECT OR *
* * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS *
* * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE *
* * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE *
* * OR PERFORMANCE OF THIS SOFTWARE. *
* * *
* **************************************************************************
*/
package com.ericsson.nrgsdk.examples.applications.whereami;
import java.io.Console;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Date;
import javax.swing.ImageIcon;
import com.ericsson.hosasdk.api.HOSAMonitor;
import com.ericsson.hosasdk.api.TpAddress;
import com.ericsson.hosasdk.api.TpHosaSendMessageError;
import com.ericsson.hosasdk.api.TpHosaSendMessageReport;
import com.ericsson.hosasdk.api.TpHosaUIMessageDeliveryStatus;
import com.ericsson.hosasdk.api.fw.P_UNKNOWN_SERVICE_TYPE;
import com.ericsson.hosasdk.api.hui.IpAppHosaUIManager;
import com.ericsson.hosasdk.api.hui.IpHosaUIManager;
import com.ericsson.hosasdk.api.mm.ul.IpUserLocation;
import com.ericsson.hosasdk.api.ui.IpAppUI;
import com.ericsson.hosasdk.api.ui.TpUIEventInfo;
import com.ericsson.hosasdk.api.ui.TpUIEventNotificationInfo;
import com.ericsson.hosasdk.api.ui.TpUIIdentifier;
import com.ericsson.hosasdk.utility.framework.FWproxy;
import com.ericsson.nrgsdk.examples.tools.SDKToolkit;
/**
* This class implements the logic of the application. It uses processors to
* interact with Ericsson Network Resource Gateway.
*/
public class Feature{
private FWproxy itsFramework;
private IpHosaUIManager itsHosaUIManager;
private IpUserLocation itsOsaULManager;
private SMSProcessor itsSMSProcessor;
private MMSProcessor itsMMSProcessor;
private LocationProcessor itsLocationProcessor;
private GUI theGUI;
private Integer assignmentId;
private Service service;
private ArrayList<Worker> allWorkers; // lista wszystkich abonentow
private String locationCheck = "";
private List<String> managementNumbers;
/**
* Initializes a new instance, without starting interaction with Ericsson
* Network Resource Gateway (see start)
*
* @param aGUI
* the GUI of the application
*/
public Feature(GUI aGUI) {
theGUI = aGUI;
aGUI.setTitle("Worker control application");
aGUI.addTab("Description", getDescription());
}
/**
* Starts interaction with the Ericsson Network Resource Gateway. Note: this
* method is intended to be called at most once.
*/
protected void start() {
HOSAMonitor.addListener(SDKToolkit.LOGGER);
itsFramework = new FWproxy(Configuration.INSTANCE);
try
{
itsHosaUIManager = (IpHosaUIManager) itsFramework
.obtainSCF("SP_HOSA_USER_INTERACTION");
itsOsaULManager = (IpUserLocation) itsFramework
.obtainSCF("P_USER_LOCATION");
}
catch (P_UNKNOWN_SERVICE_TYPE anException)
{
System.err.println("Service not found. Please refer to the Ericsson Network Resource Gateway User Guide for "
+ "a list of which applications that are able to run on which test tools\n"
+ anException);
}
itsSMSProcessor = new SMSProcessor(itsHosaUIManager, this);
itsMMSProcessor = new MMSProcessor(itsHosaUIManager, this);
itsLocationProcessor = new LocationProcessor(itsOsaULManager, this);
System.out.println("Starting SMS notification");
assignmentId = new Integer(itsSMSProcessor.startNotifications(Configuration.INSTANCE.getProperty("serviceNumber")));
managementNumbers = Arrays.asList("0001", "0002", "0003", "0004");
allWorkers = new ArrayList<Worker>();
service = new Service(this);
}
/**
* Stops interaction with the Ericsson Network Resource Gateway and disposes
* of all resources allocated by this instance. Note: this method is
* intended to be called at most once.
*/
public void stop() {
System.out.println("Stopping SMS notification");
if (assignmentId != null) {
itsSMSProcessor.stopNotifications(assignmentId.intValue());
}
assignmentId = null;
System.out.println("Disposing processor");
if (itsSMSProcessor != null) {
itsSMSProcessor.dispose();
}
if (itsMMSProcessor != null) {
itsMMSProcessor.dispose();
}
if (itsLocationProcessor != null) {
itsLocationProcessor.dispose();
}
System.out.println("Disposing service manager");
if (itsHosaUIManager != null) {
itsFramework.releaseSCF(itsHosaUIManager);
}
if (itsOsaULManager != null) {
itsFramework.releaseSCF(itsOsaULManager);
}
System.out.println("Disposing framework");
if (itsFramework != null) {
itsFramework.endAccess();
itsFramework.dispose();
}
System.out.println("Stopping Parlay tracing");
HOSAMonitor.removeListener(SDKToolkit.LOGGER);
System.exit(0);
}
/**
* Invoked by the SMSProcessor, when a notification is received.
* @throws Exception
*/
protected void smsReceived(String aSender, String aReceiver,
String aMessageContent) {
System.out.println("Odebrano SMS-a o tresci: " + aMessageContent);
Worker worker = checkList(aSender); // dostajemy naszego pracownika, ktory wyslal SMS'a
//Rejestracja uzytkownika
if (aMessageContent.toLowerCase().matches("imie:(.*)") && worker == null ) {
worker = new Worker(aSender, getName(aMessageContent), 8, itsLocationProcessor);
service.addWorker(worker);
System.out.println("Dodano pracownika o numerze: " + worker.getNumer());
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Jestes nowym uzytkownikiem serwisu");
} else if(aMessageContent.toLowerCase().equals("rejestracja") && worker != null) {
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Nie musisz sie rejestrowac, jestes juz czlonkiem serwisu");
}
//worker chce zaczac monitorowac czas pracy
//jezeli wszystko git, zaczynamy liczenie czasu od momentu request'a
if (aMessageContent.toLowerCase().equals("start") && worker != null ) { //sprawdzamy pracownika
locationCheck="";
itsLocationProcessor.requestLocation(aSender); //sprawdzamy lokalizacje - nie mamy zwrotki od funkcji, trzeba dorobic!
if(locationCheck.matches(aSender+":"+"at_work")){
LocalDateTime workerStartedAt = LocalDate.now();
worker.setStartedWorkAt(workerStartedAt);
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Witaj w pracy!");
locationCheck="";
}
else{
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Nie znajdujesz sie w pracy!");
locationCheck="";
}
}
//Zatrzymanie rejestrowania czasu pracy przez pracownika
if (aMessageContent.toLowerCase().equals("stop") && worker != null ) {
LocalDateTime workerEndedAt = LocalDateTime.now();
worker.setStartedWorkAt(workerEndedAt);
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Do zobaczenia jutro :>!");
}
/* 15 minut przerwy
zacznij rejestrowac czas pracy po czasie przerwy - sprawdzajac najpierw lokalizacje, czy pracownik jest w pracy
jezeli nie ma go w pracy po przerwie, zakoncz prace */
if (aMessageContent.toLowerCase().equals("pauza") && worker != null ) {
LocalDateTime pauseStartedAt = LocalDateTime.now();
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"),aSender,"Zaczynasz pauze, odpocznij, masz 15 minut! :>!");
/*pytanie, jak po tych "15 minutach" sprawdzic, czy pracownik wrocil do firmy, bo interesuje nas jego polozenie,
czy robimy thread.sleep i czekamy, czy wychodzimy stad i za jakis czas powrot do sprawdzenia?
*/
if(ChronoUnit.MINUTES.between(pauseStartedAt, LocalDateTime.now()) >= 15){
itsLocationProcessor.requestLocation(aSender); //sprawdzamy lokalizacje - nie mamy zwrotki od funkcji, trzeba dorobic!
//jezeli jest w robocie, to nic sie nie dzieje, czas leci sobie dalej
//jezeli patalacha nie ma w robocie, to stopujemy czas pracy i czekamy az sie pojawi, zeby mu go wystartowac
//TODO: obsluga <SUF>
}
}
if (aMessageContent.toLowerCase().equals("lokalizacja") && worker != null ) {
itsLocationProcessor.requestLocation(aSender);
}
if (aMessageContent.toLowerCase().matches("zapkalendarz:(.*)") && worker != null){
String day = getDay(aMessageContent);
String hour = getHour(aMessageContent);
if(worker.setCalendar(Integer.parseInt(day),Integer.parseInt(hour)) == 0){
System.out.println("Pomyślnie dokonano wpisu do kalendarza dnia "+day+" o godzinie "+hour);
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Pomyślnie dokonano wpisu do kalendarza dnia "+day+" o godzinie "+hour);
}else{
System.out.println("Termin dnia "+day+" o godzinie "+hour+" jest już zajęty");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender, "Termin dnia "+day+" o godzinie "+hour+" jest już zajęty");
}
}
if (aMessageContent.toLowerCase().matches("sprkalendarz:(.*)") && worker != null){
String day = getDay(aMessageContent);
String hour = getHour(aMessageContent);
if(worker.setCalendar(Integer.parseInt(day),Integer.parseInt(hour)) == 0){
System.out.println("Termin dnia "+day+" o godzinie "+hour+" jest wolny");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Termin dnia "+day+" o godzinie "+hour+" jest wolny");
}else{
System.out.println("Termin dnia "+day+" o godzinie "+hour+" jest zajęty");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Termin dnia "+day+" o godzinie "+hour+" jest zajęty");
}
}
if (aMessageContent.toLowerCase().equals("status") && worker != null ) {
//musimy zwrocic informacje od klasy Worker ile czasu zostalo do konca pracy, czy to procentowo, czy w godzinach
}
if (aMessageContent.toLowerCase().matches("gdzie:(.*)") && worker != null){ //zapytanie o lokalizację danego numeru
if (worker.getNumer() == "2222") { //sprawdzamy czy numer danej osoby ma uprawnienia
//wez
String reqNum = aMessageContent.split(":")[1];
if (checkList(reqNum) != null){
itsLocationProcessor.requestLocation(reqNum);
if (locationCheck != ""){
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Pracownik używający numeru " + reqNum + " jest w pracy");
} else {
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Pracownika używającego numeru " + reqNum + " nie ma w pracy");
}
} else {
System.out.println("Nie ma takiego numeru");
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Nie ma takiego numeru");
}
} else {
itsSMSProcessor.sendSMS(Configuration.INSTANCE.getProperty("serviceNumber"), aSender,"Nie masz uprawnien do tych danych!");
}
}
if(worker == null){
// TODO: rzucamy wyjatek, ale gdzie go zlapiemy? ;)
}
}
private String getName(String aMessageContent){
return aMessageContent.substring(5);
}
private String getDay(String aMessageContent){
return aMessageContent.substring(13,15);
}
private String getHour(String aMessageContent){
return aMessageContent.substring(16,18);
}
private Worker checkList(String numer)
{
for (Worker w : service.getUserOfService())
if (w.getNumer().equalsIgnoreCase(numer))
return w;
return null;
}
//TODO: funkcja ta musi jakos zwracac, czy uzytkownik jest w pracy, czy nie, aby mozna bylo egzekwowac czas pracy
public void locationReceived(String user, float latitude, float longitude) {
try {
//Map
ImageIcon map = Configuration.INSTANCE.getImage("map.gif");
int wm = map.getIconWidth();
int hm = map.getIconHeight();
//Phone
ImageIcon phone = Configuration.INSTANCE.getImage("phone.png");
int wp = phone.getIconWidth();
int hp = phone.getIconHeight();
if (latitude < 0) {
latitude = 0;
}
if (latitude > 1) {
latitude = 1;
}
if (longitude < 0) {
longitude = 0;
}
if (longitude > 1) {
longitude = 1;
}
int x = (int) (latitude * wm - wp / 2);
int y = (int) (longitude * hm - hp / 2);
Plotter plotter = new Plotter(wm, hm);
plotter.drawImage(map.getImage(), 0, 0, theGUI);
plotter.drawImage(phone.getImage(), x, y, theGUI);
MMSMessageContent messageContent = new MMSMessageContent();
messageContent.addMedia(plotter.createDataSource());
itsMMSProcessor.sendMMS(Configuration.INSTANCE.getProperty("serviceNumber"), user, messageContent
.getBinaryContent(), "Current location");
if(latitude > 0.59 && latitude < 0.68 && longitude > 0.28 && longitude < 0.4) {
System.out.println("Witaj w pracy korposzczurku!");
locationCheck = user.toString() + ":" + "at_work";
}
else{
System.out.println("Nie znajdujesz się w pracy!");
locationCheck = user.toString() + ":" + "not_at_work";
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* @return a descriptive text that explains the application and its
* configuration.
*/
private String getDescription() {
String s = "Nacisnij START, aby sie polaczyc z symulatorem";
s += "\n";
s += "Pracownik moze wysylac SMS na numer " + Configuration.INSTANCE.getProperty("serviceNumber") + " z nastepujacymi poleceniami ";
s += "\n-------------------------------------------\n";
s += "\"imie:TWOJE_IMIE\" pozwala uzytkownikowi na rejestracje w systemie \n";
s += "\"start\" pozwala uzytkownikowi na rozpoczecie rejestrowania czasu pracy \n";
s += "\"stop\" pozwala uzytkownikowi na zakonczenie rejestrowania czasu pracy \n";
s += "\"pauza\" pozwala uzytkownikowi rozpoczecie 15 minutowej przerwy \n";
s += "\"status\" pozwala uzytkownikowi na sprawdzenie czasu pracy do konca dnia \n";
s += "\"lokalizacja \" pozwala uzytkownikowi na zwrocenie aktualnej lokalizacji \n";
s += "\"zapkalendarz:DZIEN_MIESIACA(DD),GODZINA(HH) \" pozwala uzytkownikowi na zajęcie terminu w kalendarzu(np. zapkalendarz:02,14) \n";
s += "\"sprkalendarz:DZIEN_MIESIACA(DD),GODZINA(HH) \" pozwala uzytkownikowi na sprawdzenie czy w danym terminie jest zajęty (np. sprkalendarz:31,06)\n";
s += "\"gdzie:NUMER_PRACOWNIKA \" pozwala uzytkownikowi będącemu w zarządzie na sprawdzenie czy pracownik jest w pracy\n";
s += "\n-------------------------------------------\n";
s += "Nacisnij STOP, aby zatrzymac aplikacje.\n";
return s;
}
}
| f | null |
336 | 9957_1 | SebastianGalan76/Multiplication-Math-Games | 949 | java/data/Equation.java | package com.coresaken.multiplication.data;
import androidx.annotation.NonNull;
import com.coresaken.multiplication.data.enums.OperatorType;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public class Equation {
private final String id; //2*3, 5/2, 2+5
private final List<Element> elements;
public OperatorType operatorType;
private int points;
public Equation(List<Element> elements, OperatorType operatorType){
this.elements = elements;
this.operatorType = operatorType;
StringBuilder equationBuilder = new StringBuilder();
int size = elements.size();
for(int i=0;i<size;i++){
if(i!=size-1){
equationBuilder.append(elements.get(i).toString()).append(" ");
}
else{
equationBuilder.append(elements.get(i).toString());
}
}
id = elements.get(0).number+elements.get(1).sign+elements.get(2).number;
}
public Equation(String equation, OperatorType operatorType){
String[] elementsString = equation.split(" ");
List<Element> elementsList = new ArrayList<>();
elementsList.add(new Element(Integer.parseInt(elementsString[0])));
elementsList.add(new Element(operatorType.sign));
elementsList.add(new Element(Integer.parseInt(elementsString[2])));
elementsList.add(new Element("="));
elementsList.add(new Element(Integer.parseInt(elementsString[4])));
this.elements = elementsList;
this.operatorType = operatorType;
this.id = elementsString[0]+operatorType.sign+elementsString[2];
}
@NonNull
public Equation clone(){
return new Equation(elements, operatorType);
}
//Zmiana wynik równania. Używany np. w grze prawda/fałsz
public void setResult(int value){
elements.get(elements.size()-1).number = value;
}
public List<Element> getElements(){
return elements;
}
@NonNull
public String toString(){
return elements.get(0).number+" "+operatorType.sign+" "+elements.get(2).number +" = "+elements.get(4).number;
}
public String getId(){
return id;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return Objects.equals(toString(), ((Equation) o).toString());
}
public void changePoints(int value){
points+=value;
if(points<-15){
points=-15;
}
if(points>=50){
points=50;
}
}
public int getPoints(){
return points;
}
public void setPoints(int value){
points = value;
}
public static class Element{
public ElementType type;
public int number;
public String sign;
public Element(int number){
type = ElementType.NUMBER;
this.number = number;
}
public Element(String sign){
type = ElementType.SIGN;
this.sign = sign;
}
@NonNull
public String toString(){
if(type==ElementType.NUMBER){
return String.valueOf(number);
}
return sign;
}
}
public enum ElementType{
NUMBER, SIGN
}
}
| //Zmiana wynik równania. Używany np. w grze prawda/fałsz | package com.coresaken.multiplication.data;
import androidx.annotation.NonNull;
import com.coresaken.multiplication.data.enums.OperatorType;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public class Equation {
private final String id; //2*3, 5/2, 2+5
private final List<Element> elements;
public OperatorType operatorType;
private int points;
public Equation(List<Element> elements, OperatorType operatorType){
this.elements = elements;
this.operatorType = operatorType;
StringBuilder equationBuilder = new StringBuilder();
int size = elements.size();
for(int i=0;i<size;i++){
if(i!=size-1){
equationBuilder.append(elements.get(i).toString()).append(" ");
}
else{
equationBuilder.append(elements.get(i).toString());
}
}
id = elements.get(0).number+elements.get(1).sign+elements.get(2).number;
}
public Equation(String equation, OperatorType operatorType){
String[] elementsString = equation.split(" ");
List<Element> elementsList = new ArrayList<>();
elementsList.add(new Element(Integer.parseInt(elementsString[0])));
elementsList.add(new Element(operatorType.sign));
elementsList.add(new Element(Integer.parseInt(elementsString[2])));
elementsList.add(new Element("="));
elementsList.add(new Element(Integer.parseInt(elementsString[4])));
this.elements = elementsList;
this.operatorType = operatorType;
this.id = elementsString[0]+operatorType.sign+elementsString[2];
}
@NonNull
public Equation clone(){
return new Equation(elements, operatorType);
}
//Zmiana wynik <SUF>
public void setResult(int value){
elements.get(elements.size()-1).number = value;
}
public List<Element> getElements(){
return elements;
}
@NonNull
public String toString(){
return elements.get(0).number+" "+operatorType.sign+" "+elements.get(2).number +" = "+elements.get(4).number;
}
public String getId(){
return id;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return Objects.equals(toString(), ((Equation) o).toString());
}
public void changePoints(int value){
points+=value;
if(points<-15){
points=-15;
}
if(points>=50){
points=50;
}
}
public int getPoints(){
return points;
}
public void setPoints(int value){
points = value;
}
public static class Element{
public ElementType type;
public int number;
public String sign;
public Element(int number){
type = ElementType.NUMBER;
this.number = number;
}
public Element(String sign){
type = ElementType.SIGN;
this.sign = sign;
}
@NonNull
public String toString(){
if(type==ElementType.NUMBER){
return String.valueOf(number);
}
return sign;
}
}
public enum ElementType{
NUMBER, SIGN
}
}
| f | null |
338 | 3671_1 | Semantive/hiqual | 663 | src/main/java/com/semantive/commons/Is.java | package com.semantive.commons;
import com.semantive.hiqual.IDataObject;
import org.apache.commons.lang3.ObjectUtils;
import java.io.Serializable;
import java.util.*;
/**
* @author Jacek Lewandowski
*/
public class Is {
public static boolean collectionInterfaceOrArray(Class<?> c) {
return c.isAssignableFrom(SortedSet.class) || c.isAssignableFrom(SortedMap.class) || c.isAssignableFrom(List.class) || c.isArray();
}
public static boolean equal(Object o1, Object o2, String propertyPath) {
if (o1 != null && o2 != null) {
if (o1 == o2) return true;
PropertyAccessor ps1 = new PropertyAccessor(propertyPath, o1.getClass());
PropertyAccessor ps2 = new PropertyAccessor(propertyPath, o2.getClass());
return ObjectUtils.equals(ps1.getProperty(o1), ps2.getProperty(o2));
} else {
return o1 == o2;
}
}
public static boolean nullValue(Object o, String propertyPath) {
if (o == null) return true;
PropertyAccessor ps = new PropertyAccessor(propertyPath, o.getClass());
return ps.getProperty(o) == null;
}
/**
* Sprawdza czy wsrod obiektow znajduje sie obiekt
*
* @param what obiekt szukany
* @param where obiekty wsrod ktorych jest poszukiwany
* @return true jeśli znajdziemy obiekt, false jesli nie znajdziemy.
*/
public static boolean included(Object what, Object... where) {
for (Object o : where) {
if (o.equals(what)) {
return true;
}
}
return false;
}
public static boolean proxySafeEqual(Object first, Object second) {
return ObjectUtils.equals(SemantiveObjectUtils.proxySafeCast(first), SemantiveObjectUtils.proxySafeCast(second));
}
public static <T extends Serializable> boolean idNotNull(IDataObject<T> dataObject) {
return dataObject != null && dataObject.getId() != null;
}
public static <T, V> boolean anyKeyIncluded(Map<T, V> map, Collection<T> keys) {
for (T key : keys) {
if (map.containsKey(key)) return true;
}
return false;
}
}
| /**
* Sprawdza czy wsrod obiektow znajduje sie obiekt
*
* @param what obiekt szukany
* @param where obiekty wsrod ktorych jest poszukiwany
* @return true jeśli znajdziemy obiekt, false jesli nie znajdziemy.
*/ | package com.semantive.commons;
import com.semantive.hiqual.IDataObject;
import org.apache.commons.lang3.ObjectUtils;
import java.io.Serializable;
import java.util.*;
/**
* @author Jacek Lewandowski
*/
public class Is {
public static boolean collectionInterfaceOrArray(Class<?> c) {
return c.isAssignableFrom(SortedSet.class) || c.isAssignableFrom(SortedMap.class) || c.isAssignableFrom(List.class) || c.isArray();
}
public static boolean equal(Object o1, Object o2, String propertyPath) {
if (o1 != null && o2 != null) {
if (o1 == o2) return true;
PropertyAccessor ps1 = new PropertyAccessor(propertyPath, o1.getClass());
PropertyAccessor ps2 = new PropertyAccessor(propertyPath, o2.getClass());
return ObjectUtils.equals(ps1.getProperty(o1), ps2.getProperty(o2));
} else {
return o1 == o2;
}
}
public static boolean nullValue(Object o, String propertyPath) {
if (o == null) return true;
PropertyAccessor ps = new PropertyAccessor(propertyPath, o.getClass());
return ps.getProperty(o) == null;
}
/**
* Sprawdza czy wsrod <SUF>*/
public static boolean included(Object what, Object... where) {
for (Object o : where) {
if (o.equals(what)) {
return true;
}
}
return false;
}
public static boolean proxySafeEqual(Object first, Object second) {
return ObjectUtils.equals(SemantiveObjectUtils.proxySafeCast(first), SemantiveObjectUtils.proxySafeCast(second));
}
public static <T extends Serializable> boolean idNotNull(IDataObject<T> dataObject) {
return dataObject != null && dataObject.getId() != null;
}
public static <T, V> boolean anyKeyIncluded(Map<T, V> map, Collection<T> keys) {
for (T key : keys) {
if (map.containsKey(key)) return true;
}
return false;
}
}
| f | null |
340 | 5005_1 | Skarr222/Study | 313 | java/w6/main/Towary.java | package w6.main;
import java.util.ArrayList;
import java.util.List;
//* Ta klasa będzie zawierała kolekcje obiektów klasy Towar
//* Użyjemy do przechowywania obiektów klasy Towar listy
public class Towary extends Towar{
private List<Towar> listaTowarow;
{
listaTowarow = new ArrayList<Towar>();
}
public Towary(String kod, String nazwa, float cena) {
super(kod, nazwa, cena);
}
public void DodajTowar(Towar towar) {
listaTowarow.add(towar);
}
public List<Towar> getListaTowarow() {
return listaTowarow;
}
public void DrukujTowary() {
for(int index = 0 ; index< listaTowarow.size() ; index++) {
listaTowarow.get(index).DrukujTowar(); //* z listy pobieram obiekt Towar i wywołuję jego metodę DrukujTowar
}
}
}
| //* Użyjemy do przechowywania obiektów klasy Towar listy | package w6.main;
import java.util.ArrayList;
import java.util.List;
//* Ta klasa będzie zawierała kolekcje obiektów klasy Towar
//* Użyjemy do <SUF>
public class Towary extends Towar{
private List<Towar> listaTowarow;
{
listaTowarow = new ArrayList<Towar>();
}
public Towary(String kod, String nazwa, float cena) {
super(kod, nazwa, cena);
}
public void DodajTowar(Towar towar) {
listaTowarow.add(towar);
}
public List<Towar> getListaTowarow() {
return listaTowarow;
}
public void DrukujTowary() {
for(int index = 0 ; index< listaTowarow.size() ; index++) {
listaTowarow.get(index).DrukujTowar(); //* z listy pobieram obiekt Towar i wywołuję jego metodę DrukujTowar
}
}
}
| f | null |
341 | 10606_2 | Smialekk/AiSD | 415 | lab4/NewtonDyn.java | package algorytmy4Dynamiczne;
public class NewtonDyn {
final static int N = 8; //kolumny
final static int K = 5; //wiersze
public static void main(String[] args)
{
int [][] tab = new int[K+1][N+1];
for (int n=0; n<=N; n++) //Wypelnianie pierwszego wiersza - K=0
tab[0][n] = 1;
for (int k=1; k<=K; k++) //Wypelnianie pozostalych wierszy
for (int n=k; n<=N; n++) //dla kazdego wiersza wypelnij kolumny
tab[k][n] = tab[k-1][n-1] + tab[k][n-1];
System.out.println("Ostateczny wynik to zawsze tab[K][N]");
System.out.println(tab[K][N]);
System.out.println("\n");
System.out.println("Wypelnienie tablicy krok po kroku: ");
for (int i=0; i<=K; i++) {
for (int j=0; j<=N; j++) {
int val = tab[i][j];
if (val<100) System.out.print(" ");
if (val<10) System.out.print(" ");
System.out.print(val+" ");
}
System.out.println();
}
}
}
| //dla kazdego wiersza wypelnij kolumny
| package algorytmy4Dynamiczne;
public class NewtonDyn {
final static int N = 8; //kolumny
final static int K = 5; //wiersze
public static void main(String[] args)
{
int [][] tab = new int[K+1][N+1];
for (int n=0; n<=N; n++) //Wypelnianie pierwszego wiersza - K=0
tab[0][n] = 1;
for (int k=1; k<=K; k++) //Wypelnianie pozostalych wierszy
for (int n=k; n<=N; n++) //dla kazdego <SUF>
tab[k][n] = tab[k-1][n-1] + tab[k][n-1];
System.out.println("Ostateczny wynik to zawsze tab[K][N]");
System.out.println(tab[K][N]);
System.out.println("\n");
System.out.println("Wypelnienie tablicy krok po kroku: ");
for (int i=0; i<=K; i++) {
for (int j=0; j<=N; j++) {
int val = tab[i][j];
if (val<100) System.out.print(" ");
if (val<10) System.out.print(" ");
System.out.print(val+" ");
}
System.out.println();
}
}
}
| f | null |
343 | 8294_13 | SoftProject/commons | 2,314 | utils-xml/src/main/java/pl/com/softproject/utils/xml/XMLValidator.java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pl.com.softproject.utils.xml;
import java.io.IOException;
import java.io.Reader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.util.JAXBSource;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import org.apache.log4j.Logger;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
/**
*
* @author adrian
*/
public class XMLValidator {
private static Logger logger = Logger.getLogger(XMLValidator.class);
/**
* Sprawdza składnie XML w przekazanym dokumencie
*
* @param reader - Reader do dokumentu XML
* @param errors - zainicjowana kolekcja, w której zostaną˝ zwrócone błędy. Kolekcja zostanie wyzerowana.
* @return
* @throws javax.xml.parsers.ParserConfigurationException
* @throws java.io.IOException
*/
public static boolean checkSyntax(Reader reader, Collection<SAXParseException> errors) throws ParserConfigurationException, IOException {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setValidating(false);
dbf.setNamespaceAware(true);
DocumentBuilder builder = dbf.newDocumentBuilder();
builder.setErrorHandler(new XMLErrorHandler(errors));
//InputSource is = new InputSource(filename);
InputSource source = new InputSource(reader);
try {
builder.parse(source);
} catch (SAXException ignore) {}
return errors.isEmpty();
}
/**
* Validuje XML względem XML Schemy
*
* @param reader - Reader do dokumentu XML
* @param schemaLocation - url do shcemy XML, jeżli jest null to zostanie użyta schema wskazana w atrybucie schemaLocation z dokumentu XML
* @param errors - zainicjowana kolekcja, w kt�rej zostan� zwr�cone b��dy. Kolekcja zostanie wyzerowana.
* @return - true je�li dokument validuje si�
* @throws org.xml.sax.SAXException - je�li nie mo�na zainicjowa� parsera
* @throws java.io.IOException - je�li nie mo�na czyta� z Readera
*/
public static boolean validate(Reader reader, URL schemaLocation, Collection<SAXParseException> errors) throws SAXException, IOException {
//List<SAXParseException> errors = new LinkedList<SAXParseException>();
errors.clear();
// 1. Lookup a factory for the W3C XML Schema language
SchemaFactory factory =
SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
// 2. Compile the schema.
Schema schema = null;
//schema = factory.newSchema(new URL("http://www.dmh.pl/schema/dsml/dsml-1_2_14/dsml.xsd"));
//schema = factory.newSchema(new File("D:/realizacje/CharSource/svn-nowy/dsml/dsml-core/src/main/xsd/dsml.xsd"));
if(schemaLocation == null)
schema = factory.newSchema();
else
schema = factory.newSchema(schemaLocation);
// 3. Get a validator from the schema.
Validator validator = schema.newValidator();
// 4. Parse the document you want to check.
Source source = new StreamSource(reader);
// 5. Check the document
validator.setErrorHandler(new XMLErrorHandler(errors));
validator.validate(source);
return errors.isEmpty();
}
/**
* Validuje XML względem XML Schemy, lokalizacja schemy będzie pobrana z atrybutu schemaLocation z dokumentu XML
*
* @param reader - Reader do dokumentu XML
* @param errors - zainicjowana kolekcja, w której zostaną zwrócone błędy. Kolekcja zostanie wyzerowana.
* @return - true jeśli dokument validuje się
* @throws org.xml.sax.SAXException - jeśli nie można zainicjować parsera
* @throws java.io.IOException - je�li nie mo�na czyta� z Readera
*/
public static boolean validate(Reader reader, Collection<SAXParseException> errors) throws SAXException, IOException {
return validate(reader, null, errors);
}
/**
* Validuje XML względem XML Schemy, lokalizacja schemy będzie pobrana z atrybutu schemaLocation z dokumentu XML
* Metoda z założenia, nigdy nie rzuca wyąkami. Gdy walidacje nie przejdzie zwraca po prostu "false".
* @param <T>
* @param dsml - dokument który powstał‚ w wyniku wywołania metody "unmarshal". Np. DsmlDocument lub DomainsDocument.
* @param xsdFileName - nazwa pliku xsd, jeśli jest null to zostanie użyta schema wskazana w atrybucie schemaLocation z dokumentu XML.
* @param exceptions - kolekcja, w której zostaną zwrócone błędy.
* @return - true jeśli dokument przechodzi poprawnie walidację.
*/
public static <T> boolean validate(T dsml, String xsdFileName, List<SAXParseException> exceptions) {
try {
Schema schema = null;
String contextPath = dsml.getClass().getPackage().getName();
JAXBContext jc = JAXBContext.newInstance(contextPath);
JAXBSource source = new JAXBSource(jc, dsml);
SchemaFactory factory = SchemaFactory.newInstance(javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI);
if(xsdFileName == null) {
schema = factory.newSchema();
} else {
URL schemaLocation = XMLValidator.class.getClassLoader().getResource(xsdFileName);
schema = factory.newSchema(schemaLocation);
}
Validator validator = schema.newValidator();
if (exceptions == null)
exceptions = new ArrayList<SAXParseException>();
validator.setErrorHandler(new XMLValidator.XMLErrorExtensionHandler(exceptions));
validator.validate(source);
return exceptions.isEmpty();
} catch (SAXException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch(JAXBException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch(IOException ex) {
throw new XMLParseException(ex.getMessage(), ex);
} catch (Exception ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
public static class XMLErrorHandler implements ErrorHandler {
public XMLErrorHandler(Collection<SAXParseException> errors) {
this.errors = errors;
}
private Collection<SAXParseException> errors;
@Override
public void warning(SAXParseException exception) throws SAXException {
errors.add(exception);
}
@Override
public void error(SAXParseException exception) throws SAXException {
errors.add(exception);
}
@Override
public void fatalError(SAXParseException exception) throws SAXException {
errors.add(exception);
}
}
public static class XMLErrorExtensionHandler extends XMLErrorHandler {
public XMLErrorExtensionHandler(List<SAXParseException> exceptions) {
super(exceptions);
}
@Override
public void warning(SAXParseException exception) throws SAXException {
String message = exception.getMessage() != null ? exception.getMessage() : "";
logger.warn(message, exception);
}
}
} | /**
* Validuje XML względem XML Schemy, lokalizacja schemy będzie pobrana z atrybutu schemaLocation z dokumentu XML
*
* @param reader - Reader do dokumentu XML
* @param errors - zainicjowana kolekcja, w której zostaną zwrócone błędy. Kolekcja zostanie wyzerowana.
* @return - true jeśli dokument validuje się
* @throws org.xml.sax.SAXException - jeśli nie można zainicjować parsera
* @throws java.io.IOException - je�li nie mo�na czyta� z Readera
*/ | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package pl.com.softproject.utils.xml;
import java.io.IOException;
import java.io.Reader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.util.JAXBSource;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import org.apache.log4j.Logger;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
/**
*
* @author adrian
*/
public class XMLValidator {
private static Logger logger = Logger.getLogger(XMLValidator.class);
/**
* Sprawdza składnie XML w przekazanym dokumencie
*
* @param reader - Reader do dokumentu XML
* @param errors - zainicjowana kolekcja, w której zostaną˝ zwrócone błędy. Kolekcja zostanie wyzerowana.
* @return
* @throws javax.xml.parsers.ParserConfigurationException
* @throws java.io.IOException
*/
public static boolean checkSyntax(Reader reader, Collection<SAXParseException> errors) throws ParserConfigurationException, IOException {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setValidating(false);
dbf.setNamespaceAware(true);
DocumentBuilder builder = dbf.newDocumentBuilder();
builder.setErrorHandler(new XMLErrorHandler(errors));
//InputSource is = new InputSource(filename);
InputSource source = new InputSource(reader);
try {
builder.parse(source);
} catch (SAXException ignore) {}
return errors.isEmpty();
}
/**
* Validuje XML względem XML Schemy
*
* @param reader - Reader do dokumentu XML
* @param schemaLocation - url do shcemy XML, jeżli jest null to zostanie użyta schema wskazana w atrybucie schemaLocation z dokumentu XML
* @param errors - zainicjowana kolekcja, w kt�rej zostan� zwr�cone b��dy. Kolekcja zostanie wyzerowana.
* @return - true je�li dokument validuje si�
* @throws org.xml.sax.SAXException - je�li nie mo�na zainicjowa� parsera
* @throws java.io.IOException - je�li nie mo�na czyta� z Readera
*/
public static boolean validate(Reader reader, URL schemaLocation, Collection<SAXParseException> errors) throws SAXException, IOException {
//List<SAXParseException> errors = new LinkedList<SAXParseException>();
errors.clear();
// 1. Lookup a factory for the W3C XML Schema language
SchemaFactory factory =
SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
// 2. Compile the schema.
Schema schema = null;
//schema = factory.newSchema(new URL("http://www.dmh.pl/schema/dsml/dsml-1_2_14/dsml.xsd"));
//schema = factory.newSchema(new File("D:/realizacje/CharSource/svn-nowy/dsml/dsml-core/src/main/xsd/dsml.xsd"));
if(schemaLocation == null)
schema = factory.newSchema();
else
schema = factory.newSchema(schemaLocation);
// 3. Get a validator from the schema.
Validator validator = schema.newValidator();
// 4. Parse the document you want to check.
Source source = new StreamSource(reader);
// 5. Check the document
validator.setErrorHandler(new XMLErrorHandler(errors));
validator.validate(source);
return errors.isEmpty();
}
/**
* Validuje XML względem <SUF>*/
public static boolean validate(Reader reader, Collection<SAXParseException> errors) throws SAXException, IOException {
return validate(reader, null, errors);
}
/**
* Validuje XML względem XML Schemy, lokalizacja schemy będzie pobrana z atrybutu schemaLocation z dokumentu XML
* Metoda z założenia, nigdy nie rzuca wyąkami. Gdy walidacje nie przejdzie zwraca po prostu "false".
* @param <T>
* @param dsml - dokument który powstał‚ w wyniku wywołania metody "unmarshal". Np. DsmlDocument lub DomainsDocument.
* @param xsdFileName - nazwa pliku xsd, jeśli jest null to zostanie użyta schema wskazana w atrybucie schemaLocation z dokumentu XML.
* @param exceptions - kolekcja, w której zostaną zwrócone błędy.
* @return - true jeśli dokument przechodzi poprawnie walidację.
*/
public static <T> boolean validate(T dsml, String xsdFileName, List<SAXParseException> exceptions) {
try {
Schema schema = null;
String contextPath = dsml.getClass().getPackage().getName();
JAXBContext jc = JAXBContext.newInstance(contextPath);
JAXBSource source = new JAXBSource(jc, dsml);
SchemaFactory factory = SchemaFactory.newInstance(javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI);
if(xsdFileName == null) {
schema = factory.newSchema();
} else {
URL schemaLocation = XMLValidator.class.getClassLoader().getResource(xsdFileName);
schema = factory.newSchema(schemaLocation);
}
Validator validator = schema.newValidator();
if (exceptions == null)
exceptions = new ArrayList<SAXParseException>();
validator.setErrorHandler(new XMLValidator.XMLErrorExtensionHandler(exceptions));
validator.validate(source);
return exceptions.isEmpty();
} catch (SAXException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch(JAXBException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch(IOException ex) {
throw new XMLParseException(ex.getMessage(), ex);
} catch (Exception ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
public static class XMLErrorHandler implements ErrorHandler {
public XMLErrorHandler(Collection<SAXParseException> errors) {
this.errors = errors;
}
private Collection<SAXParseException> errors;
@Override
public void warning(SAXParseException exception) throws SAXException {
errors.add(exception);
}
@Override
public void error(SAXParseException exception) throws SAXException {
errors.add(exception);
}
@Override
public void fatalError(SAXParseException exception) throws SAXException {
errors.add(exception);
}
}
public static class XMLErrorExtensionHandler extends XMLErrorHandler {
public XMLErrorExtensionHandler(List<SAXParseException> exceptions) {
super(exceptions);
}
@Override
public void warning(SAXParseException exception) throws SAXException {
String message = exception.getMessage() != null ? exception.getMessage() : "";
logger.warn(message, exception);
}
}
} | f | null |
344 | 3966_0 | Sophistic4ted/JavaLab | 172 | Lab3/1/A.java | package myPackage;
import java.util.LinkedList;
public class A {
void metodaA(final double var) {
//zmienna final typu prymitywnego double jest stała
var=1;
}
void metodaB(final LinkedList<Double> list) {
//zmienna LinkedList jest obiektem, więc stała jest tylko referencja do obiektu
//Więc to można
list.add(2.0);
list.remove(2.0);
//A tego już nie
list = new LinkedList<Double>();
}
}
| //zmienna final typu prymitywnego double jest stała | package myPackage;
import java.util.LinkedList;
public class A {
void metodaA(final double var) {
//zmienna final <SUF>
var=1;
}
void metodaB(final LinkedList<Double> list) {
//zmienna LinkedList jest obiektem, więc stała jest tylko referencja do obiektu
//Więc to można
list.add(2.0);
list.remove(2.0);
//A tego już nie
list = new LinkedList<Double>();
}
}
| f | null |
345 | 9977_3 | Sophistic4ted/javaLabs | 311 | src/lab01/Login.java | package lab01;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
* @author Szymon
*/
public class Login {
private String login;
private String password;
/**
* @param _login login jaki dana instancja klasy będiz eprzechowywać
* @param _password hasło jakie dana instancja klasy będiz eprzechowywać
*/
public Login(String _login, String _password) {
login = _login;
password = _password;
}
/**
* @param _login login do porównania z przechowywanym wewnątrz obiektu
* @param _password hasło do porównania z przechowywanym wewnatrz obiektu
* @return prawda, gdy login i hasło zgadzaja sie, fałsz gdy albo login albo hasło nie pasuje do tych rpzechowywanych przez instancję kalsy
*/
public boolean check(String _login, String _password) {
return _login.equals(login) && _password.equals(password);
}
}
| /**
* @param _login login do porównania z przechowywanym wewnątrz obiektu
* @param _password hasło do porównania z przechowywanym wewnatrz obiektu
* @return prawda, gdy login i hasło zgadzaja sie, fałsz gdy albo login albo hasło nie pasuje do tych rpzechowywanych przez instancję kalsy
*/ | package lab01;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
* @author Szymon
*/
public class Login {
private String login;
private String password;
/**
* @param _login login jaki dana instancja klasy będiz eprzechowywać
* @param _password hasło jakie dana instancja klasy będiz eprzechowywać
*/
public Login(String _login, String _password) {
login = _login;
password = _password;
}
/**
* @param _login <SUF>*/
public boolean check(String _login, String _password) {
return _login.equals(login) && _password.equals(password);
}
}
| f | null |
347 | 10247_10 | SportyScripter/ConstellationAndStars | 1,045 | src/SpaceObjects/StarRemover.java | package SpaceObjects;
import java.io.IOException;
public class StarRemover {
public static void DeleteStar(String GreekAlphabet, String ConstellationName) throws IOException, ClassNotFoundException {
int counter = 1;
Star starToRemove = null;
for (Star star : AppStart.listOfStar) {
String catalogName = GreekAlphabet.toUpperCase().concat(" ").concat(ConstellationName);
if (star.getCatalogName().equals(catalogName)) {
starToRemove = star;
break;
}
}
if (starToRemove != null) {
AppStart.listOfStar.remove(starToRemove); //usuwanie gwiazdy z listy
}
else {
System.out.println("Nie ma takiej gwiazdy");
return;
}
if (starToRemove.getCatalogIndex() == 0) { // jesli gwiazda do usuniecia była alpha to trzeba znalezc nowa alpha
Star newAlpha = FindNewAlphaStar(ConstellationName); //znajduje nowa alpha
if (newAlpha != null)
{
newAlpha.setCatalogIndex(0); //ustawiamy jej index na 0
newAlpha.setCatalogName(SpaceObjects.GreekAlphabet.ALPHA.getGreekAlphabet(newAlpha.getCatalogIndex()).concat(" ").concat(newAlpha.getConstellation())); //zmiana nazwy katalogowej
for (Star starsToUpdate : AppStart.listOfStar) { //aktualizacja nazw katalogowych
if (starsToUpdate.getConstellation().equals(ConstellationName) && starsToUpdate.getCatalogIndex() > starToRemove.getCatalogIndex()) { //jesli gwiazda jest w tym samym gwiazdozbiorze i jej index jest wiekszy od poprzedniego indeksu nowej alpha
starsToUpdate.setCatalogIndex(starsToUpdate.getCatalogIndex() - 1); //zmniejszamy jej index o 1 w dół
starsToUpdate.setCatalogName(SpaceObjects.GreekAlphabet.ALPHA.getGreekAlphabet(starsToUpdate.getCatalogIndex()).concat(" ").concat(starsToUpdate.getConstellation())); // zmieniamy nazwe katalogowa
}
}
}
else
{
System.out.println("Usunąłeś ostatnią gwiazde w gwiazdozbiorze");
}
}
else // jesli gwiazda do usuniecia byłą inna niz alpha
{
for (Star starsToUpdate : AppStart.listOfStar) { //aktualizacja nazw katalogowych
if (starsToUpdate.getConstellation().equals(ConstellationName) && starsToUpdate.getCatalogIndex() > starToRemove.getCatalogIndex()) { //jesli gwiazda jest w tym samym gwiazdozbiorze i jej index jest wiekszy od poprzedniego indeksu gwiazdy do usuniecia
starsToUpdate.setCatalogIndex(starsToUpdate.getCatalogIndex() - 1); //zmniejszamy jej index o 1 w dół
starsToUpdate.setCatalogName(SpaceObjects.GreekAlphabet.ALPHA.getGreekAlphabet(starsToUpdate.getCatalogIndex()).concat(" ").concat(starsToUpdate.getConstellation())); // zmieniamy nazwe katalogowa
}
}
}
}
private static Star FindNewAlphaStar(String constellationName) {
Star newAlpha = null;
double temp = 15.00;
for (Star star : AppStart.listOfStar) {
if (star.getConstellation().equals(constellationName)) {
if (star.getObservedStellarMagnitude() < temp) {
temp = star.getObservedStellarMagnitude();
newAlpha = star;
}
}
}
return newAlpha;
}
}
| //aktualizacja nazw katalogowych | package SpaceObjects;
import java.io.IOException;
public class StarRemover {
public static void DeleteStar(String GreekAlphabet, String ConstellationName) throws IOException, ClassNotFoundException {
int counter = 1;
Star starToRemove = null;
for (Star star : AppStart.listOfStar) {
String catalogName = GreekAlphabet.toUpperCase().concat(" ").concat(ConstellationName);
if (star.getCatalogName().equals(catalogName)) {
starToRemove = star;
break;
}
}
if (starToRemove != null) {
AppStart.listOfStar.remove(starToRemove); //usuwanie gwiazdy z listy
}
else {
System.out.println("Nie ma takiej gwiazdy");
return;
}
if (starToRemove.getCatalogIndex() == 0) { // jesli gwiazda do usuniecia była alpha to trzeba znalezc nowa alpha
Star newAlpha = FindNewAlphaStar(ConstellationName); //znajduje nowa alpha
if (newAlpha != null)
{
newAlpha.setCatalogIndex(0); //ustawiamy jej index na 0
newAlpha.setCatalogName(SpaceObjects.GreekAlphabet.ALPHA.getGreekAlphabet(newAlpha.getCatalogIndex()).concat(" ").concat(newAlpha.getConstellation())); //zmiana nazwy katalogowej
for (Star starsToUpdate : AppStart.listOfStar) { //aktualizacja nazw katalogowych
if (starsToUpdate.getConstellation().equals(ConstellationName) && starsToUpdate.getCatalogIndex() > starToRemove.getCatalogIndex()) { //jesli gwiazda jest w tym samym gwiazdozbiorze i jej index jest wiekszy od poprzedniego indeksu nowej alpha
starsToUpdate.setCatalogIndex(starsToUpdate.getCatalogIndex() - 1); //zmniejszamy jej index o 1 w dół
starsToUpdate.setCatalogName(SpaceObjects.GreekAlphabet.ALPHA.getGreekAlphabet(starsToUpdate.getCatalogIndex()).concat(" ").concat(starsToUpdate.getConstellation())); // zmieniamy nazwe katalogowa
}
}
}
else
{
System.out.println("Usunąłeś ostatnią gwiazde w gwiazdozbiorze");
}
}
else // jesli gwiazda do usuniecia byłą inna niz alpha
{
for (Star starsToUpdate : AppStart.listOfStar) { //aktualizacja nazw <SUF>
if (starsToUpdate.getConstellation().equals(ConstellationName) && starsToUpdate.getCatalogIndex() > starToRemove.getCatalogIndex()) { //jesli gwiazda jest w tym samym gwiazdozbiorze i jej index jest wiekszy od poprzedniego indeksu gwiazdy do usuniecia
starsToUpdate.setCatalogIndex(starsToUpdate.getCatalogIndex() - 1); //zmniejszamy jej index o 1 w dół
starsToUpdate.setCatalogName(SpaceObjects.GreekAlphabet.ALPHA.getGreekAlphabet(starsToUpdate.getCatalogIndex()).concat(" ").concat(starsToUpdate.getConstellation())); // zmieniamy nazwe katalogowa
}
}
}
}
private static Star FindNewAlphaStar(String constellationName) {
Star newAlpha = null;
double temp = 15.00;
for (Star star : AppStart.listOfStar) {
if (star.getConstellation().equals(constellationName)) {
if (star.getObservedStellarMagnitude() < temp) {
temp = star.getObservedStellarMagnitude();
newAlpha = star;
}
}
}
return newAlpha;
}
}
| f | null |
348 | 10334_5 | Squar89/Dziki-zachod | 1,590 | src/dzikizachod/StrategiaBandytySprytna.java | package dzikizachod;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author squar
*/
public class StrategiaBandytySprytna extends StrategiaBandyty {
public StrategiaBandytySprytna() {}
@Override
public int strzel(Gracz gracz, int liczbaKart) {
List<WidokGracza> widokGraczy;
WidokGracza aktualnyGracz;
/* możliweCele, to wszyscy gracze w zasięgu bandyty nie będący bandytami */
List<Integer> indeksyMożliweCele;
int indeksGracza, pozostałyZasięg, cel;
widokGraczy = gracz.getWidokGraczy();
indeksyMożliweCele = new ArrayList<>();
indeksGracza = gracz.getIndeks();
/* ustawiam tutaj cel na -1 równoważne braku akcji, ponieważ wyjątkowo nie ma tutaj żadnego
* losowania (metoda zwróci indeks pierwszego celu jaki znajdzie), więc cel = -1
* zostanie zwrócony tylko w przypadku nieznalezienia żadnego możliwego celu */
cel = -1;
/* Czyli w tej turze zabił już bandytę i dalej będzie działał ze strategią domyślną */
if (gracz.getCzyTejTuryZabiłBandytę()) {
pozostałyZasięg = gracz.getZasięg();
for (int indeks = indeksGracza - 1; indeks >= 0; indeks--) {
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
else if (!aktualnyGracz.zobaczCzyJestBandytą(gracz)) {
indeksyMożliweCele.add(indeks);
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
pozostałyZasięg = gracz.getZasięg();
for (int indeks = indeksGracza + 1; indeks <= widokGraczy.size(); indeks++) {
if (indeks == widokGraczy.size()) {
indeks = 0;
}
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
else if (!aktualnyGracz.zobaczCzyJestBandytą(gracz)) {
indeksyMożliweCele.add(indeks);
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
if (!indeksyMożliweCele.isEmpty()) {
cel = indeksyMożliweCele.get(losujIndeks(indeksyMożliweCele.size()));
}
}
else {
pozostałyZasięg = gracz.getZasięg();
/* jeśli szeryf jest w zasięgu bandyty, to automatycznie staje się jego celem
* dlatego interesuje nas przedział [0, indeksGracza) */
for (int indeks = indeksGracza - 1; indeks >= 0; indeks--) {
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
/* sprawdzam czy aktualnyGracz jest bandytą i czy będę miał wystarczającą
* ilość strzałów żeby zabić go w tej turze */
else if (aktualnyGracz.zobaczCzyJestBandytą(gracz)
&& aktualnyGracz.zobaczAktualnePunktyŻycia() <= liczbaKart) {
return indeks;
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
pozostałyZasięg = gracz.getZasięg();
for (int indeks = indeksGracza + 1; indeks <= widokGraczy.size(); indeks++) {
if (indeks == widokGraczy.size()) {
indeks = 0;
}
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
else if (aktualnyGracz.zobaczCzyJestBandytą(gracz)
&& aktualnyGracz.zobaczAktualnePunktyŻycia() <= liczbaKart) {
return indeks;
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
}
return cel;
}
}
| /* sprawdzam czy aktualnyGracz jest bandytą i czy będę miał wystarczającą
* ilość strzałów żeby zabić go w tej turze */ | package dzikizachod;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author squar
*/
public class StrategiaBandytySprytna extends StrategiaBandyty {
public StrategiaBandytySprytna() {}
@Override
public int strzel(Gracz gracz, int liczbaKart) {
List<WidokGracza> widokGraczy;
WidokGracza aktualnyGracz;
/* możliweCele, to wszyscy gracze w zasięgu bandyty nie będący bandytami */
List<Integer> indeksyMożliweCele;
int indeksGracza, pozostałyZasięg, cel;
widokGraczy = gracz.getWidokGraczy();
indeksyMożliweCele = new ArrayList<>();
indeksGracza = gracz.getIndeks();
/* ustawiam tutaj cel na -1 równoważne braku akcji, ponieważ wyjątkowo nie ma tutaj żadnego
* losowania (metoda zwróci indeks pierwszego celu jaki znajdzie), więc cel = -1
* zostanie zwrócony tylko w przypadku nieznalezienia żadnego możliwego celu */
cel = -1;
/* Czyli w tej turze zabił już bandytę i dalej będzie działał ze strategią domyślną */
if (gracz.getCzyTejTuryZabiłBandytę()) {
pozostałyZasięg = gracz.getZasięg();
for (int indeks = indeksGracza - 1; indeks >= 0; indeks--) {
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
else if (!aktualnyGracz.zobaczCzyJestBandytą(gracz)) {
indeksyMożliweCele.add(indeks);
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
pozostałyZasięg = gracz.getZasięg();
for (int indeks = indeksGracza + 1; indeks <= widokGraczy.size(); indeks++) {
if (indeks == widokGraczy.size()) {
indeks = 0;
}
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
else if (!aktualnyGracz.zobaczCzyJestBandytą(gracz)) {
indeksyMożliweCele.add(indeks);
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
if (!indeksyMożliweCele.isEmpty()) {
cel = indeksyMożliweCele.get(losujIndeks(indeksyMożliweCele.size()));
}
}
else {
pozostałyZasięg = gracz.getZasięg();
/* jeśli szeryf jest w zasięgu bandyty, to automatycznie staje się jego celem
* dlatego interesuje nas przedział [0, indeksGracza) */
for (int indeks = indeksGracza - 1; indeks >= 0; indeks--) {
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
/* sprawdzam czy aktualnyGracz <SUF>*/
else if (aktualnyGracz.zobaczCzyJestBandytą(gracz)
&& aktualnyGracz.zobaczAktualnePunktyŻycia() <= liczbaKart) {
return indeks;
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
pozostałyZasięg = gracz.getZasięg();
for (int indeks = indeksGracza + 1; indeks <= widokGraczy.size(); indeks++) {
if (indeks == widokGraczy.size()) {
indeks = 0;
}
aktualnyGracz = widokGraczy.get(indeks);
if (aktualnyGracz.zobaczAktualnePunktyŻycia() > 0) {
if (indeks == 0) {
return 0;
}
else if (aktualnyGracz.zobaczCzyJestBandytą(gracz)
&& aktualnyGracz.zobaczAktualnePunktyŻycia() <= liczbaKart) {
return indeks;
}
pozostałyZasięg--;
if (pozostałyZasięg == 0) {
break;
}
}
}
}
return cel;
}
}
| f | null |
349 | 9364_0 | StanczakDominik/JavaPIC | 1,272 | JavaPIC/src/pl/edu/fizyka/pojava/pic/EnergyPlot.java | package pl.edu.fizyka.pojava.pic;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import java.util.List;
import javax.swing.*;
import java.awt.*;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
/**
* Autor: Dominik
* Klasa oparta na JFreeCharcie odpowiadająca za wykres energii symulacji
* Należy zauważyć, że model PIC przez użyte przybliżenia nawet nie powinien zachowywać energii tak, jak robi to np.
* algorytm leapfrog (który zachowuje ją w 100% przez swoją symetrię czasową).
* Generalnie wszystko działa podobnie jak w FieldPlocie.
* Metoda saveChartAsPng zapisuje wykres fazowy do pliku EnergyPlot#.png, gdzie # jest numerem zdjęcia
*/
class EnergyPlot extends JPanel {
JFreeChart lineGraph;
XYSeries kineticEnergy1, kineticEnergy2, fieldEnergy, totalEnergy;
ArrayList<Double> fieldEnergyToExport = new ArrayList<Double>();
ArrayList<Double> kineticEnergyToExport1= new ArrayList<Double>();
ArrayList<Double> kineticEnergyToExport2 = new ArrayList<Double>();
ArrayList<Double> totalEnergyToExport = new ArrayList<Double>();
ArrayList<Double> timeStepToExport = new ArrayList<Double>();
private int snapshotsTaken = 0;
public EnergyPlot() {
setSize(1000, 240);
fieldEnergy = new XYSeries("Field energy");
kineticEnergy1 = new XYSeries("Species 1 kinetic energy");
kineticEnergy2 = new XYSeries("Species 2 kinetic energy");
totalEnergy = new XYSeries("Total energy");
XYSeriesCollection xySeriesCollection = new XYSeriesCollection(fieldEnergy);
xySeriesCollection.addSeries(kineticEnergy1);
xySeriesCollection.addSeries(kineticEnergy2);
xySeriesCollection.addSeries(totalEnergy);
lineGraph = ChartFactory.createXYLineChart("Energies Chart", "Time", "Energy", xySeriesCollection,
PlotOrientation.VERTICAL, true, true, true);
ChartPanel chartPanel = new ChartPanel(lineGraph);
chartPanel.setPreferredSize(new Dimension(getWidth(), (int) (0.95 * getHeight())));
add(chartPanel);
chartPanel.setVisible(true);
setVisible(true);
}
public void update(SimulationEngine engine, int iteration)
{
fieldEnergy.add(iteration * engine.parameters.timeStep, engine.grid.totalFieldEnergy);
kineticEnergy1.add(iteration * engine.parameters.timeStep, engine.listOfSpecies[0].totalKineticEnergy);
kineticEnergy2.add(iteration * engine.parameters.timeStep, engine.listOfSpecies[1].totalKineticEnergy);
totalEnergy.add(iteration * engine.parameters.timeStep, engine.grid.totalFieldEnergy +
engine.listOfSpecies[0].totalKineticEnergy + engine.listOfSpecies[1].totalKineticEnergy);
fieldEnergyToExport.add(engine.grid.totalFieldEnergy);
kineticEnergyToExport1.add(engine.listOfSpecies[0].totalKineticEnergy);
kineticEnergyToExport2.add(engine.listOfSpecies[1].totalKineticEnergy);
totalEnergyToExport.add(engine.grid.totalFieldEnergy +
engine.listOfSpecies[0].totalKineticEnergy + engine.listOfSpecies[1].totalKineticEnergy);
timeStepToExport.add(iteration * engine.parameters.timeStep);
repaint();
}
public void clear() {
fieldEnergy.clear();
kineticEnergy2.clear();
kineticEnergy1.clear();
totalEnergy.clear();
}
public void saveChartAsPng() {
try {
FileOutputStream output = new FileOutputStream("EnergyPlot" + snapshotsTaken + ".png");
ChartUtilities.writeChartAsPNG(output, lineGraph, 1000, 600);
output.close();
} catch (IOException e) {
e.printStackTrace();
}
snapshotsTaken++;
}
} | /**
* Autor: Dominik
* Klasa oparta na JFreeCharcie odpowiadająca za wykres energii symulacji
* Należy zauważyć, że model PIC przez użyte przybliżenia nawet nie powinien zachowywać energii tak, jak robi to np.
* algorytm leapfrog (który zachowuje ją w 100% przez swoją symetrię czasową).
* Generalnie wszystko działa podobnie jak w FieldPlocie.
* Metoda saveChartAsPng zapisuje wykres fazowy do pliku EnergyPlot#.png, gdzie # jest numerem zdjęcia
*/ | package pl.edu.fizyka.pojava.pic;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import java.util.List;
import javax.swing.*;
import java.awt.*;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
/**
* Autor: Dominik
<SUF>*/
class EnergyPlot extends JPanel {
JFreeChart lineGraph;
XYSeries kineticEnergy1, kineticEnergy2, fieldEnergy, totalEnergy;
ArrayList<Double> fieldEnergyToExport = new ArrayList<Double>();
ArrayList<Double> kineticEnergyToExport1= new ArrayList<Double>();
ArrayList<Double> kineticEnergyToExport2 = new ArrayList<Double>();
ArrayList<Double> totalEnergyToExport = new ArrayList<Double>();
ArrayList<Double> timeStepToExport = new ArrayList<Double>();
private int snapshotsTaken = 0;
public EnergyPlot() {
setSize(1000, 240);
fieldEnergy = new XYSeries("Field energy");
kineticEnergy1 = new XYSeries("Species 1 kinetic energy");
kineticEnergy2 = new XYSeries("Species 2 kinetic energy");
totalEnergy = new XYSeries("Total energy");
XYSeriesCollection xySeriesCollection = new XYSeriesCollection(fieldEnergy);
xySeriesCollection.addSeries(kineticEnergy1);
xySeriesCollection.addSeries(kineticEnergy2);
xySeriesCollection.addSeries(totalEnergy);
lineGraph = ChartFactory.createXYLineChart("Energies Chart", "Time", "Energy", xySeriesCollection,
PlotOrientation.VERTICAL, true, true, true);
ChartPanel chartPanel = new ChartPanel(lineGraph);
chartPanel.setPreferredSize(new Dimension(getWidth(), (int) (0.95 * getHeight())));
add(chartPanel);
chartPanel.setVisible(true);
setVisible(true);
}
public void update(SimulationEngine engine, int iteration)
{
fieldEnergy.add(iteration * engine.parameters.timeStep, engine.grid.totalFieldEnergy);
kineticEnergy1.add(iteration * engine.parameters.timeStep, engine.listOfSpecies[0].totalKineticEnergy);
kineticEnergy2.add(iteration * engine.parameters.timeStep, engine.listOfSpecies[1].totalKineticEnergy);
totalEnergy.add(iteration * engine.parameters.timeStep, engine.grid.totalFieldEnergy +
engine.listOfSpecies[0].totalKineticEnergy + engine.listOfSpecies[1].totalKineticEnergy);
fieldEnergyToExport.add(engine.grid.totalFieldEnergy);
kineticEnergyToExport1.add(engine.listOfSpecies[0].totalKineticEnergy);
kineticEnergyToExport2.add(engine.listOfSpecies[1].totalKineticEnergy);
totalEnergyToExport.add(engine.grid.totalFieldEnergy +
engine.listOfSpecies[0].totalKineticEnergy + engine.listOfSpecies[1].totalKineticEnergy);
timeStepToExport.add(iteration * engine.parameters.timeStep);
repaint();
}
public void clear() {
fieldEnergy.clear();
kineticEnergy2.clear();
kineticEnergy1.clear();
totalEnergy.clear();
}
public void saveChartAsPng() {
try {
FileOutputStream output = new FileOutputStream("EnergyPlot" + snapshotsTaken + ".png");
ChartUtilities.writeChartAsPNG(output, lineGraph, 1000, 600);
output.close();
} catch (IOException e) {
e.printStackTrace();
}
snapshotsTaken++;
}
} | f | null |
350 | 7630_0 | Studia-Politechnika-Bialostocka/ProjektZawodyPO | 458 | ZawodyGUI.java | package def;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ZawodyGUI extends JFrame{
private JPanel mainPanel;
private JLabel mainTitle;
private JButton selectATournamentButton;
private JButton manageTeamsRefereesEtcButton;
private JButton displayListOfTournament;
private JButton addATournamentButton;
private JButton exitTheProgramButton;
public ZawodyGUI(String title){
super(title);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setContentPane(mainPanel);
this.pack();
//żeby okienko było na środku, a nie w lewym górym rogu
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation(dim.width/2-this.getSize().width/2, dim.height/2-this.getSize().height/2);
addATournamentButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent actionEvent) {
AddTheTournamentFrame addTheTournamentFrame = new AddTheTournamentFrame("HEllo WOrld");
addTheTournamentFrame.setVisible(true);
mainPanel.setVisible(false);
dispose();
}
});
exitTheProgramButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent actionEvent) {
}
});
}
public static void main(String[] args) {
JFrame frame = new ZawodyGUI("Zawody");
frame.setVisible(true);
}
}
| //żeby okienko było na środku, a nie w lewym górym rogu | package def;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ZawodyGUI extends JFrame{
private JPanel mainPanel;
private JLabel mainTitle;
private JButton selectATournamentButton;
private JButton manageTeamsRefereesEtcButton;
private JButton displayListOfTournament;
private JButton addATournamentButton;
private JButton exitTheProgramButton;
public ZawodyGUI(String title){
super(title);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setContentPane(mainPanel);
this.pack();
//żeby okienko <SUF>
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation(dim.width/2-this.getSize().width/2, dim.height/2-this.getSize().height/2);
addATournamentButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent actionEvent) {
AddTheTournamentFrame addTheTournamentFrame = new AddTheTournamentFrame("HEllo WOrld");
addTheTournamentFrame.setVisible(true);
mainPanel.setVisible(false);
dispose();
}
});
exitTheProgramButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent actionEvent) {
}
});
}
public static void main(String[] args) {
JFrame frame = new ZawodyGUI("Zawody");
frame.setVisible(true);
}
}
| f | null |
352 | 6760_0 | Sydnej/ProjektSZI | 542 | src/main/java/model/neural/Neuron.java | package model.neural;
import java.util.ArrayList;
import java.util.List;
public class Neuron {
private List<Double> inputSignals;
private List<Double> weights;
private double expectedOutput;
public Neuron() {
inputSignals = new ArrayList<>();
weights = new ArrayList<>();
}
// dodanie sygnału wejściowego i przypisanej mu wagi
public void addSignalAndItsWeight(double signal, double weight) {
inputSignals.add(signal);
weights.add(weight);
}
public double getSignal(int position) {
return inputSignals.get(position);
}
public double getWeight(int position) {
return weights.get(position);
}
public double getExpectedOutput() {
return expectedOutput;
}
// zmiana wartości wybranego sygnału wejściowego i jego wagi
public void setSignalAndItsWeight(int position, double signal, double weight) {
inputSignals.set(position, signal);
weights.set(position, weight);
}
public void setSignal(int position, double signal) {
inputSignals.set(position, signal);
}
public void setWeight(int position, double weight) {
weights.set(position, weight);
}
// ustawienie oczekiwanego wyjścia podczas uczenia sieci
public void setExpectedOutput(double expectedOutput) {
this.expectedOutput = expectedOutput;
}
public int getNumberOfSignals() {
return inputSignals.size();
}
public double getSumOfSignalsAndWeights() {
double sum = 0;
for(int i=0; i<inputSignals.size(); i++) {
sum = sum + (getSignal(i) * getWeight(i));
}
return sum;
}
// funkcja aktywacji
public double getOutput() {
return getSumOfSignalsAndWeights() / getNumberOfSignals();
}
}
| // dodanie sygnału wejściowego i przypisanej mu wagi | package model.neural;
import java.util.ArrayList;
import java.util.List;
public class Neuron {
private List<Double> inputSignals;
private List<Double> weights;
private double expectedOutput;
public Neuron() {
inputSignals = new ArrayList<>();
weights = new ArrayList<>();
}
// dodanie sygnału <SUF>
public void addSignalAndItsWeight(double signal, double weight) {
inputSignals.add(signal);
weights.add(weight);
}
public double getSignal(int position) {
return inputSignals.get(position);
}
public double getWeight(int position) {
return weights.get(position);
}
public double getExpectedOutput() {
return expectedOutput;
}
// zmiana wartości wybranego sygnału wejściowego i jego wagi
public void setSignalAndItsWeight(int position, double signal, double weight) {
inputSignals.set(position, signal);
weights.set(position, weight);
}
public void setSignal(int position, double signal) {
inputSignals.set(position, signal);
}
public void setWeight(int position, double weight) {
weights.set(position, weight);
}
// ustawienie oczekiwanego wyjścia podczas uczenia sieci
public void setExpectedOutput(double expectedOutput) {
this.expectedOutput = expectedOutput;
}
public int getNumberOfSignals() {
return inputSignals.size();
}
public double getSumOfSignalsAndWeights() {
double sum = 0;
for(int i=0; i<inputSignals.size(); i++) {
sum = sum + (getSignal(i) * getWeight(i));
}
return sum;
}
// funkcja aktywacji
public double getOutput() {
return getSumOfSignalsAndWeights() / getNumberOfSignals();
}
}
| f | null |
353 | 7135_1 | SzestKam/SdaAdvace126 | 820 | src/main/java/opp/task04/ListRunner.java | package opp.task04;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
class ListRunner {
public static void main(String[] args) {
List<Integer> myList = new ArrayList<>();
/* byte -> Byte;
short -> Short;
char -> Character;
int -> Integer;
long -> Long;
float -> Float;
double -> Double;
boolean -> Boolean;
byte aB = 2;
Byte bB = 2;
*/
myList.add(2);
myList.add(22);
myList.add(5);
myList.add(50);
myList.add(50);
myList.add(50);
myList.add(-5);
myList.add(800);
System.out.println("---Old fashion / deprecated---");
for (int i = 0; i < myList.size(); i++) {
System.out.println(myList.get(i));
}
System.out.println("---Enhanced list iteration---");
for (int el : myList) {
System.out.println(el);
}
System.out.println("---Stream iteration---");
myList.forEach(System.out::println);
Set<Integer> mySet = new HashSet<>();
mySet.add(12);
mySet.add(22);
mySet.addAll(myList);
System.out.println("---Stream iteration from SET---");
mySet.forEach(System.out::println);
System.out.println("Numbers from range 20-100");
Consumer<Integer> myPrint = el -> System.out.println("Mój element :" + el); // - >
Predicate<Integer> valuesLowerThan100 = el -> el <= 100;
myList.stream()
.filter(new ValuesGreater(20))
.filter(valuesLowerThan100)
.distinct()
.forEach(myPrint);
Supplier<Integer> mySupp = () -> Integer.MIN_VALUE;
var r = myList.stream()
.filter(new ValuesGreater(1_000))
.findFirst()
.orElseGet(mySupp);
System.out.println("Supplier test result: " + r);
}
}
@AllArgsConstructor
class ValuesGreater implements Predicate<Integer> {
private final int LOW_BOUND;
@Override
public boolean test(Integer element) {
return LOW_BOUND <= element;
}
}
// bezpośrednie implementowanie interfejsu funkcyjnego
class MyPrintConsumer implements Consumer<Integer> {
@Override
public void accept(Integer el) {
System.out.println("Mój element :" + el);
}
}
| // bezpośrednie implementowanie interfejsu funkcyjnego | package opp.task04;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
class ListRunner {
public static void main(String[] args) {
List<Integer> myList = new ArrayList<>();
/* byte -> Byte;
short -> Short;
char -> Character;
int -> Integer;
long -> Long;
float -> Float;
double -> Double;
boolean -> Boolean;
byte aB = 2;
Byte bB = 2;
*/
myList.add(2);
myList.add(22);
myList.add(5);
myList.add(50);
myList.add(50);
myList.add(50);
myList.add(-5);
myList.add(800);
System.out.println("---Old fashion / deprecated---");
for (int i = 0; i < myList.size(); i++) {
System.out.println(myList.get(i));
}
System.out.println("---Enhanced list iteration---");
for (int el : myList) {
System.out.println(el);
}
System.out.println("---Stream iteration---");
myList.forEach(System.out::println);
Set<Integer> mySet = new HashSet<>();
mySet.add(12);
mySet.add(22);
mySet.addAll(myList);
System.out.println("---Stream iteration from SET---");
mySet.forEach(System.out::println);
System.out.println("Numbers from range 20-100");
Consumer<Integer> myPrint = el -> System.out.println("Mój element :" + el); // - >
Predicate<Integer> valuesLowerThan100 = el -> el <= 100;
myList.stream()
.filter(new ValuesGreater(20))
.filter(valuesLowerThan100)
.distinct()
.forEach(myPrint);
Supplier<Integer> mySupp = () -> Integer.MIN_VALUE;
var r = myList.stream()
.filter(new ValuesGreater(1_000))
.findFirst()
.orElseGet(mySupp);
System.out.println("Supplier test result: " + r);
}
}
@AllArgsConstructor
class ValuesGreater implements Predicate<Integer> {
private final int LOW_BOUND;
@Override
public boolean test(Integer element) {
return LOW_BOUND <= element;
}
}
// bezpośrednie implementowanie <SUF>
class MyPrintConsumer implements Consumer<Integer> {
@Override
public void accept(Integer el) {
System.out.println("Mój element :" + el);
}
}
| f | null |
354 | 8277_0 | Szy-Ban/MPR-project | 162 | back/src/main/java/com/example/monday/MondayApplication.java | package com.example.monday;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//Adnotacja mówiąca o tym, że tu znajduje się główna klasa naszej aplikacji. To tu jest ona uruchamiana
// i od tego miejsca w szerz oraz w głąb skanowane są pakiety. Skanowanie nigdy nie jest wykonywane w górę.
@SpringBootApplication
public class MondayApplication {
public static void main(String[] args) {
SpringApplication.run(MondayApplication.class, args);
}
}
| //Adnotacja mówiąca o tym, że tu znajduje się główna klasa naszej aplikacji. To tu jest ona uruchamiana | package com.example.monday;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//Adnotacja mówiąca <SUF>
// i od tego miejsca w szerz oraz w głąb skanowane są pakiety. Skanowanie nigdy nie jest wykonywane w górę.
@SpringBootApplication
public class MondayApplication {
public static void main(String[] args) {
SpringApplication.run(MondayApplication.class, args);
}
}
| f | null |
356 | 8293_0 | SzymonM213/mimuw | 95 | sem2/po/BAJTTRADE/src/StrategieDnia/Pracuś.java | package StrategieDnia;
import Giełdy.HistoriaGiełdy;
//nigdy się nie uczy, zawsze pracuje
public class Pracuś implements StrategiaDnia {
@Override
public boolean czyPracuje(double diamenty_robotnika, HistoriaGiełdy historia) {
return true;
}
}
| //nigdy się nie uczy, zawsze pracuje | package StrategieDnia;
import Giełdy.HistoriaGiełdy;
//nigdy się <SUF>
public class Pracuś implements StrategiaDnia {
@Override
public boolean czyPracuje(double diamenty_robotnika, HistoriaGiełdy historia) {
return true;
}
}
| f | null |
357 | 6080_2 | TWokulski/BrainBooster | 1,432 | src/GameCore/ScoreBoard.java | package GameCore;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Obiekt <code>ScoreBoard</code> reprezentuje panel z tablica wynikow.
* W panelu znajdziemy tablice z wynikami odczytanymi z pliku tekstowego oraz przycisk powrotu do Menu
*
* @author Tomasz Gruzdzis
*/
public class ScoreBoard extends JPanel
{
/** Zmienna przechowujaca obrazek tla */
private Image bgMenu = new ImageIcon(getClass().getResource("/Resources/bgMenu.gif")).getImage();
/** Deklaracja Tabeli, przeznaczonej do prezentowania wynikow */
private JTable scoreTable;
/** Zadeklarowanie kolum jakie beda uzywane w tabeli */
private String[] columnNames = {"Date", "Player Name", "Time", "Wrong answers"};
/**
* Konstruktor domyslny.
*/
ScoreBoard()
{
this.setLayout( new FlowLayout() );
/**
* Stworzenie obiektu tabeli, nie posiadajacej kolumn i wierszy.
* Kolumny i wiersze dodane zostaja w readScore()
* @see GameCore.ScoreBoard#readScore()
*/
scoreTable = new JTable(0,0);
readScore();
/** Ustawienie maksymalnych wymiarow tabeli, a takze koloru tla i czcionki */
scoreTable.setPreferredScrollableViewportSize(new Dimension(800,300));
scoreTable.setFillsViewportHeight(true);
scoreTable.setBackground(Color.BLACK);
scoreTable.setFont(new Font("Arial",Font.PLAIN, 20));
scoreTable.setForeground(Color.WHITE);
/** Wprowadzenie domyslnego sortowania
* pozwala miedzy innymi na zmiane trybu prezentowania wynikow wzgledem daty
*/
scoreTable.setAutoCreateRowSorter(true);
/** Zablokowanie mozliwosci edytowania z punktu programu */
scoreTable.setEnabled(false);
/** Deklaracja scrollPane, wprowadza suwak, ktory umozliwia gromadzenie wiekszej ilosci danych w tabeli */
JScrollPane scrollPane = new JScrollPane(scoreTable);
add(scrollPane);
}
/**
* Metoda odczytujaca dane z pliku i zapisujaca je do tabeli
*/
public void readScore()
{
try
{
/** Otwarcie strumienia odczytujacego i wybranie pliku z wynikami
* @see GameWindow#finishTheGame()
*/
BufferedReader scoreRead = new BufferedReader (new FileReader("score.txt"));
DefaultTableModel model = (DefaultTableModel)scoreTable.getModel();
/** Zapisanie lini do tablicy */
Object [] tableLines = scoreRead.lines().toArray();
/** Ustawienie kolumn tabeli */
model.setColumnIdentifiers(columnNames);
if(scoreTable.getRowCount() != 0)
{
/** Jezeli tablica nie jest pusta, dodany do tablicy zostanie tylko ostatni wiersz w pliku tekstowym
* @see GameWindow#finishTheGame()
*/
String line = tableLines[tableLines.length - 1].toString().trim();
/** Podzial pobranej lini wzgledem znaku "/" */
String[] dataRow = line.split("/");
/** Dodanie wiersza do tabeli */
model.addRow(dataRow);
}
else
{
/** Jezeli tablica jest pusta, dodany do tablicy zostana wszystkie wiersze w pliku tekstowym
* @see ScoreBoard#ScoreBoard()
*/
for(int i = 0; i < tableLines.length; i++)
{
/** Do <code>line</code> zostana przypisane kolejne wiersze w pliku tekstowym
* Po kazdym wieszu nastepuje dodanie do tabeli
*/
String line = tableLines[i].toString().trim();
String[] dataRow = line.split("/");
model.addRow(dataRow);
}
}
/** Zamkniecie strumienia*/
scoreRead.close();
}
catch (IOException e)
{
System.err.println(e.getMessage());
}
}
/**
* Metoda rysujaca obraz tla, oraz przycisk powrotu u dolu panelu
*/
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawImage(bgMenu, 0, 0, 1024, 768, null);
g.setFont(new Font("Arial",Font.BOLD, 60));
g.setColor(Color.WHITE);
/** Narysowanie lini obszaru przycisku powrotu */
g.drawLine(0,658,1024,658);
g.drawString("BACK", 420,718);
}
}
| /** Deklaracja Tabeli, przeznaczonej do prezentowania wynikow */ | package GameCore;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Obiekt <code>ScoreBoard</code> reprezentuje panel z tablica wynikow.
* W panelu znajdziemy tablice z wynikami odczytanymi z pliku tekstowego oraz przycisk powrotu do Menu
*
* @author Tomasz Gruzdzis
*/
public class ScoreBoard extends JPanel
{
/** Zmienna przechowujaca obrazek tla */
private Image bgMenu = new ImageIcon(getClass().getResource("/Resources/bgMenu.gif")).getImage();
/** Deklaracja Tabeli, przeznaczonej <SUF>*/
private JTable scoreTable;
/** Zadeklarowanie kolum jakie beda uzywane w tabeli */
private String[] columnNames = {"Date", "Player Name", "Time", "Wrong answers"};
/**
* Konstruktor domyslny.
*/
ScoreBoard()
{
this.setLayout( new FlowLayout() );
/**
* Stworzenie obiektu tabeli, nie posiadajacej kolumn i wierszy.
* Kolumny i wiersze dodane zostaja w readScore()
* @see GameCore.ScoreBoard#readScore()
*/
scoreTable = new JTable(0,0);
readScore();
/** Ustawienie maksymalnych wymiarow tabeli, a takze koloru tla i czcionki */
scoreTable.setPreferredScrollableViewportSize(new Dimension(800,300));
scoreTable.setFillsViewportHeight(true);
scoreTable.setBackground(Color.BLACK);
scoreTable.setFont(new Font("Arial",Font.PLAIN, 20));
scoreTable.setForeground(Color.WHITE);
/** Wprowadzenie domyslnego sortowania
* pozwala miedzy innymi na zmiane trybu prezentowania wynikow wzgledem daty
*/
scoreTable.setAutoCreateRowSorter(true);
/** Zablokowanie mozliwosci edytowania z punktu programu */
scoreTable.setEnabled(false);
/** Deklaracja scrollPane, wprowadza suwak, ktory umozliwia gromadzenie wiekszej ilosci danych w tabeli */
JScrollPane scrollPane = new JScrollPane(scoreTable);
add(scrollPane);
}
/**
* Metoda odczytujaca dane z pliku i zapisujaca je do tabeli
*/
public void readScore()
{
try
{
/** Otwarcie strumienia odczytujacego i wybranie pliku z wynikami
* @see GameWindow#finishTheGame()
*/
BufferedReader scoreRead = new BufferedReader (new FileReader("score.txt"));
DefaultTableModel model = (DefaultTableModel)scoreTable.getModel();
/** Zapisanie lini do tablicy */
Object [] tableLines = scoreRead.lines().toArray();
/** Ustawienie kolumn tabeli */
model.setColumnIdentifiers(columnNames);
if(scoreTable.getRowCount() != 0)
{
/** Jezeli tablica nie jest pusta, dodany do tablicy zostanie tylko ostatni wiersz w pliku tekstowym
* @see GameWindow#finishTheGame()
*/
String line = tableLines[tableLines.length - 1].toString().trim();
/** Podzial pobranej lini wzgledem znaku "/" */
String[] dataRow = line.split("/");
/** Dodanie wiersza do tabeli */
model.addRow(dataRow);
}
else
{
/** Jezeli tablica jest pusta, dodany do tablicy zostana wszystkie wiersze w pliku tekstowym
* @see ScoreBoard#ScoreBoard()
*/
for(int i = 0; i < tableLines.length; i++)
{
/** Do <code>line</code> zostana przypisane kolejne wiersze w pliku tekstowym
* Po kazdym wieszu nastepuje dodanie do tabeli
*/
String line = tableLines[i].toString().trim();
String[] dataRow = line.split("/");
model.addRow(dataRow);
}
}
/** Zamkniecie strumienia*/
scoreRead.close();
}
catch (IOException e)
{
System.err.println(e.getMessage());
}
}
/**
* Metoda rysujaca obraz tla, oraz przycisk powrotu u dolu panelu
*/
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawImage(bgMenu, 0, 0, 1024, 768, null);
g.setFont(new Font("Arial",Font.BOLD, 60));
g.setColor(Color.WHITE);
/** Narysowanie lini obszaru przycisku powrotu */
g.drawLine(0,658,1024,658);
g.drawString("BACK", 420,718);
}
}
| f | null |
358 | 8265_0 | TajneStudio/KwadrateX | 375 | STARA_WERSJA_PROJEKTU/KwadrateX - Stary kod/src/interfejsy/zmienneGlobalne.java | package interfejsy;
import java.util.Timer;
import obiektyPlanszy.stworek;
import listenery.klawiaturaOpcje;
import timery.glowneZadanieTimera;
/**
* Interfjes zawierajacy zmienne Globalne gry
*
* UWAGA! Tutaj wrzucamy zmienne statyczne, ktore nigdy nie zmienia swojej
* wartosci, a przydadza sie w weikszej ilosci klas
*
* @author Lukasz Flak
*
*/
public interface zmienneGlobalne {
String tytulGry = "KwadrateX";
int szerokoscAplikacji = 480;
int wysokoscAplikacji = 640;
int wysokoscEkranuStworka = 501;
//120fps zatrzymanie 1000/120 ok. 8
long klatkiNaSekunde = 8;
//obsluga zdarzen klawiatury
klawiaturaOpcje klawiaturaListener = new klawiaturaOpcje();
//timer
Timer zegarGry = new Timer();
//zadania timera
glowneZadanieTimera glowneZadania = new glowneZadanieTimera();
}
| /**
* Interfjes zawierajacy zmienne Globalne gry
*
* UWAGA! Tutaj wrzucamy zmienne statyczne, ktore nigdy nie zmienia swojej
* wartosci, a przydadza sie w weikszej ilosci klas
*
* @author Lukasz Flak
*
*/ | package interfejsy;
import java.util.Timer;
import obiektyPlanszy.stworek;
import listenery.klawiaturaOpcje;
import timery.glowneZadanieTimera;
/**
* Interfjes zawierajacy zmienne <SUF>*/
public interface zmienneGlobalne {
String tytulGry = "KwadrateX";
int szerokoscAplikacji = 480;
int wysokoscAplikacji = 640;
int wysokoscEkranuStworka = 501;
//120fps zatrzymanie 1000/120 ok. 8
long klatkiNaSekunde = 8;
//obsluga zdarzen klawiatury
klawiaturaOpcje klawiaturaListener = new klawiaturaOpcje();
//timer
Timer zegarGry = new Timer();
//zadania timera
glowneZadanieTimera glowneZadania = new glowneZadanieTimera();
}
| f | null |
359 | 8325_25 | Tay0108/GPS | 4,352 | src/robots/Controller.java | package robots;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.control.TextField;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import java.net.URL;
import java.util.ArrayList;
import java.util.ResourceBundle;
import java.util.concurrent.ThreadLocalRandom;
public class Controller implements Initializable {
private Stage stage;
private ArrayList<Robot> robots = new ArrayList<>();
private Transmitter transmitterA;
private Transmitter transmitterB;
private Transmitter transmitterC;
private Robot closestRobotA; // robot closest to transmitter A
private Robot closestRobotB; // B
private Robot closestRobotC; // C
private Robot ourRobot;
private int robotsCount;
private int robotRadius = 8;
private int transmitterRadius = 10;
@FXML
TextField robotsCountText;
@FXML
private Text message;
@FXML
private Canvas coordinateSystem;
private GraphicsContext gc;
private double triangleArea(double edge1, double edge2, double edge3) {
double p = (edge1 + edge2 + edge3) / 2; // polowa obwodu
return Math.sqrt(p * (p - edge1) * (p - edge2) * (p - edge3));
}
private boolean isRobotSafe(Robot robot) {
double AB = Math.sqrt(Math.pow(transmitterA.getX() - transmitterB.getX(), 2) + Math.pow(transmitterA.getY() - transmitterB.getY(), 2));
double AC = Math.sqrt(Math.pow(transmitterA.getX() - transmitterC.getX(), 2) + Math.pow(transmitterA.getY() - transmitterC.getY(), 2));
double BC = Math.sqrt(Math.pow(transmitterB.getX() - transmitterC.getX(), 2) + Math.pow(transmitterB.getY() - transmitterC.getY(), 2));
double PA = Math.sqrt(Math.pow(robot.getX() - transmitterA.getX(), 2) + Math.pow(robot.getY() - transmitterA.getY(), 2));
double PB = Math.sqrt(Math.pow(robot.getX() - transmitterB.getX(), 2) + Math.pow(robot.getY() - transmitterB.getY(), 2));
double PC = Math.sqrt(Math.pow(robot.getX() - transmitterC.getX(), 2) + Math.pow(robot.getY() - transmitterC.getY(), 2));
double realTriangleArea = triangleArea(AB, AC, BC);
double smallTriangle1 = triangleArea(AB, PA, PB);
double smallTriangle2 = triangleArea(AC, PA, PC);
double smallTriangle3 = triangleArea(BC, PB, PC);
return Math.abs(realTriangleArea - (smallTriangle1 + smallTriangle2 + smallTriangle3)) < 100;
}
private boolean isRobotRelativelySafe(Robot ourRobot) {
// pierwszy pomysł - pola trójkątów
/*
Łączysz P z wierzchołkami A, B i C. Liczysz pole trójkąta ABC i pola małych trójkątów ABP, BCP i ACP.
Jeśli suma pól małych trójkątów jest równa polu trójkąta ABC to P jest wewnątrz niego. Uwaga - pamietaj o przyblizeniu,
trojkaty pewnie nie beda dokladnie identyczne
*/
// usrednianie bokow
/* int AB = (closestRobotA.getDistanceB() + closestRobotB.getDistanceA()) / 2;
int AC = (closestRobotA.getDistanceC() + closestRobotC.getDistanceA()) / 2;
int BC = (closestRobotB.getDistanceC() + closestRobotC.getDistanceB()) / 2;
int bigTriangle = triangleArea(AB, AC, BC); // may be problematic
int smallTriangle1 = triangleArea(ourRobot.getDistanceA(), ourRobot.getDistanceB(), AB);
int smallTriangle2 = triangleArea(ourRobot.getDistanceA(), ourRobot.getDistanceC(), AC);
int smallTriangle3 = triangleArea(ourRobot.getDistanceB(), ourRobot.getDistanceC(), BC);
System.out.println(bigTriangle);
System.out.println(smallTriangle1);
System.out.println(smallTriangle2);
System.out.println(smallTriangle3);
return Math.abs(bigTriangle - (smallTriangle1 + smallTriangle2 + smallTriangle3)) < 0; // tolerancja*/
// nowy pomysl, z ukladem wspolrzednych:
// usadawiamy dwa punkty na osi OX:
double Ax = 0;
double Ay = 0;
double Bx = closestRobotB.getDistanceA();
double By = 0;
double Cx; // punkt nieznany, jego wspolrzedne musimy wyliczyć znając pozycje dwóch pozostałych, oraz mając przybliżone długości boków trójkąta
double Cy;
double ac = closestRobotC.getDistanceA();
double bc = closestRobotC.getDistanceB();
double ab = closestRobotB.getDistanceA();
// dwa równania odległości - od punktu A i B.
Cx = (ac * ac - bc * bc - ab * ab) / (-2 * ab);
Cy = Math.sqrt(Math.abs(ac * ac - Cx * Cx)); // TODO abs
// okrąg A: x^2+y^2 = ourRobot.getDistanceA^2;
// okrąg B: (x-1)^2 +y^2 = ourRobot.getDistanceB^2;
// okrąg C: (x-Cx)^2+(y-Cy)^2 = ourRobot.getDistanceC^2;
// mamy juz wszystkie wspolrzedne trojkąta. Teraz triangulacją wyliczamy współrzędne naszego robota:
double a = ourRobot.getDistanceA();
double b = ourRobot.getDistanceB();
double c = ourRobot.getDistanceC();
System.out.println("|PA|: " + a);
System.out.println("|PB|: " + b);
System.out.println("|PC|: " + c);
System.out.println("|AB|: " + ab);
System.out.println("|AC|: " + ac);
System.out.println("|BC|: " + bc);
double Px = (a * a - b * b + ab * ab) / (2 * ab); // wspolrzedne naszego robota
double Py = Math.sqrt(Math.abs(a * a - Px * Px)); // TODO abs
// mamy juz wszystkie potrzebne punkty:
System.out.println("A: " + Ax + " " + Ay);
System.out.println("B: " + Bx + " " + By);
System.out.println("C: " + Cx + " " + Cy);
System.out.println("P: " + Px + " " + Py);
// Sprawdzenie, czy punkt P jest w trójkącie:
// wyznaczam proste, na ktorych lezy trójkąt (wyznaczyłem na kartce):
/*
trzy wyrazenia, którym sprawdzam znaki (http://www.math.us.edu.pl/pgladki/faq/node105.html):
*/
double Ap = Ay - By;
double Bp = Bx - Ax;
double Cp = -Ay * Bx + Ax * Ay + By * Ax - Ay * Ax;
double Aq = Ay - Cy;
double Bq = Cx - Ax;
double Cq = -Ay * Cx + Ax * Ay + Cy * Ay - Ay * Ax;
double Ar = By - Cy;
double Br = Cx - Bx;
double Cr = -By * Cx + Bx * By + Cy * Bx - By * Bx;
if ((Ap * Cx + Bp * Cy + Cp) * (Ap * Px + Bp * Py + Cp) >= 0 && (Aq * Bx + Bq * By + Cq) * (Aq * Px + Bq * Py + Cq) >= 0 && (Ar * Ax + Br * Ay + Cr) * (Ar * Px + Br * Py + Cr) >= 0) {
return true;
}
return false;
}
@FXML
private void generateWorld() {
robotsCount = Integer.parseInt(robotsCountText.getText());
message.setText("");
// umiesc anteny w trzech losowych miejscach plaszczyzny:
int minX = 0;
int minY = 0;
int maxX = 660;
int maxY = 480;
// clear canvas and list:
gc.clearRect(minX, minY, maxX, maxY);
robots.clear();
int x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
int y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
transmitterA = new Transmitter(x, y);
x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
transmitterB = new Transmitter(x, y);
x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
transmitterC = new Transmitter(x, y);
// dodaj roboty w losowych miejscach plaszczyzny:
for (int i = 0; i < robotsCount; i++) {
x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
double distanceA = Math.sqrt(Math.pow(transmitterA.getX() - x, 2) + Math.pow(transmitterA.getY() - y, 2));
double distanceB = Math.sqrt(Math.pow(transmitterB.getX() - x, 2) + Math.pow(transmitterB.getY() - y, 2));
double distanceC = Math.sqrt(Math.pow(transmitterC.getX() - x, 2) + Math.pow(transmitterC.getY() - y, 2));
robots.add(new Robot(x, y, distanceA, distanceB, distanceC));
}
// znajdz roboty najblizej anten i zmien ich typ na roboty antenowe:
closestRobotA = robots.get(0);
closestRobotB = robots.get(0);
closestRobotC = robots.get(0);
for (Robot current : robots) {
if (current.getDistanceA() < closestRobotA.getDistanceA()) {
closestRobotA = current;
}
if (current.getDistanceB() < closestRobotB.getDistanceB()) {
closestRobotB = current;
}
if (current.getDistanceC() < closestRobotC.getDistanceC()) {
closestRobotC = current;
}
}
closestRobotA.setType(1); // changing to 'satelite'
closestRobotB.setType(1);
closestRobotC.setType(1);
// jesli nie ma trzech robotow, tylko ktorys jest najblizej dwoch badz trzech wierzcholkow:
if (closestRobotA == closestRobotB && closestRobotB == closestRobotC) { // kolko jak jest jeden punkt
}
// z pozostalych robotow (WHERE type = 0) wybierz losowo jednego i sprawdz czy jest bezpieczny:
// losuje dopoki nie wylosuje jakiegos nietransmitera
while (true) {
ourRobot = robots.get(ThreadLocalRandom.current().nextInt(0, robots.size()));
if (ourRobot.getType() == 0) {
ourRobot.setType(2);
break;
}
}
// wyswietl stosowna informacje:
//if (isRobotSafe(ourRobot)) {
// System.out.println("Robot jest bezpieczny.");
//}
/*if (isRobotRelativelySafe(ourRobot)) {
if (isRobotSafe(ourRobot)) {
message.setText("Komunikat: Robot jest bezpieczny.");
System.out.println("Robot jest bezpieczny.");
} else {
message.setText("Komunikat: Robot jest względnie bezpieczny, ale tak naprawdę to nie.");
System.out.println("Robot jest względnie bezpieczny, ale tak naprawdę to nie.");
}
} else {
message.setText("Komunikat: Robot jest w niebezpieczeństwie.");
System.out.println("Robot jest w niebezpieczeństwie.");
}
*/
if (isRobotSafe(ourRobot)) {
message.setText("Komunikat: Robot jest bezpieczny.");
System.out.println("Robot jest bezpieczny.");
} else {
message.setText("Komunikat: Robot jest w niebezpieczeństwie.");
System.out.println("Robot jest w niebezpieczeństwie.");
}
drawWorld();
}
private void drawWorld() {
gc.setFill(Color.BLUEVIOLET);
gc.fillOval(transmitterA.getX() - transmitterRadius / 2, transmitterA.getY() - transmitterRadius / 2, transmitterRadius, transmitterRadius);
gc.fillOval(transmitterB.getX() - transmitterRadius / 2, transmitterB.getY() - transmitterRadius / 2, transmitterRadius, transmitterRadius);
gc.fillOval(transmitterC.getX() - transmitterRadius / 2, transmitterC.getY() - transmitterRadius / 2, transmitterRadius, transmitterRadius);
gc.setStroke(Color.BLUEVIOLET);
gc.strokeLine(transmitterA.getX(), transmitterA.getY(), transmitterB.getX(), transmitterB.getY());
gc.strokeLine(transmitterA.getX(), transmitterA.getY(), transmitterC.getX(), transmitterC.getY());
gc.strokeLine(transmitterB.getX(), transmitterB.getY(), transmitterC.getX(), transmitterC.getY());
for (Robot current : robots) {
if (current.getType() == 0) {
gc.setFill(Color.GREEN);
} else if (current.getType() == 1) {
gc.setFill(Color.RED);
} else if (current.getType() == 2) {
gc.setFill(Color.YELLOW);
}
gc.fillOval(current.getX() - robotRadius / 2, current.getY() - robotRadius / 2, robotRadius, robotRadius);
}
gc.setStroke(Color.RED);
gc.strokeLine(closestRobotA.getX(), closestRobotA.getY(), closestRobotB.getX(), closestRobotB.getY());
gc.strokeLine(closestRobotA.getX(), closestRobotA.getY(), closestRobotC.getX(), closestRobotC.getY());
gc.strokeLine(closestRobotB.getX(), closestRobotB.getY(), closestRobotC.getX(), closestRobotC.getY());
}
@FXML
public void initialize(URL url, ResourceBundle rb) {
gc = coordinateSystem.getGraphicsContext2D();
robotsCountText.setText("500");
}
}
| // losuje dopoki nie wylosuje jakiegos nietransmitera | package robots;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.control.TextField;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import java.net.URL;
import java.util.ArrayList;
import java.util.ResourceBundle;
import java.util.concurrent.ThreadLocalRandom;
public class Controller implements Initializable {
private Stage stage;
private ArrayList<Robot> robots = new ArrayList<>();
private Transmitter transmitterA;
private Transmitter transmitterB;
private Transmitter transmitterC;
private Robot closestRobotA; // robot closest to transmitter A
private Robot closestRobotB; // B
private Robot closestRobotC; // C
private Robot ourRobot;
private int robotsCount;
private int robotRadius = 8;
private int transmitterRadius = 10;
@FXML
TextField robotsCountText;
@FXML
private Text message;
@FXML
private Canvas coordinateSystem;
private GraphicsContext gc;
private double triangleArea(double edge1, double edge2, double edge3) {
double p = (edge1 + edge2 + edge3) / 2; // polowa obwodu
return Math.sqrt(p * (p - edge1) * (p - edge2) * (p - edge3));
}
private boolean isRobotSafe(Robot robot) {
double AB = Math.sqrt(Math.pow(transmitterA.getX() - transmitterB.getX(), 2) + Math.pow(transmitterA.getY() - transmitterB.getY(), 2));
double AC = Math.sqrt(Math.pow(transmitterA.getX() - transmitterC.getX(), 2) + Math.pow(transmitterA.getY() - transmitterC.getY(), 2));
double BC = Math.sqrt(Math.pow(transmitterB.getX() - transmitterC.getX(), 2) + Math.pow(transmitterB.getY() - transmitterC.getY(), 2));
double PA = Math.sqrt(Math.pow(robot.getX() - transmitterA.getX(), 2) + Math.pow(robot.getY() - transmitterA.getY(), 2));
double PB = Math.sqrt(Math.pow(robot.getX() - transmitterB.getX(), 2) + Math.pow(robot.getY() - transmitterB.getY(), 2));
double PC = Math.sqrt(Math.pow(robot.getX() - transmitterC.getX(), 2) + Math.pow(robot.getY() - transmitterC.getY(), 2));
double realTriangleArea = triangleArea(AB, AC, BC);
double smallTriangle1 = triangleArea(AB, PA, PB);
double smallTriangle2 = triangleArea(AC, PA, PC);
double smallTriangle3 = triangleArea(BC, PB, PC);
return Math.abs(realTriangleArea - (smallTriangle1 + smallTriangle2 + smallTriangle3)) < 100;
}
private boolean isRobotRelativelySafe(Robot ourRobot) {
// pierwszy pomysł - pola trójkątów
/*
Łączysz P z wierzchołkami A, B i C. Liczysz pole trójkąta ABC i pola małych trójkątów ABP, BCP i ACP.
Jeśli suma pól małych trójkątów jest równa polu trójkąta ABC to P jest wewnątrz niego. Uwaga - pamietaj o przyblizeniu,
trojkaty pewnie nie beda dokladnie identyczne
*/
// usrednianie bokow
/* int AB = (closestRobotA.getDistanceB() + closestRobotB.getDistanceA()) / 2;
int AC = (closestRobotA.getDistanceC() + closestRobotC.getDistanceA()) / 2;
int BC = (closestRobotB.getDistanceC() + closestRobotC.getDistanceB()) / 2;
int bigTriangle = triangleArea(AB, AC, BC); // may be problematic
int smallTriangle1 = triangleArea(ourRobot.getDistanceA(), ourRobot.getDistanceB(), AB);
int smallTriangle2 = triangleArea(ourRobot.getDistanceA(), ourRobot.getDistanceC(), AC);
int smallTriangle3 = triangleArea(ourRobot.getDistanceB(), ourRobot.getDistanceC(), BC);
System.out.println(bigTriangle);
System.out.println(smallTriangle1);
System.out.println(smallTriangle2);
System.out.println(smallTriangle3);
return Math.abs(bigTriangle - (smallTriangle1 + smallTriangle2 + smallTriangle3)) < 0; // tolerancja*/
// nowy pomysl, z ukladem wspolrzednych:
// usadawiamy dwa punkty na osi OX:
double Ax = 0;
double Ay = 0;
double Bx = closestRobotB.getDistanceA();
double By = 0;
double Cx; // punkt nieznany, jego wspolrzedne musimy wyliczyć znając pozycje dwóch pozostałych, oraz mając przybliżone długości boków trójkąta
double Cy;
double ac = closestRobotC.getDistanceA();
double bc = closestRobotC.getDistanceB();
double ab = closestRobotB.getDistanceA();
// dwa równania odległości - od punktu A i B.
Cx = (ac * ac - bc * bc - ab * ab) / (-2 * ab);
Cy = Math.sqrt(Math.abs(ac * ac - Cx * Cx)); // TODO abs
// okrąg A: x^2+y^2 = ourRobot.getDistanceA^2;
// okrąg B: (x-1)^2 +y^2 = ourRobot.getDistanceB^2;
// okrąg C: (x-Cx)^2+(y-Cy)^2 = ourRobot.getDistanceC^2;
// mamy juz wszystkie wspolrzedne trojkąta. Teraz triangulacją wyliczamy współrzędne naszego robota:
double a = ourRobot.getDistanceA();
double b = ourRobot.getDistanceB();
double c = ourRobot.getDistanceC();
System.out.println("|PA|: " + a);
System.out.println("|PB|: " + b);
System.out.println("|PC|: " + c);
System.out.println("|AB|: " + ab);
System.out.println("|AC|: " + ac);
System.out.println("|BC|: " + bc);
double Px = (a * a - b * b + ab * ab) / (2 * ab); // wspolrzedne naszego robota
double Py = Math.sqrt(Math.abs(a * a - Px * Px)); // TODO abs
// mamy juz wszystkie potrzebne punkty:
System.out.println("A: " + Ax + " " + Ay);
System.out.println("B: " + Bx + " " + By);
System.out.println("C: " + Cx + " " + Cy);
System.out.println("P: " + Px + " " + Py);
// Sprawdzenie, czy punkt P jest w trójkącie:
// wyznaczam proste, na ktorych lezy trójkąt (wyznaczyłem na kartce):
/*
trzy wyrazenia, którym sprawdzam znaki (http://www.math.us.edu.pl/pgladki/faq/node105.html):
*/
double Ap = Ay - By;
double Bp = Bx - Ax;
double Cp = -Ay * Bx + Ax * Ay + By * Ax - Ay * Ax;
double Aq = Ay - Cy;
double Bq = Cx - Ax;
double Cq = -Ay * Cx + Ax * Ay + Cy * Ay - Ay * Ax;
double Ar = By - Cy;
double Br = Cx - Bx;
double Cr = -By * Cx + Bx * By + Cy * Bx - By * Bx;
if ((Ap * Cx + Bp * Cy + Cp) * (Ap * Px + Bp * Py + Cp) >= 0 && (Aq * Bx + Bq * By + Cq) * (Aq * Px + Bq * Py + Cq) >= 0 && (Ar * Ax + Br * Ay + Cr) * (Ar * Px + Br * Py + Cr) >= 0) {
return true;
}
return false;
}
@FXML
private void generateWorld() {
robotsCount = Integer.parseInt(robotsCountText.getText());
message.setText("");
// umiesc anteny w trzech losowych miejscach plaszczyzny:
int minX = 0;
int minY = 0;
int maxX = 660;
int maxY = 480;
// clear canvas and list:
gc.clearRect(minX, minY, maxX, maxY);
robots.clear();
int x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
int y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
transmitterA = new Transmitter(x, y);
x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
transmitterB = new Transmitter(x, y);
x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
transmitterC = new Transmitter(x, y);
// dodaj roboty w losowych miejscach plaszczyzny:
for (int i = 0; i < robotsCount; i++) {
x = ThreadLocalRandom.current().nextInt(minX, maxX + 1);
y = ThreadLocalRandom.current().nextInt(minY, maxY + 1);
double distanceA = Math.sqrt(Math.pow(transmitterA.getX() - x, 2) + Math.pow(transmitterA.getY() - y, 2));
double distanceB = Math.sqrt(Math.pow(transmitterB.getX() - x, 2) + Math.pow(transmitterB.getY() - y, 2));
double distanceC = Math.sqrt(Math.pow(transmitterC.getX() - x, 2) + Math.pow(transmitterC.getY() - y, 2));
robots.add(new Robot(x, y, distanceA, distanceB, distanceC));
}
// znajdz roboty najblizej anten i zmien ich typ na roboty antenowe:
closestRobotA = robots.get(0);
closestRobotB = robots.get(0);
closestRobotC = robots.get(0);
for (Robot current : robots) {
if (current.getDistanceA() < closestRobotA.getDistanceA()) {
closestRobotA = current;
}
if (current.getDistanceB() < closestRobotB.getDistanceB()) {
closestRobotB = current;
}
if (current.getDistanceC() < closestRobotC.getDistanceC()) {
closestRobotC = current;
}
}
closestRobotA.setType(1); // changing to 'satelite'
closestRobotB.setType(1);
closestRobotC.setType(1);
// jesli nie ma trzech robotow, tylko ktorys jest najblizej dwoch badz trzech wierzcholkow:
if (closestRobotA == closestRobotB && closestRobotB == closestRobotC) { // kolko jak jest jeden punkt
}
// z pozostalych robotow (WHERE type = 0) wybierz losowo jednego i sprawdz czy jest bezpieczny:
// losuje dopoki <SUF>
while (true) {
ourRobot = robots.get(ThreadLocalRandom.current().nextInt(0, robots.size()));
if (ourRobot.getType() == 0) {
ourRobot.setType(2);
break;
}
}
// wyswietl stosowna informacje:
//if (isRobotSafe(ourRobot)) {
// System.out.println("Robot jest bezpieczny.");
//}
/*if (isRobotRelativelySafe(ourRobot)) {
if (isRobotSafe(ourRobot)) {
message.setText("Komunikat: Robot jest bezpieczny.");
System.out.println("Robot jest bezpieczny.");
} else {
message.setText("Komunikat: Robot jest względnie bezpieczny, ale tak naprawdę to nie.");
System.out.println("Robot jest względnie bezpieczny, ale tak naprawdę to nie.");
}
} else {
message.setText("Komunikat: Robot jest w niebezpieczeństwie.");
System.out.println("Robot jest w niebezpieczeństwie.");
}
*/
if (isRobotSafe(ourRobot)) {
message.setText("Komunikat: Robot jest bezpieczny.");
System.out.println("Robot jest bezpieczny.");
} else {
message.setText("Komunikat: Robot jest w niebezpieczeństwie.");
System.out.println("Robot jest w niebezpieczeństwie.");
}
drawWorld();
}
private void drawWorld() {
gc.setFill(Color.BLUEVIOLET);
gc.fillOval(transmitterA.getX() - transmitterRadius / 2, transmitterA.getY() - transmitterRadius / 2, transmitterRadius, transmitterRadius);
gc.fillOval(transmitterB.getX() - transmitterRadius / 2, transmitterB.getY() - transmitterRadius / 2, transmitterRadius, transmitterRadius);
gc.fillOval(transmitterC.getX() - transmitterRadius / 2, transmitterC.getY() - transmitterRadius / 2, transmitterRadius, transmitterRadius);
gc.setStroke(Color.BLUEVIOLET);
gc.strokeLine(transmitterA.getX(), transmitterA.getY(), transmitterB.getX(), transmitterB.getY());
gc.strokeLine(transmitterA.getX(), transmitterA.getY(), transmitterC.getX(), transmitterC.getY());
gc.strokeLine(transmitterB.getX(), transmitterB.getY(), transmitterC.getX(), transmitterC.getY());
for (Robot current : robots) {
if (current.getType() == 0) {
gc.setFill(Color.GREEN);
} else if (current.getType() == 1) {
gc.setFill(Color.RED);
} else if (current.getType() == 2) {
gc.setFill(Color.YELLOW);
}
gc.fillOval(current.getX() - robotRadius / 2, current.getY() - robotRadius / 2, robotRadius, robotRadius);
}
gc.setStroke(Color.RED);
gc.strokeLine(closestRobotA.getX(), closestRobotA.getY(), closestRobotB.getX(), closestRobotB.getY());
gc.strokeLine(closestRobotA.getX(), closestRobotA.getY(), closestRobotC.getX(), closestRobotC.getY());
gc.strokeLine(closestRobotB.getX(), closestRobotB.getY(), closestRobotC.getX(), closestRobotC.getY());
}
@FXML
public void initialize(URL url, ResourceBundle rb) {
gc = coordinateSystem.getGraphicsContext2D();
robotsCountText.setText("500");
}
}
| f | null |
360 | 6533_1 | Tay0108/JIMP3 | 261 | lab3/zad3.4_m/src/Main.java | import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
Kwadrat k1 = new Kwadrat();
Koło k2 = new Koło();
Trójkąt k3 = new Trójkąt();
/* //Wywołanie metod z obiektów klas pochodnych
k1.draw();
k2.draw();
k3.draw();*/
//wywołnie metod, korzystając z metody abstarkcyjnej klasy podstawowej
System.out.println(Shape.listOfShapes);
LinkedList<Object> jakasLista= new LinkedList<>();
jakasLista.addLast(k1);
jakasLista.addLast(k2);
jakasLista.addLast(k3);
//TODO narawic to tam żeby można było wywoływać metodę draw() z listy obiektów dziedziczących po klasie Shape
}
}
| //wywołnie metod, korzystając z metody abstarkcyjnej klasy podstawowej | import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
Kwadrat k1 = new Kwadrat();
Koło k2 = new Koło();
Trójkąt k3 = new Trójkąt();
/* //Wywołanie metod z obiektów klas pochodnych
k1.draw();
k2.draw();
k3.draw();*/
//wywołnie metod, <SUF>
System.out.println(Shape.listOfShapes);
LinkedList<Object> jakasLista= new LinkedList<>();
jakasLista.addLast(k1);
jakasLista.addLast(k2);
jakasLista.addLast(k3);
//TODO narawic to tam żeby można było wywoływać metodę draw() z listy obiektów dziedziczących po klasie Shape
}
}
| f | null |
361 | 9955_3 | TeRed/PO | 312 | src/lab1/e4/Login.java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package lab1.e4;
/**
*
* @author Szymon
*/
public class Login {
private String login;
private String password;
/**
*
* @param _login login jaki dana instancja klasy będzie przechowywać
* @param _password hasło jakie dana instancja klasy będzie przechowywać
*/
public Login(String _login, String _password){
login = _login;
password = _password;
}
/**
*
* @param _login login do porównania z przechowywanym wewnątrz obiektu
* @param _password hasło do porównania z przechowywanym wewnatrz obiektu
* @return prawda, gdy login i hasło zgadzaja sie, fałsz gdy albo login albo hasło nie pasuje do tych rpzechowywanych przez instancję kalsy
*/
public boolean check(String _login, String _password){
return (_password.equals(password) && _login.equals(login));
}
}
| /**
*
* @param _login login do porównania z przechowywanym wewnątrz obiektu
* @param _password hasło do porównania z przechowywanym wewnatrz obiektu
* @return prawda, gdy login i hasło zgadzaja sie, fałsz gdy albo login albo hasło nie pasuje do tych rpzechowywanych przez instancję kalsy
*/ | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package lab1.e4;
/**
*
* @author Szymon
*/
public class Login {
private String login;
private String password;
/**
*
* @param _login login jaki dana instancja klasy będzie przechowywać
* @param _password hasło jakie dana instancja klasy będzie przechowywać
*/
public Login(String _login, String _password){
login = _login;
password = _password;
}
/**
*
* @param _login login <SUF>*/
public boolean check(String _login, String _password){
return (_password.equals(password) && _login.equals(login));
}
}
| f | null |
362 | 7627_13 | Technikum-TEB-Edukacja-we-Wroclawiu/INF.04-rozwiazania | 1,018 | INF.04-informator/mobilna/MainActivity.java | package com.example.inf04_informator;
import androidx.appcompat.app.AppCompatActivity;
import android.graphics.Color;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.View;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Switch;
import android.widget.Toast;
public class MainActivity extends AppCompatActivity {
private final int[] images = {
R.drawable.kot1,
R.drawable.kot2,
R.drawable.kot3,
R.drawable.kot4
};
ImageView iv; // Dostęp do ImageView z obrazkiem kota
EditText etImageNumber; // Dostęp do EditText z numerem obrazka
Switch switchBackground; // Dostęp do Switcha
LinearLayout layout; // Dostęp do layoutu aplikacji (żeby potem zmienić tło)
int current_image = 0; // Indeks bieżącego obrazka - standardowo od 0
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
iv = findViewById(R.id.imageView);
etImageNumber = findViewById(R.id.editTextNumber);
switchBackground = findViewById(R.id.switchBackground);
layout = findViewById(R.id.layout);
etImageNumber.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void afterTextChanged(Editable editable) {
String imageNumberInput = editable.toString();
int imageNumber;
try {
imageNumber = Integer.parseInt(imageNumberInput);
} catch(NumberFormatException ex) {
return;
}
if(imageNumber >= 1 && imageNumber <= images.length) {
current_image = imageNumber - 1;
iv.setImageResource(images[current_image]);
}
}
});
switchBackground.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
if(b) {
// ustaw tło na niebieski
layout.setBackgroundColor(Color.parseColor("#1565c0"));
} else {
// ustaw tło na standardowe
layout.setBackgroundColor(Color.parseColor("#00796B"));
}
}
});
}
public void onClickBtnNext(View view) {
current_image = (current_image + 1) % images.length;
iv.setImageResource(images[current_image]);
// I sposób wprowadzenia liczby do pola tekstowego
// - ustalenie wartości i konwersja jej przez Integer.toString()
int image_number = current_image + 1;
etImageNumber.setText(Integer.toString(image_number));
}
public void onClickBtnPrev(View view) {
// 0 - 1 = -1
// (-1) mod 4 = 3
// niestety operator% w Javie nie działa tak jak w Pythonie
current_image = current_image - 1;
if(current_image < 0) {
current_image += images.length; // np. -1 + 4 = 3
}
iv.setImageResource(images[current_image]);
// II sposób wprowadzenia - String.format()
etImageNumber.setText(String.format("%d", current_image + 1));
}
}
| // II sposób wprowadzenia - String.format() | package com.example.inf04_informator;
import androidx.appcompat.app.AppCompatActivity;
import android.graphics.Color;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.View;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Switch;
import android.widget.Toast;
public class MainActivity extends AppCompatActivity {
private final int[] images = {
R.drawable.kot1,
R.drawable.kot2,
R.drawable.kot3,
R.drawable.kot4
};
ImageView iv; // Dostęp do ImageView z obrazkiem kota
EditText etImageNumber; // Dostęp do EditText z numerem obrazka
Switch switchBackground; // Dostęp do Switcha
LinearLayout layout; // Dostęp do layoutu aplikacji (żeby potem zmienić tło)
int current_image = 0; // Indeks bieżącego obrazka - standardowo od 0
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
iv = findViewById(R.id.imageView);
etImageNumber = findViewById(R.id.editTextNumber);
switchBackground = findViewById(R.id.switchBackground);
layout = findViewById(R.id.layout);
etImageNumber.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void afterTextChanged(Editable editable) {
String imageNumberInput = editable.toString();
int imageNumber;
try {
imageNumber = Integer.parseInt(imageNumberInput);
} catch(NumberFormatException ex) {
return;
}
if(imageNumber >= 1 && imageNumber <= images.length) {
current_image = imageNumber - 1;
iv.setImageResource(images[current_image]);
}
}
});
switchBackground.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton compoundButton, boolean b) {
if(b) {
// ustaw tło na niebieski
layout.setBackgroundColor(Color.parseColor("#1565c0"));
} else {
// ustaw tło na standardowe
layout.setBackgroundColor(Color.parseColor("#00796B"));
}
}
});
}
public void onClickBtnNext(View view) {
current_image = (current_image + 1) % images.length;
iv.setImageResource(images[current_image]);
// I sposób wprowadzenia liczby do pola tekstowego
// - ustalenie wartości i konwersja jej przez Integer.toString()
int image_number = current_image + 1;
etImageNumber.setText(Integer.toString(image_number));
}
public void onClickBtnPrev(View view) {
// 0 - 1 = -1
// (-1) mod 4 = 3
// niestety operator% w Javie nie działa tak jak w Pythonie
current_image = current_image - 1;
if(current_image < 0) {
current_image += images.length; // np. -1 + 4 = 3
}
iv.setImageResource(images[current_image]);
// II sposób <SUF>
etImageNumber.setText(String.format("%d", current_image + 1));
}
}
| f | null |
363 | 10601_1 | Teserat/Java-learning | 420 | src/Map/Maps.java | package Map;
import Paczka.Pomocnicza.ExtraMethods;
import java.util.HashMap;
import java.util.Map;
public class Maps {
public static void main(String[] args) {
Map<Integer, String> students = new HashMap<>();
students.put(1, "Basia");
students.put(2, "Bobek");
students.put(3, "Basia");
students.put(4, "Tomek");
System.out.println(students.get(1));
System.out.println(students.containsKey(4));
System.out.println(students.containsValue("Robert"));
System.out.println(students.size());
students.remove(1);
System.out.println(students.get(1));
System.out.println(students.size());
ExtraMethods.linia("Wylistowanie kluczy");
//odwołanie do kluczy (klucz zawsze jest unikalny, i zapisanie na nim powoduje nadpisanie)
for(Integer key : students.keySet()){
System.out.println(key);
System.out.println(students.get(key));
}
ExtraMethods.linia("Drugi raz petla po wartościach (niezauwazalne co chodzi o kolejność)");
//odwołanie do wartości (wartości może być wiele takich samych przypisanych do różnych kluczy)
for (String student : students.values()){
System.out.println(student);
}
}
}
| //odwołanie do wartości (wartości może być wiele takich samych przypisanych do różnych kluczy) | package Map;
import Paczka.Pomocnicza.ExtraMethods;
import java.util.HashMap;
import java.util.Map;
public class Maps {
public static void main(String[] args) {
Map<Integer, String> students = new HashMap<>();
students.put(1, "Basia");
students.put(2, "Bobek");
students.put(3, "Basia");
students.put(4, "Tomek");
System.out.println(students.get(1));
System.out.println(students.containsKey(4));
System.out.println(students.containsValue("Robert"));
System.out.println(students.size());
students.remove(1);
System.out.println(students.get(1));
System.out.println(students.size());
ExtraMethods.linia("Wylistowanie kluczy");
//odwołanie do kluczy (klucz zawsze jest unikalny, i zapisanie na nim powoduje nadpisanie)
for(Integer key : students.keySet()){
System.out.println(key);
System.out.println(students.get(key));
}
ExtraMethods.linia("Drugi raz petla po wartościach (niezauwazalne co chodzi o kolejność)");
//odwołanie do <SUF>
for (String student : students.values()){
System.out.println(student);
}
}
}
| f | null |
367 | 10515_0 | ThePundik/java | 1,125 | Student.java | import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
class Student {
private String imie;
private String nazwisko;
private String email;
private List<Obecnosc> obecnosci;
public Student(String imie, String nazwisko, String email) {
this.imie = imie;
this.nazwisko = nazwisko;
this.email = email;
this.obecnosci = new ArrayList<>();
}
public void dodajObecnosc(Obecnosc obecnosc) {
obecnosci.add(obecnosc);
}
public List<Obecnosc> getObecnosci() {
return obecnosci;
}
public String toString() {
return "Student: " + imie + " " + nazwisko + ", Email: " + email;
}
public List<String> przedmiotyZawszeObecny() {
Map<String, Boolean> obecnosciMap = new HashMap<>();
for (Obecnosc obecnosc : obecnosci) {
obecnosciMap.put(obecnosc.getPrzedmiot(), true);
}
List<String> przedmiotyZawszeObecny = new ArrayList<>();
for (Map.Entry<String, Boolean> entry : obecnosciMap.entrySet()) {
if (entry.getValue()) {
przedmiotyZawszeObecny.add(entry.getKey());
}
}
return przedmiotyZawszeObecny;
}
public static boolean sprawdzImie(String imie) {
// Sprawdź, czy imię zawiera tylko litery
return imie.matches("[a-zA-Z]+");
}
public static Student pobierzDaneOdUzytkownika() {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj imię studenta: ");
String imie = scanner.nextLine();
while (!sprawdzImie(imie)) {
System.out.println("Błędne imię. Imię może zawierać tylko litery.");
System.out.print("Podaj imię studenta: ");
imie = scanner.nextLine();
}
System.out.print("Podaj nazwisko studenta: ");
String nazwisko = scanner.nextLine();
System.out.print("Podaj adres e-mail studenta: ");
String email = scanner.nextLine();
return new Student(imie, nazwisko, email);
}
public static void main(String[] args) {
// Przykładowe użycie
Student student = pobierzDaneOdUzytkownika();
Obecnosc obecnosc1 = new Obecnosc("2023-01-01 10:00", "Matematyka", "nn");
Obecnosc obecnosc2 = new Obecnosc("2023-01-02 14:30", "Fizyka", "o");
Obecnosc obecnosc3 = new Obecnosc("2023-01-03 09:45", "Informatyka", "nn");
student.dodajObecnosc(obecnosc1);
student.dodajObecnosc(obecnosc2);
student.dodajObecnosc(obecnosc3);
System.out.println(student.toString());
List<String> przedmiotyZawszeObecny = student.przedmiotyZawszeObecny();
System.out.println("Przedmioty, na których student był zawsze obecny: " + przedmiotyZawszeObecny);
}
}
class Obecnosc {
private String dataGodzina;
private String przedmiot;
private String typObecnosci;
public Obecnosc(String dataGodzina, String przedmiot, String typObecnosci) {
this.dataGodzina = dataGodzina;
this.przedmiot = przedmiot;
this.typObecnosci = typObecnosci;
}
public String getPrzedmiot() {
return przedmiot;
}
} | // Sprawdź, czy imię zawiera tylko litery | import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
class Student {
private String imie;
private String nazwisko;
private String email;
private List<Obecnosc> obecnosci;
public Student(String imie, String nazwisko, String email) {
this.imie = imie;
this.nazwisko = nazwisko;
this.email = email;
this.obecnosci = new ArrayList<>();
}
public void dodajObecnosc(Obecnosc obecnosc) {
obecnosci.add(obecnosc);
}
public List<Obecnosc> getObecnosci() {
return obecnosci;
}
public String toString() {
return "Student: " + imie + " " + nazwisko + ", Email: " + email;
}
public List<String> przedmiotyZawszeObecny() {
Map<String, Boolean> obecnosciMap = new HashMap<>();
for (Obecnosc obecnosc : obecnosci) {
obecnosciMap.put(obecnosc.getPrzedmiot(), true);
}
List<String> przedmiotyZawszeObecny = new ArrayList<>();
for (Map.Entry<String, Boolean> entry : obecnosciMap.entrySet()) {
if (entry.getValue()) {
przedmiotyZawszeObecny.add(entry.getKey());
}
}
return przedmiotyZawszeObecny;
}
public static boolean sprawdzImie(String imie) {
// Sprawdź, czy <SUF>
return imie.matches("[a-zA-Z]+");
}
public static Student pobierzDaneOdUzytkownika() {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj imię studenta: ");
String imie = scanner.nextLine();
while (!sprawdzImie(imie)) {
System.out.println("Błędne imię. Imię może zawierać tylko litery.");
System.out.print("Podaj imię studenta: ");
imie = scanner.nextLine();
}
System.out.print("Podaj nazwisko studenta: ");
String nazwisko = scanner.nextLine();
System.out.print("Podaj adres e-mail studenta: ");
String email = scanner.nextLine();
return new Student(imie, nazwisko, email);
}
public static void main(String[] args) {
// Przykładowe użycie
Student student = pobierzDaneOdUzytkownika();
Obecnosc obecnosc1 = new Obecnosc("2023-01-01 10:00", "Matematyka", "nn");
Obecnosc obecnosc2 = new Obecnosc("2023-01-02 14:30", "Fizyka", "o");
Obecnosc obecnosc3 = new Obecnosc("2023-01-03 09:45", "Informatyka", "nn");
student.dodajObecnosc(obecnosc1);
student.dodajObecnosc(obecnosc2);
student.dodajObecnosc(obecnosc3);
System.out.println(student.toString());
List<String> przedmiotyZawszeObecny = student.przedmiotyZawszeObecny();
System.out.println("Przedmioty, na których student był zawsze obecny: " + przedmiotyZawszeObecny);
}
}
class Obecnosc {
private String dataGodzina;
private String przedmiot;
private String typObecnosci;
public Obecnosc(String dataGodzina, String przedmiot, String typObecnosci) {
this.dataGodzina = dataGodzina;
this.przedmiot = przedmiot;
this.typObecnosci = typObecnosci;
}
public String getPrzedmiot() {
return przedmiot;
}
} | f | null |
370 | 6554_2 | bestemic/Jezyk_Java_2021-2022 | 756 | zad8/src/ShopInterface.java | import java.util.Map;
/**
* Interfejs sklepu. Wszyskie metody mogą być wywoływane współbieżnie. Metoda
* delivery jako jedyna może doprowadzić to zablokowania pracy wywołującego ją
* wątku (stan wątku WAITING). Pozostałe metody muszą dać się wywołać pomimo
* istniejących zablokowanych wątków oczekujących na zakończenie metody
* purchase.
*/
public interface ShopInterface {
/**
* Dostawa dóbr do sklepu. Dostawa opisana jest w postaci mapy. Kluczem jest
* nazwa dostarczonego produktu, wartością ilość dostarczonych sztuk. Efektem
* ubocznym metody jest zakończenie oczekiwania wszystkich tych wątków, które
* wywołały metodę purchase dla towaru, którego nie było w sklepie w
* wystarczającej ilości, a został on dostarczony. Dostawa nie kończy
* oczekiwania wątków, które oczekują na dostawę innego towaru.
*
* @param goods spis dostarczonych do sklepu dóbr. Klucz nazwa towaru, wartość
* ilość dostarczonych sztuk.
*/
public void delivery(Map<String, Integer> goods);
/**
* Zakup towaru o podanej nazwie (productName) w liczbie quantity sztuk. W
* przypadku braku takiego towaru lub braku odpowiedniej ilości sztuk towaru
* wątek, który wywołał metodę jest blokowany do czasu dostawy zawierającej ten
* produkt. Jeśli sklep posiada na stanie odpowiednią ilość sztuk towaru zakup
* jest realizowany powodując odpowiednie zmniejszenie stanu magazynu.
*
* @param productName nazwa towaru
* @param quantity ilość sztuk
* @return true - zakup zrealizowany, false - zakup niezrealizowany.
*/
public boolean purchase(String productName, int quantity);
/**
* Aktualny stan magazynu. Mapa zawiera informacje o wszystkich towarach, które
* zostały dostarczone do sklepu, nawet jeśli w magazynie nie ma ani jednej
* sztuki danego towaru (wszystkie zostały sprzedane). Kluczem jest nazwa
* towaru, wartością aktualna liczba szuk towaru w magazynie sklepu.
*
* @return stan magazynu sklepu
*/
public Map<String, Integer> stock();
}
| /**
* Zakup towaru o podanej nazwie (productName) w liczbie quantity sztuk. W
* przypadku braku takiego towaru lub braku odpowiedniej ilości sztuk towaru
* wątek, który wywołał metodę jest blokowany do czasu dostawy zawierającej ten
* produkt. Jeśli sklep posiada na stanie odpowiednią ilość sztuk towaru zakup
* jest realizowany powodując odpowiednie zmniejszenie stanu magazynu.
*
* @param productName nazwa towaru
* @param quantity ilość sztuk
* @return true - zakup zrealizowany, false - zakup niezrealizowany.
*/ | import java.util.Map;
/**
* Interfejs sklepu. Wszyskie metody mogą być wywoływane współbieżnie. Metoda
* delivery jako jedyna może doprowadzić to zablokowania pracy wywołującego ją
* wątku (stan wątku WAITING). Pozostałe metody muszą dać się wywołać pomimo
* istniejących zablokowanych wątków oczekujących na zakończenie metody
* purchase.
*/
public interface ShopInterface {
/**
* Dostawa dóbr do sklepu. Dostawa opisana jest w postaci mapy. Kluczem jest
* nazwa dostarczonego produktu, wartością ilość dostarczonych sztuk. Efektem
* ubocznym metody jest zakończenie oczekiwania wszystkich tych wątków, które
* wywołały metodę purchase dla towaru, którego nie było w sklepie w
* wystarczającej ilości, a został on dostarczony. Dostawa nie kończy
* oczekiwania wątków, które oczekują na dostawę innego towaru.
*
* @param goods spis dostarczonych do sklepu dóbr. Klucz nazwa towaru, wartość
* ilość dostarczonych sztuk.
*/
public void delivery(Map<String, Integer> goods);
/**
* Zakup towaru o <SUF>*/
public boolean purchase(String productName, int quantity);
/**
* Aktualny stan magazynu. Mapa zawiera informacje o wszystkich towarach, które
* zostały dostarczone do sklepu, nawet jeśli w magazynie nie ma ani jednej
* sztuki danego towaru (wszystkie zostały sprzedane). Kluczem jest nazwa
* towaru, wartością aktualna liczba szuk towaru w magazynie sklepu.
*
* @return stan magazynu sklepu
*/
public Map<String, Integer> stock();
}
| f | null |
372 | 6845_23 | beto4444/GRAPHen | 5,577 | src/GNListener.java | import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import DataStructures.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.antlr.v4.runtime.tree.ParseTreeProperty;
public class GNListener extends GRAPHenBaseListener {
private final HashMap<String, Node> nodes = new HashMap<>();
private final HashMap<String, Edge> edges = new HashMap<>();
private final HashMap<String, Graph> graphs = new HashMap<>();
private final ArrayList<String> errorsList = new ArrayList<String>();
private Node currentNode;
private Edge currentEdge;
private Graph currentGraph;
private Digraph currentDigraph;
public List<Edge> getEdges(){
return new ArrayList<Edge>(edges.values());
}
public List<Node> getNodes(){
return new ArrayList<Node>(nodes.values());
}
public List<Graph> getGraphs(){
return new ArrayList<Graph>(graphs.values());
}
public String errorsToString(){
StringBuilder sb = new StringBuilder();
if(!errorsList.isEmpty()) {
for (String error : errorsList) {
sb.append(error);
sb.append('\n');
}
}
else{
sb.append("Everything ok!");
}
return sb.toString();
}
public void describeData(){
System.out.println("Węzły: ");
if(!nodes.keySet().isEmpty()) {
for (String i : nodes.keySet()) {
System.out.print(i);
System.out.print(", ");
}
}
else{System.out.println("Brak");}
System.out.println("Krawędzie: ");
if(!edges.keySet().isEmpty()) {
for (String i : edges.keySet()) {
System.out.print(i);
System.out.print(", ");
}
}
else{System.out.println("Brak");}
}
@Override
public void enterNode_definition(GRAPHenParser.Node_definitionContext ctx) {
String id = ctx.IDENTIFIER().getText();
Node node = new Node();
currentNode = node;
nodes.put(id, node);
}
@Override
public void enterNode_inline(GRAPHenParser.Node_inlineContext ctx) {
String id = ctx.IDENTIFIER().getText();
Node node = new Node();
currentNode = node;
nodes.put(id, node);
}
@Override
public void enterNode_properties(GRAPHenParser.Node_propertiesContext ctx) {
Node node = currentNode;
TerminalNode numColorNode = ctx.TEXT();
if (numColorNode != null) {
String contents = ctx.TEXT().getText();
node.setNodeContents(contents);
}
TerminalNode contColor = ctx.COLOR(0);
if (contColor != null) {
String Color = contColor.getText();
node.setContColor(Color);
}
TerminalNode contSizeCtx = ctx.POS_NUMBER(0);
if (contSizeCtx != null) {
int Size = Integer.parseInt(contSizeCtx.getText());
node.setContSize(Size);
}
TerminalNode fillColor = ctx.COLOR(1);
if (fillColor != null) {
String Color = fillColor.getText();
node.setFillColor(Color);
}
TerminalNode borderColor = ctx.COLOR(2);
if (borderColor != null) {
String Color = borderColor.getText();
node.setBorderColor(Color);
}
TerminalNode nodeShapeCtx = ctx.NODE_SHAPE();
if (nodeShapeCtx != null) {
NodeShape nodeShape = NodeShape.valueOf(nodeShapeCtx.getText());
node.setNodeShape(nodeShape);
}
TerminalNode nodeSizeCtx = ctx.POS_NUMBER(1);
if (nodeSizeCtx != null) {
int nodeSize = Integer.parseInt(nodeSizeCtx.getText());
node.setNodeSize(nodeSize);
}
// Get the optional 'borderWidth' property
TerminalNode borderWidthCtx = ctx.POS_NUMBER(2);
if (borderWidthCtx != null) {
int borderWidth = Integer.parseInt(borderWidthCtx.getText());
node.setBorderWidth(borderWidth);
}
// Get the optional 'borderLineShape' property
TerminalNode borderLineShapeCtx = ctx.LINE_TYPE();
if (borderLineShapeCtx != null) {
LineType borderLineShape = LineType.valueOf(borderLineShapeCtx.getText());
node.setBorderLineShape(borderLineShape);
}
}
@Override
public void enterEdge_definition(GRAPHenParser.Edge_definitionContext ctx) {
String id = ctx.IDENTIFIER().getText();
Edge edge = new Edge();
currentEdge = edge;
edges.put(id, edge);
}
@Override
public void enterEdge_inline(GRAPHenParser.Edge_inlineContext ctx) {
String id = ctx.IDENTIFIER().getText();
Edge edge = new Edge();
currentEdge = edge;
edges.put(id, edge);
}
@Override
public void enterEdge_properties(GRAPHenParser.Edge_propertiesContext ctx) {
Edge edge = currentEdge;
TerminalNode numberNode = ctx.NUMBER();
if (numberNode != null) {
int number = Integer.parseInt(numberNode.getText());
edge.setNumColor(number);
}
TerminalNode posNumberNode = ctx.POS_NUMBER(0);
if (posNumberNode != null) {
int posNumber = Integer.parseInt(posNumberNode.getText());
edge.setLineWidth(posNumber);
}
TerminalNode colorNode = ctx.COLOR();
if (colorNode != null) {
String color = colorNode.getText();
edge.setColor(color);
}
TerminalNode lineTypeNode = ctx.LINE_TYPE();
if (lineTypeNode != null) {
LineType lineType = LineType.valueOf(lineTypeNode.getText());
edge.setLineType(lineType);
}
}
@Override
public void enterGraph_definition(GRAPHenParser.Graph_definitionContext ctx) {
String graphName = ctx.IDENTIFIER().getText();
Graph graph;
graph = new Graph();
graphs.put(graphName, graph);
currentGraph = graph;
if (ctx.edge_list() != null) {
enterEdge_list(ctx.edge_list());
if (ctx.graph_function() != null){
enterGraph_function(ctx.graph_function());
}
} else if (ctx.graph_add() != null) {
enterGraph_add(ctx.graph_add());
} else if (ctx.graph_substract() != null) {
enterGraph_substract(ctx.graph_substract());
} else if (ctx.graph_union() != null){
enterGraph_union(ctx.graph_union());
}
}
@Override
public void enterEdge_list(GRAPHenParser.Edge_listContext ctx) {
List<GRAPHenParser.Edge_relationContext> edgeRelationContexts = ctx.edge_relation();
for (GRAPHenParser.Edge_relationContext edgeRelationContext : edgeRelationContexts) {
enterEdge_relation(edgeRelationContext);
}
}
@Override
public void enterEdge_relation(GRAPHenParser.Edge_relationContext ctx) {
List<ParseTree> children = ctx.children;
Node parent = null;
Edge edge = null;
List<Node> child = new ArrayList<>();
ParseTree firstNodeOrIdentifier = children.get(0);
if (firstNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = firstNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": 1Node " + identifier + " not defined";
if(!errorsList.contains(error)) {
errorsList.add(error);
}
}else {
parent = nodes.get(identifier);
}
} else if (firstNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) firstNodeOrIdentifier);
parent = currentNode; //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
ParseTree edgeOrIdentifier = children.get(3);
if (edgeOrIdentifier instanceof TerminalNode) {
String identifier = edgeOrIdentifier.getText();
if (!edges.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": Edge " + identifier + " not defined";
if(!errorsList.contains(error)) {
errorsList.add(error);
}
}
else {
edge = edges.get(identifier);
}
} else if (edgeOrIdentifier instanceof GRAPHenParser.Edge_inlineContext) {
enterEdge_inline((GRAPHenParser.Edge_inlineContext) edgeOrIdentifier);
edge = currentEdge;
}
ParseTree secondNodeOrIdentifier = children.get(4);
if (secondNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = secondNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": Node " + identifier + " not defined";
if(!errorsList.contains(error)&&!identifier.equals(")")) {
errorsList.add(error);
}
}else {
child.add(nodes.get(identifier));
}
} else if (secondNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) secondNodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
for (int i = 5; i < children.size(); i += 2) {
ParseTree nodeOrIdentifier = children.get(i);
if (nodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = nodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": Node " + identifier + " not defined";
if(!errorsList.contains(error)) {
errorsList.add(error);
}
}else {
child.add(nodes.get(identifier));
}
} else if (nodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) nodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
}
if (parent == null || edge == null || child.size() == 0){
return; //nie powinno się zdarzyć @TODO wyjątek
}
edge.setRelations(parent, child); //@TODO zamienić child na children dlaczego nazwałam to child
currentGraph.addRelation(parent, edge, child);
}
@Override
public void enterGraph_add(GRAPHenParser.Graph_addContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Add(second)); //@TODO: czy tu potrzebne copy?
}
@Override
public void enterGraph_substract(GRAPHenParser.Graph_substractContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Substract(second)); //@TODO: czy tu potrzebne copy?
}
@Override
public void enterGraph_union(GRAPHenParser.Graph_unionContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Union(second)); //@TODO: czy tu potrzebne copy?
}
@Override
public void enterGraph_function(GRAPHenParser.Graph_functionContext ctx) {
if (ctx.colorEdgesFunc() != null){
enterColorEdgesFunc(ctx.colorEdgesFunc());
}
else if (ctx.colorNodesFunc() != null){
enterColorNodesFunc(ctx.colorNodesFunc());
}
else {
String foo = ctx.getText();
if (foo.equals("clearEdges()")) {
currentGraph.clearEdges();
}
}
}
@Override
public void enterColorEdgesFunc(GRAPHenParser.ColorEdgesFuncContext ctx) {
currentGraph.colorEdges();
}
@Override
public void enterColorNodesFunc(GRAPHenParser.ColorNodesFuncContext ctx) {
currentGraph.colorNodes();
}
@Override
public void enterDigraph_definition(GRAPHenParser.Digraph_definitionContext ctx) {
String graphName = ctx.IDENTIFIER().getText();
Graph graph;
graph = new Graph(true);
graphs.put(graphName, graph);
currentGraph = graph;
if (ctx.dedge_list() != null) {
enterDedge_list(ctx.dedge_list());
if (ctx.graph_function() != null){
enterGraph_function(ctx.graph_function());
}
} else if (ctx.digraph_add() != null) {
enterDigraph_add(ctx.digraph_add());
} else if (ctx.digraph_substract() != null) {
enterDigraph_substract(ctx.digraph_substract());
} else if (ctx.digraph_union() != null) {
enterDigraph_union(ctx.digraph_union());
}
}
@Override
public void enterDedge_list(GRAPHenParser.Dedge_listContext ctx) {
List<GRAPHenParser.Dedge_relationContext> dedgeRelationContexts = ctx.dedge_relation();
for (GRAPHenParser.Dedge_relationContext dedgeRelationContext : dedgeRelationContexts) {
enterDedge_relation(dedgeRelationContext);
}
}
@Override
public void enterDedge_relation(GRAPHenParser.Dedge_relationContext ctx) {
List<ParseTree> children = ctx.children;
Node parent = null;
Edge edge = null;
List<Node> child = new ArrayList<>();
ParseTree firstNodeOrIdentifier = children.get(0);
if (firstNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = firstNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
//@TODO: throw node does not exist error
}else {
parent = nodes.get(identifier);
}
} else if (firstNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) firstNodeOrIdentifier);
parent = currentNode; //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
ParseTree edgeOrIdentifier = children.get(3);
if (edgeOrIdentifier instanceof TerminalNode) {
String identifier = edgeOrIdentifier.getText();
if (!edges.containsKey(identifier)){
//@TODO: throw edge does not exist error
}
else {
edge = edges.get(identifier);
}
} else if (edgeOrIdentifier instanceof GRAPHenParser.Edge_inlineContext) {
enterEdge_inline((GRAPHenParser.Edge_inlineContext) edgeOrIdentifier);
edge = currentEdge;
}
ParseTree secondNodeOrIdentifier = children.get(4);
if (secondNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = secondNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
//@TODO: throw node does not exist error
}else {
child.add(nodes.get(identifier));
}
} else if (secondNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) secondNodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
for (int i = 5; i < children.size(); i += 2) {
ParseTree nodeOrIdentifier = children.get(i);
if (nodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = nodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
//@TODO: throw node does not exist error
}else {
child.add(nodes.get(identifier));
}
} else if (nodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) nodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
}
if (parent == null || edge == null || child.size() == 0){
return; //nie powinno się zdarzyć
}
currentGraph.addRelation(parent, edge, child);
}
@Override
public void enterDigraph_add(GRAPHenParser.Digraph_addContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Add(second));
}
@Override
public void enterDigraph_substract(GRAPHenParser.Digraph_substractContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Substract(second));
}
@Override
public void enterDigraph_union(GRAPHenParser.Digraph_unionContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Union(second));
}
@Override
public void enterGraph_function_statement(GRAPHenParser.Graph_function_statementContext ctx) {
String id = ctx.IDENTIFIER().getText();
if (!graphs.containsKey(id)){
//@TODO: error
}
else {
currentGraph = graphs.get(id);
enterGraph_function(ctx.graph_function());
}
}
//@TODO: export to file function
}
| //nie powinno się zdarzyć | import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import DataStructures.*;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.antlr.v4.runtime.tree.ParseTreeProperty;
public class GNListener extends GRAPHenBaseListener {
private final HashMap<String, Node> nodes = new HashMap<>();
private final HashMap<String, Edge> edges = new HashMap<>();
private final HashMap<String, Graph> graphs = new HashMap<>();
private final ArrayList<String> errorsList = new ArrayList<String>();
private Node currentNode;
private Edge currentEdge;
private Graph currentGraph;
private Digraph currentDigraph;
public List<Edge> getEdges(){
return new ArrayList<Edge>(edges.values());
}
public List<Node> getNodes(){
return new ArrayList<Node>(nodes.values());
}
public List<Graph> getGraphs(){
return new ArrayList<Graph>(graphs.values());
}
public String errorsToString(){
StringBuilder sb = new StringBuilder();
if(!errorsList.isEmpty()) {
for (String error : errorsList) {
sb.append(error);
sb.append('\n');
}
}
else{
sb.append("Everything ok!");
}
return sb.toString();
}
public void describeData(){
System.out.println("Węzły: ");
if(!nodes.keySet().isEmpty()) {
for (String i : nodes.keySet()) {
System.out.print(i);
System.out.print(", ");
}
}
else{System.out.println("Brak");}
System.out.println("Krawędzie: ");
if(!edges.keySet().isEmpty()) {
for (String i : edges.keySet()) {
System.out.print(i);
System.out.print(", ");
}
}
else{System.out.println("Brak");}
}
@Override
public void enterNode_definition(GRAPHenParser.Node_definitionContext ctx) {
String id = ctx.IDENTIFIER().getText();
Node node = new Node();
currentNode = node;
nodes.put(id, node);
}
@Override
public void enterNode_inline(GRAPHenParser.Node_inlineContext ctx) {
String id = ctx.IDENTIFIER().getText();
Node node = new Node();
currentNode = node;
nodes.put(id, node);
}
@Override
public void enterNode_properties(GRAPHenParser.Node_propertiesContext ctx) {
Node node = currentNode;
TerminalNode numColorNode = ctx.TEXT();
if (numColorNode != null) {
String contents = ctx.TEXT().getText();
node.setNodeContents(contents);
}
TerminalNode contColor = ctx.COLOR(0);
if (contColor != null) {
String Color = contColor.getText();
node.setContColor(Color);
}
TerminalNode contSizeCtx = ctx.POS_NUMBER(0);
if (contSizeCtx != null) {
int Size = Integer.parseInt(contSizeCtx.getText());
node.setContSize(Size);
}
TerminalNode fillColor = ctx.COLOR(1);
if (fillColor != null) {
String Color = fillColor.getText();
node.setFillColor(Color);
}
TerminalNode borderColor = ctx.COLOR(2);
if (borderColor != null) {
String Color = borderColor.getText();
node.setBorderColor(Color);
}
TerminalNode nodeShapeCtx = ctx.NODE_SHAPE();
if (nodeShapeCtx != null) {
NodeShape nodeShape = NodeShape.valueOf(nodeShapeCtx.getText());
node.setNodeShape(nodeShape);
}
TerminalNode nodeSizeCtx = ctx.POS_NUMBER(1);
if (nodeSizeCtx != null) {
int nodeSize = Integer.parseInt(nodeSizeCtx.getText());
node.setNodeSize(nodeSize);
}
// Get the optional 'borderWidth' property
TerminalNode borderWidthCtx = ctx.POS_NUMBER(2);
if (borderWidthCtx != null) {
int borderWidth = Integer.parseInt(borderWidthCtx.getText());
node.setBorderWidth(borderWidth);
}
// Get the optional 'borderLineShape' property
TerminalNode borderLineShapeCtx = ctx.LINE_TYPE();
if (borderLineShapeCtx != null) {
LineType borderLineShape = LineType.valueOf(borderLineShapeCtx.getText());
node.setBorderLineShape(borderLineShape);
}
}
@Override
public void enterEdge_definition(GRAPHenParser.Edge_definitionContext ctx) {
String id = ctx.IDENTIFIER().getText();
Edge edge = new Edge();
currentEdge = edge;
edges.put(id, edge);
}
@Override
public void enterEdge_inline(GRAPHenParser.Edge_inlineContext ctx) {
String id = ctx.IDENTIFIER().getText();
Edge edge = new Edge();
currentEdge = edge;
edges.put(id, edge);
}
@Override
public void enterEdge_properties(GRAPHenParser.Edge_propertiesContext ctx) {
Edge edge = currentEdge;
TerminalNode numberNode = ctx.NUMBER();
if (numberNode != null) {
int number = Integer.parseInt(numberNode.getText());
edge.setNumColor(number);
}
TerminalNode posNumberNode = ctx.POS_NUMBER(0);
if (posNumberNode != null) {
int posNumber = Integer.parseInt(posNumberNode.getText());
edge.setLineWidth(posNumber);
}
TerminalNode colorNode = ctx.COLOR();
if (colorNode != null) {
String color = colorNode.getText();
edge.setColor(color);
}
TerminalNode lineTypeNode = ctx.LINE_TYPE();
if (lineTypeNode != null) {
LineType lineType = LineType.valueOf(lineTypeNode.getText());
edge.setLineType(lineType);
}
}
@Override
public void enterGraph_definition(GRAPHenParser.Graph_definitionContext ctx) {
String graphName = ctx.IDENTIFIER().getText();
Graph graph;
graph = new Graph();
graphs.put(graphName, graph);
currentGraph = graph;
if (ctx.edge_list() != null) {
enterEdge_list(ctx.edge_list());
if (ctx.graph_function() != null){
enterGraph_function(ctx.graph_function());
}
} else if (ctx.graph_add() != null) {
enterGraph_add(ctx.graph_add());
} else if (ctx.graph_substract() != null) {
enterGraph_substract(ctx.graph_substract());
} else if (ctx.graph_union() != null){
enterGraph_union(ctx.graph_union());
}
}
@Override
public void enterEdge_list(GRAPHenParser.Edge_listContext ctx) {
List<GRAPHenParser.Edge_relationContext> edgeRelationContexts = ctx.edge_relation();
for (GRAPHenParser.Edge_relationContext edgeRelationContext : edgeRelationContexts) {
enterEdge_relation(edgeRelationContext);
}
}
@Override
public void enterEdge_relation(GRAPHenParser.Edge_relationContext ctx) {
List<ParseTree> children = ctx.children;
Node parent = null;
Edge edge = null;
List<Node> child = new ArrayList<>();
ParseTree firstNodeOrIdentifier = children.get(0);
if (firstNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = firstNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": 1Node " + identifier + " not defined";
if(!errorsList.contains(error)) {
errorsList.add(error);
}
}else {
parent = nodes.get(identifier);
}
} else if (firstNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) firstNodeOrIdentifier);
parent = currentNode; //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
ParseTree edgeOrIdentifier = children.get(3);
if (edgeOrIdentifier instanceof TerminalNode) {
String identifier = edgeOrIdentifier.getText();
if (!edges.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": Edge " + identifier + " not defined";
if(!errorsList.contains(error)) {
errorsList.add(error);
}
}
else {
edge = edges.get(identifier);
}
} else if (edgeOrIdentifier instanceof GRAPHenParser.Edge_inlineContext) {
enterEdge_inline((GRAPHenParser.Edge_inlineContext) edgeOrIdentifier);
edge = currentEdge;
}
ParseTree secondNodeOrIdentifier = children.get(4);
if (secondNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = secondNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": Node " + identifier + " not defined";
if(!errorsList.contains(error)&&!identifier.equals(")")) {
errorsList.add(error);
}
}else {
child.add(nodes.get(identifier));
}
} else if (secondNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) secondNodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
for (int i = 5; i < children.size(); i += 2) {
ParseTree nodeOrIdentifier = children.get(i);
if (nodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = nodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
int Line = ctx.getStart().getLine();
String error = "LISTENER ERROR: Line " + Line + ": Node " + identifier + " not defined";
if(!errorsList.contains(error)) {
errorsList.add(error);
}
}else {
child.add(nodes.get(identifier));
}
} else if (nodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) nodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
}
if (parent == null || edge == null || child.size() == 0){
return; //nie powinno się zdarzyć @TODO wyjątek
}
edge.setRelations(parent, child); //@TODO zamienić child na children dlaczego nazwałam to child
currentGraph.addRelation(parent, edge, child);
}
@Override
public void enterGraph_add(GRAPHenParser.Graph_addContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Add(second)); //@TODO: czy tu potrzebne copy?
}
@Override
public void enterGraph_substract(GRAPHenParser.Graph_substractContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Substract(second)); //@TODO: czy tu potrzebne copy?
}
@Override
public void enterGraph_union(GRAPHenParser.Graph_unionContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Union(second)); //@TODO: czy tu potrzebne copy?
}
@Override
public void enterGraph_function(GRAPHenParser.Graph_functionContext ctx) {
if (ctx.colorEdgesFunc() != null){
enterColorEdgesFunc(ctx.colorEdgesFunc());
}
else if (ctx.colorNodesFunc() != null){
enterColorNodesFunc(ctx.colorNodesFunc());
}
else {
String foo = ctx.getText();
if (foo.equals("clearEdges()")) {
currentGraph.clearEdges();
}
}
}
@Override
public void enterColorEdgesFunc(GRAPHenParser.ColorEdgesFuncContext ctx) {
currentGraph.colorEdges();
}
@Override
public void enterColorNodesFunc(GRAPHenParser.ColorNodesFuncContext ctx) {
currentGraph.colorNodes();
}
@Override
public void enterDigraph_definition(GRAPHenParser.Digraph_definitionContext ctx) {
String graphName = ctx.IDENTIFIER().getText();
Graph graph;
graph = new Graph(true);
graphs.put(graphName, graph);
currentGraph = graph;
if (ctx.dedge_list() != null) {
enterDedge_list(ctx.dedge_list());
if (ctx.graph_function() != null){
enterGraph_function(ctx.graph_function());
}
} else if (ctx.digraph_add() != null) {
enterDigraph_add(ctx.digraph_add());
} else if (ctx.digraph_substract() != null) {
enterDigraph_substract(ctx.digraph_substract());
} else if (ctx.digraph_union() != null) {
enterDigraph_union(ctx.digraph_union());
}
}
@Override
public void enterDedge_list(GRAPHenParser.Dedge_listContext ctx) {
List<GRAPHenParser.Dedge_relationContext> dedgeRelationContexts = ctx.dedge_relation();
for (GRAPHenParser.Dedge_relationContext dedgeRelationContext : dedgeRelationContexts) {
enterDedge_relation(dedgeRelationContext);
}
}
@Override
public void enterDedge_relation(GRAPHenParser.Dedge_relationContext ctx) {
List<ParseTree> children = ctx.children;
Node parent = null;
Edge edge = null;
List<Node> child = new ArrayList<>();
ParseTree firstNodeOrIdentifier = children.get(0);
if (firstNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = firstNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
//@TODO: throw node does not exist error
}else {
parent = nodes.get(identifier);
}
} else if (firstNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) firstNodeOrIdentifier);
parent = currentNode; //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
ParseTree edgeOrIdentifier = children.get(3);
if (edgeOrIdentifier instanceof TerminalNode) {
String identifier = edgeOrIdentifier.getText();
if (!edges.containsKey(identifier)){
//@TODO: throw edge does not exist error
}
else {
edge = edges.get(identifier);
}
} else if (edgeOrIdentifier instanceof GRAPHenParser.Edge_inlineContext) {
enterEdge_inline((GRAPHenParser.Edge_inlineContext) edgeOrIdentifier);
edge = currentEdge;
}
ParseTree secondNodeOrIdentifier = children.get(4);
if (secondNodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = secondNodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
//@TODO: throw node does not exist error
}else {
child.add(nodes.get(identifier));
}
} else if (secondNodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) secondNodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
for (int i = 5; i < children.size(); i += 2) {
ParseTree nodeOrIdentifier = children.get(i);
if (nodeOrIdentifier instanceof TerminalNode) {
// Handle identifier
String identifier = nodeOrIdentifier.getText();
if (!nodes.containsKey(identifier)){
//@TODO: throw node does not exist error
}else {
child.add(nodes.get(identifier));
}
} else if (nodeOrIdentifier instanceof GRAPHenParser.Node_inlineContext) {
// Handle node_inline
enterNode_inline((GRAPHenParser.Node_inlineContext) nodeOrIdentifier);
child.add(currentNode); //@TODO: zabezpieczyć (np. zmieniać currentNode na null po zakończeniu używnaia i sprawdzać czy wszystko działa
}
}
if (parent == null || edge == null || child.size() == 0){
return; //nie powinno <SUF>
}
currentGraph.addRelation(parent, edge, child);
}
@Override
public void enterDigraph_add(GRAPHenParser.Digraph_addContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Add(second));
}
@Override
public void enterDigraph_substract(GRAPHenParser.Digraph_substractContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Substract(second));
}
@Override
public void enterDigraph_union(GRAPHenParser.Digraph_unionContext ctx) {
String firstId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(firstId)){
//@TODO: graph does not exist
}
Graph first = graphs.get(firstId);
String secondId = ctx.IDENTIFIER(0).getText();
if (!graphs.containsKey(secondId)){
//@TODO: graph does not exist
}
Graph second = graphs.get(secondId);
currentGraph.copy(first.Union(second));
}
@Override
public void enterGraph_function_statement(GRAPHenParser.Graph_function_statementContext ctx) {
String id = ctx.IDENTIFIER().getText();
if (!graphs.containsKey(id)){
//@TODO: error
}
else {
currentGraph = graphs.get(id);
enterGraph_function(ctx.graph_function());
}
}
//@TODO: export to file function
}
| f | null |
373 | 294_5 | bieleck1/DandD | 1,319 | DandD/src/Tury/Ruch.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 Tury;
import Dane.Bohaterowie;
import Dane.Mapa;
import static Tury.Komenda.podajStan;
/**
*
* @author Grzechu
*/
public class Ruch {
public static int Ruch (Bohaterowie postaci, Mapa mapa, int czyjRuch, int kierunek)
{
int koszt = 0;
if (kierunek == -3 || kierunek == -1)
{
System.out.println("Ruch niedozwolony");
postaci.tablica.get(czyjRuch).ruchPom -= 1;
return 0;
}
if (kierunek == -2)
{
System.out.println("Znajdujesz się na polu " + mapa.znajdzBohatera(czyjRuch+1));
postaci.tablica.get(czyjRuch).ruchPom -= 1;
return 0;
}
//Ruch po prostej
if (kierunek == mapa.znajdzBohatera(czyjRuch+1) + mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) + 1
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - 1)
if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek))
{
if (mapa.plansza.get(kierunek).czyDostepne())
{
mapa.przemiesc(czyjRuch+1, kierunek);
postaci.tablica.get(czyjRuch).ruchPom -= mapa.kosztRuchu(kierunek);
koszt += mapa.kosztRuchu(kierunek);
podajStan("Poruszyłeś się: Koszt ruchu - " + koszt);
}
else System.out.println("Pole niedostępne");
}
else System.out.println("Brak wystarczającej liczby punktów ruchu");
//Ruch po skosie
else if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek) + 1 )
if (mapa.plansza.get(kierunek).czyDostepne())
{
mapa.przemiesc(czyjRuch+1, kierunek);
postaci.tablica.get(czyjRuch).ruchPom -= mapa.kosztRuchu(kierunek) + 1;
koszt += mapa.kosztRuchu(kierunek) + 1;
podajStan("Poruszyłeś się: Koszt ruchu - " + koszt);
}
else {
//System.out.println("Pole niedostępne");
return 0;
}
else System.out.println("Brak wystarczającej liczby punktów ruchu");
return 1;
}
public static boolean RuchSprawdz (Bohaterowie postaci, Mapa mapa, int czyjRuch, int kierunek)
{
if (kierunek < 0)
return false;
//Ruch po prostej
if (kierunek == mapa.znajdzBohatera(czyjRuch+1) + mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) + 1
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - 1)
if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek))
{
return mapa.plansza.get(kierunek).czyDostepne();
}
else return false;
//Ruch po skosie
else if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek) + 1 )
return mapa.plansza.get(kierunek).czyDostepne();
else return false;
}
}
| //Ruch po skosie
| /*
* 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 Tury;
import Dane.Bohaterowie;
import Dane.Mapa;
import static Tury.Komenda.podajStan;
/**
*
* @author Grzechu
*/
public class Ruch {
public static int Ruch (Bohaterowie postaci, Mapa mapa, int czyjRuch, int kierunek)
{
int koszt = 0;
if (kierunek == -3 || kierunek == -1)
{
System.out.println("Ruch niedozwolony");
postaci.tablica.get(czyjRuch).ruchPom -= 1;
return 0;
}
if (kierunek == -2)
{
System.out.println("Znajdujesz się na polu " + mapa.znajdzBohatera(czyjRuch+1));
postaci.tablica.get(czyjRuch).ruchPom -= 1;
return 0;
}
//Ruch po prostej
if (kierunek == mapa.znajdzBohatera(czyjRuch+1) + mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) + 1
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - 1)
if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek))
{
if (mapa.plansza.get(kierunek).czyDostepne())
{
mapa.przemiesc(czyjRuch+1, kierunek);
postaci.tablica.get(czyjRuch).ruchPom -= mapa.kosztRuchu(kierunek);
koszt += mapa.kosztRuchu(kierunek);
podajStan("Poruszyłeś się: Koszt ruchu - " + koszt);
}
else System.out.println("Pole niedostępne");
}
else System.out.println("Brak wystarczającej liczby punktów ruchu");
//Ruch po skosie
else if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek) + 1 )
if (mapa.plansza.get(kierunek).czyDostepne())
{
mapa.przemiesc(czyjRuch+1, kierunek);
postaci.tablica.get(czyjRuch).ruchPom -= mapa.kosztRuchu(kierunek) + 1;
koszt += mapa.kosztRuchu(kierunek) + 1;
podajStan("Poruszyłeś się: Koszt ruchu - " + koszt);
}
else {
//System.out.println("Pole niedostępne");
return 0;
}
else System.out.println("Brak wystarczającej liczby punktów ruchu");
return 1;
}
public static boolean RuchSprawdz (Bohaterowie postaci, Mapa mapa, int czyjRuch, int kierunek)
{
if (kierunek < 0)
return false;
//Ruch po prostej
if (kierunek == mapa.znajdzBohatera(czyjRuch+1) + mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - mapa.wymiarX()
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) + 1
|| kierunek == mapa.znajdzBohatera(czyjRuch+1) - 1)
if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek))
{
return mapa.plansza.get(kierunek).czyDostepne();
}
else return false;
//Ruch po <SUF>
else if (postaci.tablica.get(czyjRuch).ruchPom >= mapa.kosztRuchu(kierunek) + 1 )
return mapa.plansza.get(kierunek).czyDostepne();
else return false;
}
}
| f | null |
374 | 6785_8 | bkucman/Java-Testowanie | 432 | projekt2-kucmeno/Device.java | import java.util.ArrayList;
public interface Mp3Player {
/**
* Rozpocznij odtwarzanie
* od utworu znajdujacego sie na szczycie listy
* utworow lub nie rob nic gdy lista jest pusta.
*/
public void play();
/**
* Wstrzymaj odtwarzanie. Odtwarzanie bedzie
* pozniej wznowione od tego miejsca.
*/
public void pause();
/**
* Zatrzymaj odtwarzanie. Biezacy utwor pozostaje
* na szczycie listy, ale odtwarzanie zostanie
* wznowione od jego poczatku.
*/
public void stop();
/** Zwraca liczbe sekund od poczatku
* biezacego utworu.
*/
public double currentPosition();
/**
* Zwraca nazwe odtwarzanego pliku.
*/
public String currentSong();
/**
* Przechodzi do nastepnego utworu na liscie
* i rozpoczyna jego odtwarzanie.
*/
public void next();
/**
* Wraca do poprzedniego utworu na liscie
* i rozpoczyna jego odtwarzanie.
*/
public void prev();
/**
* Zwraca true gdy odtwarzany jest utwor.
*/
public boolean isPlaying();
/**
* Laduje pliki na liste utworow.
*/
public void loadSongs(ArrayList names);
}
| /**
* Laduje pliki na liste utworow.
*/ | import java.util.ArrayList;
public interface Mp3Player {
/**
* Rozpocznij odtwarzanie
* od utworu znajdujacego sie na szczycie listy
* utworow lub nie rob nic gdy lista jest pusta.
*/
public void play();
/**
* Wstrzymaj odtwarzanie. Odtwarzanie bedzie
* pozniej wznowione od tego miejsca.
*/
public void pause();
/**
* Zatrzymaj odtwarzanie. Biezacy utwor pozostaje
* na szczycie listy, ale odtwarzanie zostanie
* wznowione od jego poczatku.
*/
public void stop();
/** Zwraca liczbe sekund od poczatku
* biezacego utworu.
*/
public double currentPosition();
/**
* Zwraca nazwe odtwarzanego pliku.
*/
public String currentSong();
/**
* Przechodzi do nastepnego utworu na liscie
* i rozpoczyna jego odtwarzanie.
*/
public void next();
/**
* Wraca do poprzedniego utworu na liscie
* i rozpoczyna jego odtwarzanie.
*/
public void prev();
/**
* Zwraca true gdy odtwarzany jest utwor.
*/
public boolean isPlaying();
/**
* Laduje pliki na <SUF>*/
public void loadSongs(ArrayList names);
}
| f | null |
375 | 5619_2 | bl4de/cs | 547 | ProjectEuler/Euler9/src/Euler9.java | /*
*
A Pythagorean triplet is a set of three natural numbers, a b c, for which,
a2 + b2 = c2
For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.
*/
class Euler9 {
public static void main(String args[]) {
int a = 3, b = 4, c = 5;
// wiedzac, ze dla dowolnego a,b,c, gdzie a^2+b^2=c^2 i dla dowolnego d
// spelniona jest zaleznosc, ze (da)^2+(db)^2 = (dc)^2 mozemy zalozyc, ze (a+b+c)*d = 1000
int d;
for (d = 1; d <=10; d++ ) {
int tmp_a = a * d;
int tmp_b = b * d;
int tmp_c = c * d;
//obliczamy tw. Pitagorasa dla obliczonych wartosci trojki
// sprawdzamy, czy suma a,b i c = 1000
if ( ( Math.pow(tmp_a,2) + Math.pow( tmp_b,2 ) ) == Math.pow( tmp_c, 2 ) ) {
if ( tmp_a + tmp_b + tmp_c == 1000 ) {
System.out.println("znaleziona trojka: "+tmp_a+", "+tmp_b+", "+tmp_c+" suma: "+tmp_a+tmp_b+tmp_c);
} else {
System.out.println(Math.pow(tmp_a,2)+", "+Math.pow(tmp_b,2)+", "+(Math.pow(tmp_a,2) + Math.pow( tmp_b,2 )));
}
}//if
}
System.out.println();
}
}
| // spelniona jest zaleznosc, ze (da)^2+(db)^2 = (dc)^2 mozemy zalozyc, ze (a+b+c)*d = 1000 | /*
*
A Pythagorean triplet is a set of three natural numbers, a b c, for which,
a2 + b2 = c2
For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.
*/
class Euler9 {
public static void main(String args[]) {
int a = 3, b = 4, c = 5;
// wiedzac, ze dla dowolnego a,b,c, gdzie a^2+b^2=c^2 i dla dowolnego d
// spelniona jest <SUF>
int d;
for (d = 1; d <=10; d++ ) {
int tmp_a = a * d;
int tmp_b = b * d;
int tmp_c = c * d;
//obliczamy tw. Pitagorasa dla obliczonych wartosci trojki
// sprawdzamy, czy suma a,b i c = 1000
if ( ( Math.pow(tmp_a,2) + Math.pow( tmp_b,2 ) ) == Math.pow( tmp_c, 2 ) ) {
if ( tmp_a + tmp_b + tmp_c == 1000 ) {
System.out.println("znaleziona trojka: "+tmp_a+", "+tmp_b+", "+tmp_c+" suma: "+tmp_a+tmp_b+tmp_c);
} else {
System.out.println(Math.pow(tmp_a,2)+", "+Math.pow(tmp_b,2)+", "+(Math.pow(tmp_a,2) + Math.pow( tmp_b,2 )));
}
}//if
}
System.out.println();
}
}
| f | null |
377 | 3955_0 | bluesoft-rnd/aperte-workflow-core | 7,459 | core/base-gui/src/main/java/pl/net/bluesoft/rnd/processtool/ui/process/ProcessDataPane.java | package pl.net.bluesoft.rnd.processtool.ui.process;
import static com.vaadin.ui.Label.CONTENT_XHTML;
import static org.aperteworkflow.util.vaadin.VaadinExceptionHandler.Util.withErrorHandling;
import static pl.net.bluesoft.util.lang.Formats.nvl;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.lang3.StringUtils;
import org.aperteworkflow.ui.help.HelpProvider;
import org.aperteworkflow.ui.help.HelpProviderFactory;
import org.aperteworkflow.util.vaadin.VaadinUtility;
import org.aperteworkflow.util.vaadin.ui.AligningHorizontalLayout;
import pl.net.bluesoft.rnd.processtool.ProcessToolContext;
import pl.net.bluesoft.rnd.processtool.bpm.ProcessToolBpmSession;
import pl.net.bluesoft.rnd.processtool.model.BpmTask;
import pl.net.bluesoft.rnd.processtool.model.ProcessInstance;
import pl.net.bluesoft.rnd.processtool.model.UserData;
import pl.net.bluesoft.rnd.processtool.model.config.ProcessStateAction;
import pl.net.bluesoft.rnd.processtool.model.config.ProcessStateConfiguration;
import pl.net.bluesoft.rnd.processtool.model.config.ProcessStateWidget;
import pl.net.bluesoft.rnd.processtool.plugins.ProcessToolRegistry;
import pl.net.bluesoft.rnd.processtool.ui.WidgetContextSupport;
import pl.net.bluesoft.rnd.processtool.ui.common.FailedProcessToolWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolActionButton;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolActionCallback;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolChildrenFilteringWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolDataWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolVaadinRenderable;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.event.WidgetEventBus;
import pl.net.bluesoft.rnd.util.i18n.I18NSource;
import pl.net.bluesoft.util.lang.Lang;
import pl.net.bluesoft.util.lang.Strings;
import pl.net.bluesoft.util.lang.TaskWatch;
import com.vaadin.Application;
import com.vaadin.terminal.Sizeable;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
/**
* Główny panel widoku zawartości kroku procesu
*
* @author [email protected], [email protected]
*/
public class ProcessDataPane extends VerticalLayout implements WidgetContextSupport {
private Logger logger = Logger.getLogger(ProcessDataPane.class.getName());
private ProcessToolBpmSession bpmSession;
private I18NSource i18NSource;
private Set<ProcessToolDataWidget> dataWidgets = new HashSet<ProcessToolDataWidget>();
private boolean isOwner;
private Application application;
private ProcessDataDisplayContext displayProcessContext;
private BpmTask task;
private HelpProvider helpFactory;
private ProcessToolActionCallback actionCallback;
private GuiAction guiAction = null;
private static enum GuiAction {
ACTION_PERFORMED, SAVE_PERFORMED, ACTION_FAILED;
}
public ProcessDataPane(Application application, ProcessToolBpmSession bpmSession, I18NSource i18NSource, BpmTask bpmTask,
ProcessDataDisplayContext hideProcessHandler) {
this.application = application;
this.bpmSession = bpmSession;
this.i18NSource = i18NSource;
displayProcessContext = hideProcessHandler;
task = bpmTask;
refreshTask();
prepare();
setMargin(new MarginInfo(false, false, true, true));
initLayout(false);
}
private void prepare() {
HelpProviderFactory helpProviderFactory =
ProcessToolContext.Util.getThreadProcessToolContext().getRegistry().lookupService(HelpProviderFactory.class.getName());
if (helpProviderFactory != null)
helpFactory = helpProviderFactory.getInstance(application, task.getProcessDefinition(), true, "step_help");
actionCallback = new MyProcessToolActionCallback();
}
/** Odśwież odśwież widok po zmianie kroku lub procesu */
private void initLayout(boolean autoHide) {
final ProcessToolContext ctx = getCurrentContext();
removeAllComponents();
setWidth(100, Sizeable.UNITS_PERCENTAGE);
dataWidgets.clear();
boolean processRunning = bpmSession.isProcessRunning(task.getInternalProcessId(), ctx);
isOwner = processRunning && !task.isFinished();
if (!isOwner)
{
//showProcessStateInformation(processRunning);
if (autoHide)
{
/* Jeżeli wstrzymujemy proces glowny, albo zamykamy podproces, sprobuj wrocic
* do odpowiedniego procesu
*/
boolean isProcessChanged = changeCurrentViewToActiveProcess();
/* Nie zmienilismy procesu, tak wiec chowamy ten widok */
if(!isProcessChanged)
{
guiAction = null;
displayProcessContext.hide();
return;
}
else
{
/* Zacznij od nowa z nowym przypisanym taskiem */
initLayout(false);
return;
}
}
}
guiAction = null;
final ProcessStateConfiguration stateConfiguration = ctx.getProcessDefinitionDAO()
.getProcessStateConfiguration(task);
Label stateDescription = new Label(getMessage(stateConfiguration.getDescription()));
stateDescription.addStyleName("h1 color processtool-title");
stateDescription.setWidth(100, Sizeable.UNITS_PERCENTAGE);
addComponent(stateDescription);
if (Strings.hasText(stateConfiguration.getCommentary())) {
addComponent(new Label(getMessage(stateConfiguration.getCommentary()), Label.CONTENT_XHTML));
}
if (helpFactory != null)
addComponent(helpFactory.helpIcon(task.getTaskName(), "step.help"));
displayProcessContext.setCaption(task.getExternalProcessId() != null ? task.getExternalProcessId() : task.getInternalProcessId());
final VerticalLayout vl = new VerticalLayout();
vl.setSpacing(true);
vl.setWidth(100, Sizeable.UNITS_PERCENTAGE);
List<ProcessStateWidget> widgets = new ArrayList<ProcessStateWidget>(stateConfiguration.getWidgets());
Collections.sort(widgets, new WidgetPriorityComparator());
TaskWatch watch = new TaskWatch(ProcessDataPane.class.getSimpleName() + " - generowanie interfejsu dla kroku " + stateConfiguration.getName());
final WidgetEventBus widgetEventBus = new WidgetEventBus();
for (final ProcessStateWidget w : widgets) {
try {
watch.watchTask(w.getClassName() + ": " + w.getName(), new Callable() {
@Override
public Object call() throws Exception {
try {
ProcessToolWidget realWidget = getWidget(w, stateConfiguration, ctx, null, widgetEventBus);
if (realWidget instanceof ProcessToolVaadinRenderable && (!nvl(w.getOptional(), false) || realWidget.hasVisibleData())) {
processWidgetChildren(w, realWidget, stateConfiguration, ctx, null, widgetEventBus);
ProcessToolVaadinRenderable vaadinW = (ProcessToolVaadinRenderable) realWidget;
vl.addComponent(vaadinW.render());
}
}
catch (Exception e) {
logger.log(Level.SEVERE, e.getMessage(), e);
vl.addComponent(new Label(getMessage("process.data.widget.exception-occurred")));
vl.addComponent(new Label(e.getMessage()));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
e.printStackTrace(new PrintWriter(baos));
vl.addComponent(new Label("<pre>" + baos.toString() + "</pre>", CONTENT_XHTML));
}
// TODO Auto-generated method stub
return null;
}
});
} catch (Exception e) {
throw new RuntimeException(e);
}
}
watch.stopAll();
logger.log(Level.INFO, watch.printSummary());
addComponent(vl);
setExpandRatio(vl,1f);
if (isOwner) {
HorizontalLayout buttonLayout = getButtonsPanel(stateConfiguration);
addComponentAsFirst(buttonLayout);
buttonLayout = getButtonsPanel(stateConfiguration);
addComponent(buttonLayout);
}
}
/** Metoda w przypadku wstrzymywania procesu przelacza widok na podproces
* lub w przypadku zamkniecia podprocesu, na proces glowny
*
* @return true jeżeli nastąpiło przełączenie
*/
private boolean changeCurrentViewToActiveProcess()
{
/* Aktualny proces */
ProcessInstance closedProcess = task.getProcessInstance();
/* Proces główny względem wstrzymywanego procesu */
ProcessInstance parentProcess = closedProcess.getParent();
boolean isSubProcess = parentProcess != null ;
boolean isParentProcess = !closedProcess.getChildren().isEmpty();
/* Zamykany proces jest podprocesem, wybierz do otwoarcia jego rodzica */
if(isSubProcess)
{
/* Przełącz się na proces głowny */
if(parentProcess.isProcessRunning())
return changeProcess(parentProcess);
}
/* Zamykany proces jest procesem glownym dla innych procesow */
if(isParentProcess)
{
/* Pobierz podprocesy skorelowane z zamykanym procesem */
for(ProcessInstance childProcess: task.getProcessInstance().getChildren())
{
if(childProcess.isProcessRunning())
{
/* Tylko jeden proces powinien być aktywny, przełącz się na
* niego
*/
return changeProcess(childProcess);
}
}
}
/* Zatrzymywany proces nie posiada ani aktywnego procesu głównego, ani
* aktywnych podprocesów. Zamknij więc widok
*/
return false;
}
private boolean changeProcess(ProcessInstance newProcess)
{
/* Get active task for current process */
List<BpmTask> activeTasks = bpmSession.findProcessTasks(newProcess, getCurrentContext());
/* Check if the current process has active task. It should has at least one */
if(activeTasks.isEmpty())
return false;
UserData user = bpmSession.getUser(getCurrentContext());
String userLogin = user.getLogin();
for(BpmTask task: activeTasks)
{
if(task.getAssignee() != null && task.getAssignee().equals(userLogin))
{
/* Change current task */
updateTask(task);
refreshTask();
return true;
}
}
/* There are no active task or the assigne is diffrent */
return false;
}
private HorizontalLayout getButtonsPanel(ProcessStateConfiguration stateConfiguration) {
// sort the actions to preserve the displaying order
List<ProcessStateAction> actionList = new ArrayList<ProcessStateAction>(stateConfiguration.getActions());
Collections.sort(actionList, new ActionPriorityComparator());
AligningHorizontalLayout buttonLayout = new AligningHorizontalLayout(Alignment.MIDDLE_RIGHT);
buttonLayout.setMargin(new MarginInfo(false, true, false, true));
buttonLayout.setWidth(100, Sizeable.UNITS_PERCENTAGE);
for (final ProcessStateAction a : actionList) {
final ProcessToolActionButton actionButton = makeButton(a);
actionButton.setEnabled(isOwner);
actionButton.loadData(task);
actionButton.setActionCallback(actionCallback);
if (actionButton instanceof ProcessToolVaadinRenderable) {
buttonLayout.addComponent(((ProcessToolVaadinRenderable) actionButton).render());
}
}
buttonLayout.addComponentAsFirst(new Label() {{
setWidth(100, Sizeable.UNITS_PERCENTAGE);
}});
buttonLayout.recalculateExpandRatios();
return buttonLayout;
}
public List<Component> getToolbarButtons() {
List<Component> buttons = new ArrayList<Component>();
Button saveButton = createSaveButton();
buttons.add(saveButton);
return buttons;
}
public boolean canSaveProcessData() {
return isOwner;
}
private Button createSaveButton() {
Button saveButton = VaadinUtility.link(i18NSource.getMessage("button.save.process.data"), new Button.ClickListener() {
@Override
public void buttonClick(Button.ClickEvent event) {
saveProcessDataButtonAction();
}
});
saveButton.addStyleName("with_message");
saveButton.setDescription(i18NSource.getMessage("button.save.process.desc"));
saveButton.setIcon(VaadinUtility.imageResource(application, "save.png"));
saveButton.setEnabled(isOwner);
return saveButton;
}
public boolean saveProcessDataButtonAction() {
final boolean[] result = { false };
withErrorHandling(application, new Runnable() {
@Override
public void run() {
if (validateWidgetsAndSaveData(task)) {
refreshTask();
guiAction = GuiAction.SAVE_PERFORMED;
initLayout(false);
result[0] = true;
}
}
});
return result[0];
}
private void refreshTask() {
task = refreshTask(bpmSession, task);
}
@Override
public void updateTask(BpmTask task) {
this.task = task;
}
@Override
public Set<ProcessToolDataWidget> getWidgets() {
return Collections.unmodifiableSet(dataWidgets);
}
@Override
public void displayValidationErrors(Map<ProcessToolDataWidget, Collection<String>> errorMap) {
String errorMessage = VaadinUtility.widgetsErrorMessage(i18NSource, errorMap);
VaadinUtility.validationNotification(application, i18NSource, errorMessage);
}
@Override
public Map<ProcessToolDataWidget, Collection<String>> getWidgetsErrors(BpmTask bpmTask, boolean skipRequired) {
Map<ProcessToolDataWidget, Collection<String>> errorMap = new HashMap();
for (ProcessToolDataWidget w : dataWidgets) {
Collection<String> errors = w.validateData(bpmTask, skipRequired);
if (errors != null && !errors.isEmpty()) {
errorMap.put(w, errors);
}
}
return errorMap;
}
@Override
public boolean validateWidgetsAndSaveData(BpmTask task) {
task = refreshTask(bpmSession, task);
Map<ProcessToolDataWidget, Collection<String>> errorMap = getWidgetsErrors(task, true);
if (!errorMap.isEmpty()) {
displayValidationErrors(errorMap);
return false;
}
saveTaskData(task);
return true;
}
@Override
public void saveTaskData(BpmTask task, ProcessToolActionButton... actions) {
for (ProcessToolDataWidget w : dataWidgets) {
w.saveData(task);
}
for (ProcessToolActionButton action : actions) {
action.saveData(task);
}
bpmSession.saveProcessInstance(task.getProcessInstance(), getCurrentContext());
}
@Override
public void saveTaskWithoutData(BpmTask task, ProcessToolActionButton... actions) {
for (ProcessToolActionButton action : actions) {
action.saveData(task);
}
}
@Override
public ProcessToolContext getCurrentContext() {
return ProcessToolContext.Util.getThreadProcessToolContext();
}
@Override
public BpmTask refreshTask(ProcessToolBpmSession bpmSession, BpmTask bpmTask) {
return bpmSession.refreshTaskData(bpmTask, getCurrentContext());
}
public String getMessage(String key) {
return i18NSource.getMessage(key);
}
private ProcessToolActionButton makeButton(ProcessStateAction a) {
try {
ProcessToolContext ctx = getCurrentContext();
ProcessToolActionButton actionButton = ctx.getRegistry().makeButton(a.getButtonName());
actionButton.setContext(a, bpmSession, application, i18NSource);
return actionButton;
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
private void processWidgetChildren(ProcessStateWidget parentWidgetConfiguration, ProcessToolWidget parentWidgetInstance,
ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx, String generatorKey, WidgetEventBus widgetEventBus) {
Set<ProcessStateWidget> children = parentWidgetConfiguration.getChildren();
List<ProcessStateWidget> sortedList = new ArrayList<ProcessStateWidget>(children);
Collections.sort(sortedList, new Comparator<ProcessStateWidget>() {
@Override
public int compare(ProcessStateWidget o1, ProcessStateWidget o2) {
if (o1.getPriority().equals(o2.getPriority())) {
return Lang.compare(o1.getId(), o2.getId());
}
return o1.getPriority().compareTo(o2.getPriority());
}
});
if(parentWidgetInstance instanceof ProcessToolChildrenFilteringWidget){
sortedList = ((ProcessToolChildrenFilteringWidget)parentWidgetInstance).filterChildren(task, sortedList);
}
for (ProcessStateWidget subW : sortedList) {
if(StringUtils.isNotEmpty(subW.getGenerateFromCollection())){
generateChildren(parentWidgetInstance, stateConfiguration, ctx, subW, widgetEventBus);
} else {
subW.setParent(parentWidgetConfiguration);
addWidgetChild(parentWidgetInstance, stateConfiguration, ctx, subW, generatorKey, widgetEventBus);
}
}
}
/**
* Comparator for {@link ProcessStateWidget} objects that takes intro account widget priority
*/
private class WidgetPriorityComparator implements Comparator<ProcessStateWidget> {
@Override
public int compare(ProcessStateWidget w1, ProcessStateWidget w2) {
if (w1 == null || w2 == null) {
throw new NullPointerException("Can not compare null ProcessStateWidgets");
}
if (w1 == w2) {
return 0;
}
if (w1.getPriority() != null && w2.getPriority() != null) {
return w1.getPriority().compareTo(w2.getPriority());
} else if (w1.getPriority() != null && w2.getPriority() == null) {
return 1;
} else if (w1.getPriority() == null && w2.getPriority() != null) {
return -1;
} else {
return w1.getId().compareTo(w2.getId());
}
}
}
/**
* Comparator for {@link ProcessStateAction} object that takes into account action priority
*/
private class ActionPriorityComparator implements Comparator<ProcessStateAction> {
@Override
public int compare(ProcessStateAction a1, ProcessStateAction a2) {
if (a1 == null || a2 == null) {
throw new NullPointerException("Can not compare null ProcessStateActions");
}
if (a1 == a2) {
return 0;
}
if (a1.getActionType() != null && a1.getActionType() != null && !a1.getActionType().equals(a2.getActionType())) {
return ProcessStateAction.SECONDARY_ACTION.equals(a1.getActionType()) ? -1 : 1;
} else if (a1.getActionType() != null && a2.getActionType() == null) {
return -1;
} else if (a1.getActionType() == null && a2.getActionType() != null) {
return 1;
} else {
if (a1.getPriority() != null && a2.getPriority() != null) {
return a1.getPriority().compareTo(a2.getPriority());
} else if (a1.getPriority() != null && a2.getPriority() == null) {
return 1;
} else if (a1.getPriority() == null && a2.getPriority() != null) {
return -1;
} else {
return a1.getId().compareTo(a2.getId());
}
}
}
}
private void generateChildren(ProcessToolWidget parentWidgetInstance, ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx,
ProcessStateWidget subW, WidgetEventBus widgetEventBus) {
String collection = task.getProcessInstance().getSimpleAttributeValue(subW.getGenerateFromCollection(), null);
if(StringUtils.isEmpty(collection))
return;
String[] items = collection.split("[,; ]");
for(String item : items){
addWidgetChild(parentWidgetInstance, stateConfiguration, ctx, subW, item, widgetEventBus);
}
}
private void addWidgetChild(ProcessToolWidget parentWidgetInstance, ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx,
ProcessStateWidget subW, String generatorKey, WidgetEventBus widgetEventBus) {
ProcessToolWidget widgetInstance = getWidget(subW, stateConfiguration, ctx, generatorKey, widgetEventBus);
if (!nvl(subW.getOptional(), false) || widgetInstance.hasVisibleData()) {
processWidgetChildren(subW, widgetInstance, stateConfiguration, ctx, generatorKey, widgetEventBus);
parentWidgetInstance.addChild(widgetInstance);
}
}
private ProcessToolWidget getWidget(ProcessStateWidget w, ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx,
String generatorKey, WidgetEventBus widgetEventBus) {
ProcessToolWidget processToolWidget;
try {
ProcessToolRegistry toolRegistry = VaadinUtility.getProcessToolContext(application.getContext()).getRegistry();
processToolWidget = w.getClassName() == null ? toolRegistry.makeWidget(w.getName()) : toolRegistry.makeWidget(w.getClassName());
processToolWidget.setContext(stateConfiguration, w, i18NSource, bpmSession, application,
bpmSession.getPermissionsForWidget(w, ctx), isOwner);
processToolWidget.setGeneratorKey(generatorKey);
processToolWidget.setWidgetEventBus(widgetEventBus);
if (processToolWidget instanceof ProcessToolDataWidget) {
((ProcessToolDataWidget) processToolWidget).loadData(task);
dataWidgets.add((ProcessToolDataWidget) processToolWidget);
}
}
catch (final Exception e) {
logger.log(Level.SEVERE, e.getMessage(), e);
FailedProcessToolWidget failedProcessToolVaadinWidget = new FailedProcessToolWidget(e);
failedProcessToolVaadinWidget.setContext(stateConfiguration, w, i18NSource, bpmSession, application,
bpmSession.getPermissionsForWidget(w, ctx),
isOwner);
dataWidgets.add(failedProcessToolVaadinWidget);
processToolWidget = failedProcessToolVaadinWidget;
}
return processToolWidget;
}
private class MyProcessToolActionCallback implements ProcessToolActionCallback, Serializable {
private void actionCompleted(GuiAction guiAction, ProcessStateAction action) {
ProcessDataPane.this.guiAction = guiAction;
refreshTask();
initLayout(action.getAutohide());
}
@Override
public void actionPerformed(ProcessStateAction action) {
actionCompleted(GuiAction.ACTION_PERFORMED, action);
}
@Override
public void actionFailed(ProcessStateAction action) {
actionCompleted(GuiAction.ACTION_FAILED, action);
}
@Override
public WidgetContextSupport getWidgetContextSupport() {
return ProcessDataPane.this;
}
}
}
| /**
* Główny panel widoku zawartości kroku procesu
*
* @author [email protected], [email protected]
*/ | package pl.net.bluesoft.rnd.processtool.ui.process;
import static com.vaadin.ui.Label.CONTENT_XHTML;
import static org.aperteworkflow.util.vaadin.VaadinExceptionHandler.Util.withErrorHandling;
import static pl.net.bluesoft.util.lang.Formats.nvl;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.lang3.StringUtils;
import org.aperteworkflow.ui.help.HelpProvider;
import org.aperteworkflow.ui.help.HelpProviderFactory;
import org.aperteworkflow.util.vaadin.VaadinUtility;
import org.aperteworkflow.util.vaadin.ui.AligningHorizontalLayout;
import pl.net.bluesoft.rnd.processtool.ProcessToolContext;
import pl.net.bluesoft.rnd.processtool.bpm.ProcessToolBpmSession;
import pl.net.bluesoft.rnd.processtool.model.BpmTask;
import pl.net.bluesoft.rnd.processtool.model.ProcessInstance;
import pl.net.bluesoft.rnd.processtool.model.UserData;
import pl.net.bluesoft.rnd.processtool.model.config.ProcessStateAction;
import pl.net.bluesoft.rnd.processtool.model.config.ProcessStateConfiguration;
import pl.net.bluesoft.rnd.processtool.model.config.ProcessStateWidget;
import pl.net.bluesoft.rnd.processtool.plugins.ProcessToolRegistry;
import pl.net.bluesoft.rnd.processtool.ui.WidgetContextSupport;
import pl.net.bluesoft.rnd.processtool.ui.common.FailedProcessToolWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolActionButton;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolActionCallback;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolChildrenFilteringWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolDataWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolVaadinRenderable;
import pl.net.bluesoft.rnd.processtool.ui.widgets.ProcessToolWidget;
import pl.net.bluesoft.rnd.processtool.ui.widgets.event.WidgetEventBus;
import pl.net.bluesoft.rnd.util.i18n.I18NSource;
import pl.net.bluesoft.util.lang.Lang;
import pl.net.bluesoft.util.lang.Strings;
import pl.net.bluesoft.util.lang.TaskWatch;
import com.vaadin.Application;
import com.vaadin.terminal.Sizeable;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
/**
* Główny panel widoku <SUF>*/
public class ProcessDataPane extends VerticalLayout implements WidgetContextSupport {
private Logger logger = Logger.getLogger(ProcessDataPane.class.getName());
private ProcessToolBpmSession bpmSession;
private I18NSource i18NSource;
private Set<ProcessToolDataWidget> dataWidgets = new HashSet<ProcessToolDataWidget>();
private boolean isOwner;
private Application application;
private ProcessDataDisplayContext displayProcessContext;
private BpmTask task;
private HelpProvider helpFactory;
private ProcessToolActionCallback actionCallback;
private GuiAction guiAction = null;
private static enum GuiAction {
ACTION_PERFORMED, SAVE_PERFORMED, ACTION_FAILED;
}
public ProcessDataPane(Application application, ProcessToolBpmSession bpmSession, I18NSource i18NSource, BpmTask bpmTask,
ProcessDataDisplayContext hideProcessHandler) {
this.application = application;
this.bpmSession = bpmSession;
this.i18NSource = i18NSource;
displayProcessContext = hideProcessHandler;
task = bpmTask;
refreshTask();
prepare();
setMargin(new MarginInfo(false, false, true, true));
initLayout(false);
}
private void prepare() {
HelpProviderFactory helpProviderFactory =
ProcessToolContext.Util.getThreadProcessToolContext().getRegistry().lookupService(HelpProviderFactory.class.getName());
if (helpProviderFactory != null)
helpFactory = helpProviderFactory.getInstance(application, task.getProcessDefinition(), true, "step_help");
actionCallback = new MyProcessToolActionCallback();
}
/** Odśwież odśwież widok po zmianie kroku lub procesu */
private void initLayout(boolean autoHide) {
final ProcessToolContext ctx = getCurrentContext();
removeAllComponents();
setWidth(100, Sizeable.UNITS_PERCENTAGE);
dataWidgets.clear();
boolean processRunning = bpmSession.isProcessRunning(task.getInternalProcessId(), ctx);
isOwner = processRunning && !task.isFinished();
if (!isOwner)
{
//showProcessStateInformation(processRunning);
if (autoHide)
{
/* Jeżeli wstrzymujemy proces glowny, albo zamykamy podproces, sprobuj wrocic
* do odpowiedniego procesu
*/
boolean isProcessChanged = changeCurrentViewToActiveProcess();
/* Nie zmienilismy procesu, tak wiec chowamy ten widok */
if(!isProcessChanged)
{
guiAction = null;
displayProcessContext.hide();
return;
}
else
{
/* Zacznij od nowa z nowym przypisanym taskiem */
initLayout(false);
return;
}
}
}
guiAction = null;
final ProcessStateConfiguration stateConfiguration = ctx.getProcessDefinitionDAO()
.getProcessStateConfiguration(task);
Label stateDescription = new Label(getMessage(stateConfiguration.getDescription()));
stateDescription.addStyleName("h1 color processtool-title");
stateDescription.setWidth(100, Sizeable.UNITS_PERCENTAGE);
addComponent(stateDescription);
if (Strings.hasText(stateConfiguration.getCommentary())) {
addComponent(new Label(getMessage(stateConfiguration.getCommentary()), Label.CONTENT_XHTML));
}
if (helpFactory != null)
addComponent(helpFactory.helpIcon(task.getTaskName(), "step.help"));
displayProcessContext.setCaption(task.getExternalProcessId() != null ? task.getExternalProcessId() : task.getInternalProcessId());
final VerticalLayout vl = new VerticalLayout();
vl.setSpacing(true);
vl.setWidth(100, Sizeable.UNITS_PERCENTAGE);
List<ProcessStateWidget> widgets = new ArrayList<ProcessStateWidget>(stateConfiguration.getWidgets());
Collections.sort(widgets, new WidgetPriorityComparator());
TaskWatch watch = new TaskWatch(ProcessDataPane.class.getSimpleName() + " - generowanie interfejsu dla kroku " + stateConfiguration.getName());
final WidgetEventBus widgetEventBus = new WidgetEventBus();
for (final ProcessStateWidget w : widgets) {
try {
watch.watchTask(w.getClassName() + ": " + w.getName(), new Callable() {
@Override
public Object call() throws Exception {
try {
ProcessToolWidget realWidget = getWidget(w, stateConfiguration, ctx, null, widgetEventBus);
if (realWidget instanceof ProcessToolVaadinRenderable && (!nvl(w.getOptional(), false) || realWidget.hasVisibleData())) {
processWidgetChildren(w, realWidget, stateConfiguration, ctx, null, widgetEventBus);
ProcessToolVaadinRenderable vaadinW = (ProcessToolVaadinRenderable) realWidget;
vl.addComponent(vaadinW.render());
}
}
catch (Exception e) {
logger.log(Level.SEVERE, e.getMessage(), e);
vl.addComponent(new Label(getMessage("process.data.widget.exception-occurred")));
vl.addComponent(new Label(e.getMessage()));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
e.printStackTrace(new PrintWriter(baos));
vl.addComponent(new Label("<pre>" + baos.toString() + "</pre>", CONTENT_XHTML));
}
// TODO Auto-generated method stub
return null;
}
});
} catch (Exception e) {
throw new RuntimeException(e);
}
}
watch.stopAll();
logger.log(Level.INFO, watch.printSummary());
addComponent(vl);
setExpandRatio(vl,1f);
if (isOwner) {
HorizontalLayout buttonLayout = getButtonsPanel(stateConfiguration);
addComponentAsFirst(buttonLayout);
buttonLayout = getButtonsPanel(stateConfiguration);
addComponent(buttonLayout);
}
}
/** Metoda w przypadku wstrzymywania procesu przelacza widok na podproces
* lub w przypadku zamkniecia podprocesu, na proces glowny
*
* @return true jeżeli nastąpiło przełączenie
*/
private boolean changeCurrentViewToActiveProcess()
{
/* Aktualny proces */
ProcessInstance closedProcess = task.getProcessInstance();
/* Proces główny względem wstrzymywanego procesu */
ProcessInstance parentProcess = closedProcess.getParent();
boolean isSubProcess = parentProcess != null ;
boolean isParentProcess = !closedProcess.getChildren().isEmpty();
/* Zamykany proces jest podprocesem, wybierz do otwoarcia jego rodzica */
if(isSubProcess)
{
/* Przełącz się na proces głowny */
if(parentProcess.isProcessRunning())
return changeProcess(parentProcess);
}
/* Zamykany proces jest procesem glownym dla innych procesow */
if(isParentProcess)
{
/* Pobierz podprocesy skorelowane z zamykanym procesem */
for(ProcessInstance childProcess: task.getProcessInstance().getChildren())
{
if(childProcess.isProcessRunning())
{
/* Tylko jeden proces powinien być aktywny, przełącz się na
* niego
*/
return changeProcess(childProcess);
}
}
}
/* Zatrzymywany proces nie posiada ani aktywnego procesu głównego, ani
* aktywnych podprocesów. Zamknij więc widok
*/
return false;
}
private boolean changeProcess(ProcessInstance newProcess)
{
/* Get active task for current process */
List<BpmTask> activeTasks = bpmSession.findProcessTasks(newProcess, getCurrentContext());
/* Check if the current process has active task. It should has at least one */
if(activeTasks.isEmpty())
return false;
UserData user = bpmSession.getUser(getCurrentContext());
String userLogin = user.getLogin();
for(BpmTask task: activeTasks)
{
if(task.getAssignee() != null && task.getAssignee().equals(userLogin))
{
/* Change current task */
updateTask(task);
refreshTask();
return true;
}
}
/* There are no active task or the assigne is diffrent */
return false;
}
private HorizontalLayout getButtonsPanel(ProcessStateConfiguration stateConfiguration) {
// sort the actions to preserve the displaying order
List<ProcessStateAction> actionList = new ArrayList<ProcessStateAction>(stateConfiguration.getActions());
Collections.sort(actionList, new ActionPriorityComparator());
AligningHorizontalLayout buttonLayout = new AligningHorizontalLayout(Alignment.MIDDLE_RIGHT);
buttonLayout.setMargin(new MarginInfo(false, true, false, true));
buttonLayout.setWidth(100, Sizeable.UNITS_PERCENTAGE);
for (final ProcessStateAction a : actionList) {
final ProcessToolActionButton actionButton = makeButton(a);
actionButton.setEnabled(isOwner);
actionButton.loadData(task);
actionButton.setActionCallback(actionCallback);
if (actionButton instanceof ProcessToolVaadinRenderable) {
buttonLayout.addComponent(((ProcessToolVaadinRenderable) actionButton).render());
}
}
buttonLayout.addComponentAsFirst(new Label() {{
setWidth(100, Sizeable.UNITS_PERCENTAGE);
}});
buttonLayout.recalculateExpandRatios();
return buttonLayout;
}
public List<Component> getToolbarButtons() {
List<Component> buttons = new ArrayList<Component>();
Button saveButton = createSaveButton();
buttons.add(saveButton);
return buttons;
}
public boolean canSaveProcessData() {
return isOwner;
}
private Button createSaveButton() {
Button saveButton = VaadinUtility.link(i18NSource.getMessage("button.save.process.data"), new Button.ClickListener() {
@Override
public void buttonClick(Button.ClickEvent event) {
saveProcessDataButtonAction();
}
});
saveButton.addStyleName("with_message");
saveButton.setDescription(i18NSource.getMessage("button.save.process.desc"));
saveButton.setIcon(VaadinUtility.imageResource(application, "save.png"));
saveButton.setEnabled(isOwner);
return saveButton;
}
public boolean saveProcessDataButtonAction() {
final boolean[] result = { false };
withErrorHandling(application, new Runnable() {
@Override
public void run() {
if (validateWidgetsAndSaveData(task)) {
refreshTask();
guiAction = GuiAction.SAVE_PERFORMED;
initLayout(false);
result[0] = true;
}
}
});
return result[0];
}
private void refreshTask() {
task = refreshTask(bpmSession, task);
}
@Override
public void updateTask(BpmTask task) {
this.task = task;
}
@Override
public Set<ProcessToolDataWidget> getWidgets() {
return Collections.unmodifiableSet(dataWidgets);
}
@Override
public void displayValidationErrors(Map<ProcessToolDataWidget, Collection<String>> errorMap) {
String errorMessage = VaadinUtility.widgetsErrorMessage(i18NSource, errorMap);
VaadinUtility.validationNotification(application, i18NSource, errorMessage);
}
@Override
public Map<ProcessToolDataWidget, Collection<String>> getWidgetsErrors(BpmTask bpmTask, boolean skipRequired) {
Map<ProcessToolDataWidget, Collection<String>> errorMap = new HashMap();
for (ProcessToolDataWidget w : dataWidgets) {
Collection<String> errors = w.validateData(bpmTask, skipRequired);
if (errors != null && !errors.isEmpty()) {
errorMap.put(w, errors);
}
}
return errorMap;
}
@Override
public boolean validateWidgetsAndSaveData(BpmTask task) {
task = refreshTask(bpmSession, task);
Map<ProcessToolDataWidget, Collection<String>> errorMap = getWidgetsErrors(task, true);
if (!errorMap.isEmpty()) {
displayValidationErrors(errorMap);
return false;
}
saveTaskData(task);
return true;
}
@Override
public void saveTaskData(BpmTask task, ProcessToolActionButton... actions) {
for (ProcessToolDataWidget w : dataWidgets) {
w.saveData(task);
}
for (ProcessToolActionButton action : actions) {
action.saveData(task);
}
bpmSession.saveProcessInstance(task.getProcessInstance(), getCurrentContext());
}
@Override
public void saveTaskWithoutData(BpmTask task, ProcessToolActionButton... actions) {
for (ProcessToolActionButton action : actions) {
action.saveData(task);
}
}
@Override
public ProcessToolContext getCurrentContext() {
return ProcessToolContext.Util.getThreadProcessToolContext();
}
@Override
public BpmTask refreshTask(ProcessToolBpmSession bpmSession, BpmTask bpmTask) {
return bpmSession.refreshTaskData(bpmTask, getCurrentContext());
}
public String getMessage(String key) {
return i18NSource.getMessage(key);
}
private ProcessToolActionButton makeButton(ProcessStateAction a) {
try {
ProcessToolContext ctx = getCurrentContext();
ProcessToolActionButton actionButton = ctx.getRegistry().makeButton(a.getButtonName());
actionButton.setContext(a, bpmSession, application, i18NSource);
return actionButton;
}
catch (Exception e) {
throw new RuntimeException(e);
}
}
private void processWidgetChildren(ProcessStateWidget parentWidgetConfiguration, ProcessToolWidget parentWidgetInstance,
ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx, String generatorKey, WidgetEventBus widgetEventBus) {
Set<ProcessStateWidget> children = parentWidgetConfiguration.getChildren();
List<ProcessStateWidget> sortedList = new ArrayList<ProcessStateWidget>(children);
Collections.sort(sortedList, new Comparator<ProcessStateWidget>() {
@Override
public int compare(ProcessStateWidget o1, ProcessStateWidget o2) {
if (o1.getPriority().equals(o2.getPriority())) {
return Lang.compare(o1.getId(), o2.getId());
}
return o1.getPriority().compareTo(o2.getPriority());
}
});
if(parentWidgetInstance instanceof ProcessToolChildrenFilteringWidget){
sortedList = ((ProcessToolChildrenFilteringWidget)parentWidgetInstance).filterChildren(task, sortedList);
}
for (ProcessStateWidget subW : sortedList) {
if(StringUtils.isNotEmpty(subW.getGenerateFromCollection())){
generateChildren(parentWidgetInstance, stateConfiguration, ctx, subW, widgetEventBus);
} else {
subW.setParent(parentWidgetConfiguration);
addWidgetChild(parentWidgetInstance, stateConfiguration, ctx, subW, generatorKey, widgetEventBus);
}
}
}
/**
* Comparator for {@link ProcessStateWidget} objects that takes intro account widget priority
*/
private class WidgetPriorityComparator implements Comparator<ProcessStateWidget> {
@Override
public int compare(ProcessStateWidget w1, ProcessStateWidget w2) {
if (w1 == null || w2 == null) {
throw new NullPointerException("Can not compare null ProcessStateWidgets");
}
if (w1 == w2) {
return 0;
}
if (w1.getPriority() != null && w2.getPriority() != null) {
return w1.getPriority().compareTo(w2.getPriority());
} else if (w1.getPriority() != null && w2.getPriority() == null) {
return 1;
} else if (w1.getPriority() == null && w2.getPriority() != null) {
return -1;
} else {
return w1.getId().compareTo(w2.getId());
}
}
}
/**
* Comparator for {@link ProcessStateAction} object that takes into account action priority
*/
private class ActionPriorityComparator implements Comparator<ProcessStateAction> {
@Override
public int compare(ProcessStateAction a1, ProcessStateAction a2) {
if (a1 == null || a2 == null) {
throw new NullPointerException("Can not compare null ProcessStateActions");
}
if (a1 == a2) {
return 0;
}
if (a1.getActionType() != null && a1.getActionType() != null && !a1.getActionType().equals(a2.getActionType())) {
return ProcessStateAction.SECONDARY_ACTION.equals(a1.getActionType()) ? -1 : 1;
} else if (a1.getActionType() != null && a2.getActionType() == null) {
return -1;
} else if (a1.getActionType() == null && a2.getActionType() != null) {
return 1;
} else {
if (a1.getPriority() != null && a2.getPriority() != null) {
return a1.getPriority().compareTo(a2.getPriority());
} else if (a1.getPriority() != null && a2.getPriority() == null) {
return 1;
} else if (a1.getPriority() == null && a2.getPriority() != null) {
return -1;
} else {
return a1.getId().compareTo(a2.getId());
}
}
}
}
private void generateChildren(ProcessToolWidget parentWidgetInstance, ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx,
ProcessStateWidget subW, WidgetEventBus widgetEventBus) {
String collection = task.getProcessInstance().getSimpleAttributeValue(subW.getGenerateFromCollection(), null);
if(StringUtils.isEmpty(collection))
return;
String[] items = collection.split("[,; ]");
for(String item : items){
addWidgetChild(parentWidgetInstance, stateConfiguration, ctx, subW, item, widgetEventBus);
}
}
private void addWidgetChild(ProcessToolWidget parentWidgetInstance, ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx,
ProcessStateWidget subW, String generatorKey, WidgetEventBus widgetEventBus) {
ProcessToolWidget widgetInstance = getWidget(subW, stateConfiguration, ctx, generatorKey, widgetEventBus);
if (!nvl(subW.getOptional(), false) || widgetInstance.hasVisibleData()) {
processWidgetChildren(subW, widgetInstance, stateConfiguration, ctx, generatorKey, widgetEventBus);
parentWidgetInstance.addChild(widgetInstance);
}
}
private ProcessToolWidget getWidget(ProcessStateWidget w, ProcessStateConfiguration stateConfiguration, ProcessToolContext ctx,
String generatorKey, WidgetEventBus widgetEventBus) {
ProcessToolWidget processToolWidget;
try {
ProcessToolRegistry toolRegistry = VaadinUtility.getProcessToolContext(application.getContext()).getRegistry();
processToolWidget = w.getClassName() == null ? toolRegistry.makeWidget(w.getName()) : toolRegistry.makeWidget(w.getClassName());
processToolWidget.setContext(stateConfiguration, w, i18NSource, bpmSession, application,
bpmSession.getPermissionsForWidget(w, ctx), isOwner);
processToolWidget.setGeneratorKey(generatorKey);
processToolWidget.setWidgetEventBus(widgetEventBus);
if (processToolWidget instanceof ProcessToolDataWidget) {
((ProcessToolDataWidget) processToolWidget).loadData(task);
dataWidgets.add((ProcessToolDataWidget) processToolWidget);
}
}
catch (final Exception e) {
logger.log(Level.SEVERE, e.getMessage(), e);
FailedProcessToolWidget failedProcessToolVaadinWidget = new FailedProcessToolWidget(e);
failedProcessToolVaadinWidget.setContext(stateConfiguration, w, i18NSource, bpmSession, application,
bpmSession.getPermissionsForWidget(w, ctx),
isOwner);
dataWidgets.add(failedProcessToolVaadinWidget);
processToolWidget = failedProcessToolVaadinWidget;
}
return processToolWidget;
}
private class MyProcessToolActionCallback implements ProcessToolActionCallback, Serializable {
private void actionCompleted(GuiAction guiAction, ProcessStateAction action) {
ProcessDataPane.this.guiAction = guiAction;
refreshTask();
initLayout(action.getAutohide());
}
@Override
public void actionPerformed(ProcessStateAction action) {
actionCompleted(GuiAction.ACTION_PERFORMED, action);
}
@Override
public void actionFailed(ProcessStateAction action) {
actionCompleted(GuiAction.ACTION_FAILED, action);
}
@Override
public WidgetContextSupport getWidgetContextSupport() {
return ProcessDataPane.this;
}
}
}
| f | null |
378 | 7146_1 | bojan-wik/SeleniumWithJavaCourse | 726 | src/Chapter13_SeleniumExcercises5/HTTPSCertificates.java | package Chapter13_SeleniumExcercises5;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.DesiredCapabilities;
import java.util.concurrent.TimeUnit;
/**
* Zadanie: wejść na stronę bez certyfikatu SSL (http) i zaakceptować ten brak certyfikatu, tak aby przejść do właściwej strony,
* żeby móc kontynuować testy.
*/
public class HTTPSCertificates {
public static void main(String[] args) {
/**
* Muszę dodać konkretne capabilities do przeglądarki Chrome.
* Najpier tworzę instancję klasy DesiredCapabilities, która dzięki metodzie chrome() pozwoli mi customizować przeglądarke Chrome.
* Potem na tym obiekcie wywoułuję metode acceptInsecureCerts(), która stanowi capability, o które chcę 'wzbogacić' Chrome
*/
DesiredCapabilities desiredCapabilities = DesiredCapabilities.chrome();
// pierwszy sposób
desiredCapabilities.acceptInsecureCerts();
// drugi sposób
//desiredCapabilities.setCapability(CapabilityType.ACCEPT_INSECURE_CERTS, true);
/**
* Tworzę instancję klasy ChromeOptions (która pozwala na tworzenie lokalnych ustawień dla Chrome)
* i potem za pomocą metody merge() 'domergowuję' wcześniej zdefiniowane capabilities -
* żeby Chrome akceptował insecure certs
*/
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.merge(desiredCapabilities);
/**
* Potem po staremu definuję co zawsze, z tą różnicą, że przy tworzeniu instancj klasy WebDriver, w metodzie ChromeDriver() jako parametr
* podaję obiekt klasy ChromeOptions (moje lokalne ustawienia dla Chrome)
*/
System.setProperty("webdriver.chrome.driver", "C:\\Tools\\Webdrivers\\Chrome\\91\\chromedriver.exe");
WebDriver driver = new ChromeDriver(chromeOptions);
driver.manage().timeouts().implicitlyWait(2, TimeUnit.SECONDS);
/**
* W tym momencie mój Chrome bez problemu otwiera mi też strony http, więc nie jestem w stanie przetestować, jak działa to rozwiązanie
*/
String url = "http://www.webscantest.com/";
driver.get(url);
driver.manage().window().maximize();
//driver.quit();
}
}
| /**
* Muszę dodać konkretne capabilities do przeglądarki Chrome.
* Najpier tworzę instancję klasy DesiredCapabilities, która dzięki metodzie chrome() pozwoli mi customizować przeglądarke Chrome.
* Potem na tym obiekcie wywoułuję metode acceptInsecureCerts(), która stanowi capability, o które chcę 'wzbogacić' Chrome
*/ | package Chapter13_SeleniumExcercises5;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.DesiredCapabilities;
import java.util.concurrent.TimeUnit;
/**
* Zadanie: wejść na stronę bez certyfikatu SSL (http) i zaakceptować ten brak certyfikatu, tak aby przejść do właściwej strony,
* żeby móc kontynuować testy.
*/
public class HTTPSCertificates {
public static void main(String[] args) {
/**
* Muszę dodać konkretne <SUF>*/
DesiredCapabilities desiredCapabilities = DesiredCapabilities.chrome();
// pierwszy sposób
desiredCapabilities.acceptInsecureCerts();
// drugi sposób
//desiredCapabilities.setCapability(CapabilityType.ACCEPT_INSECURE_CERTS, true);
/**
* Tworzę instancję klasy ChromeOptions (która pozwala na tworzenie lokalnych ustawień dla Chrome)
* i potem za pomocą metody merge() 'domergowuję' wcześniej zdefiniowane capabilities -
* żeby Chrome akceptował insecure certs
*/
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.merge(desiredCapabilities);
/**
* Potem po staremu definuję co zawsze, z tą różnicą, że przy tworzeniu instancj klasy WebDriver, w metodzie ChromeDriver() jako parametr
* podaję obiekt klasy ChromeOptions (moje lokalne ustawienia dla Chrome)
*/
System.setProperty("webdriver.chrome.driver", "C:\\Tools\\Webdrivers\\Chrome\\91\\chromedriver.exe");
WebDriver driver = new ChromeDriver(chromeOptions);
driver.manage().timeouts().implicitlyWait(2, TimeUnit.SECONDS);
/**
* W tym momencie mój Chrome bez problemu otwiera mi też strony http, więc nie jestem w stanie przetestować, jak działa to rozwiązanie
*/
String url = "http://www.webscantest.com/";
driver.get(url);
driver.manage().window().maximize();
//driver.quit();
}
}
| f | null |
379 | 631_0 | broo2s/ingress-apk-mod | 295 | ifc/com/nianticproject/ingress/common/inventory/ui/IndistinguishableItems.java | package com.nianticproject.ingress.common.inventory.ui;
import com.nianticproject.ingress.common.model.PlayerModel;
import com.nianticproject.ingress.gameentity.GameEntity;
import com.nianticproject.ingress.gameentity.components.ItemRarity;
import com.nianticproject.ingress.shared.ItemType;
import java.util.Collection;
import java.util.List;
public class IndistinguishableItems {
public ItemType getType() {
return null;
}
public int getLevel() {
return 0;
}
public ItemRarity getRarity() {
return null;
}
public int getCount() {
return 0;
}
public GameEntity getEntity() {
return null;
}
// playerModel jest chyba wykorzystywany do sortowania kluczy po odległości do bieżącej lokalizacji. Może być nullem
public static List<IndistinguishableItems> fromItemsByPlayerInfo(PlayerModel playerModel, Collection items) {
return null;
}
}
| // playerModel jest chyba wykorzystywany do sortowania kluczy po odległości do bieżącej lokalizacji. Może być nullem | package com.nianticproject.ingress.common.inventory.ui;
import com.nianticproject.ingress.common.model.PlayerModel;
import com.nianticproject.ingress.gameentity.GameEntity;
import com.nianticproject.ingress.gameentity.components.ItemRarity;
import com.nianticproject.ingress.shared.ItemType;
import java.util.Collection;
import java.util.List;
public class IndistinguishableItems {
public ItemType getType() {
return null;
}
public int getLevel() {
return 0;
}
public ItemRarity getRarity() {
return null;
}
public int getCount() {
return 0;
}
public GameEntity getEntity() {
return null;
}
// playerModel jest <SUF>
public static List<IndistinguishableItems> fromItemsByPlayerInfo(PlayerModel playerModel, Collection items) {
return null;
}
}
| f | null |
380 | 4035_2 | bruderooo/Dashboard | 456 | src/logicLayer/sensors/AccumulatorLoadSensor.java | package logicLayer.sensors;
/**
* Metoda odpowiedzialna za poziom naladowania akumulatora.
* Implementuje interfejs Sensor.
*
* @author Daniel Londka
* @author Szymon Jacon
*
* @see logicLayer.sensors.Sensor
*/
public class AccumulatorLoadSensor implements Sensor {
public static double maxLoad = 100.0;
private double currentLoad;
/**
* Konstruktor, ustawia pole odpowiedzialne za obecny poziom naladowania na maksymalny.
*/
public AccumulatorLoadSensor() {
this.currentLoad = maxLoad;
}
public void setCurrentLoad(double currentLoad) {
this.currentLoad = currentLoad;
}
@Override
public String toString() {
return "Poziom naładowania akumulatora: " + currentLoad + "/" + maxLoad;
}
/**
* Metoda zwracajaca wartosc naladowania akumulatora.
*
* @return poziom naladowania akumulatora w procentach
*/
@Override
public double getValue() {
return currentLoad;
}
/**
* Metoda zwracajaca informacje o statusie akumulatora.
*
* @return stan akumulatora czy wszystko jest dobrze, czy nalezy sprawdzic, czy jest zle
*/
@Override
public int status() {
if (currentLoad <= maxLoad && currentLoad >= 0.6 * maxLoad) return GOOD;
if (currentLoad < 0.6 * maxLoad && currentLoad >= 0.1 * maxLoad) return CHECK;
else return BAD;
}
}
| /**
* Metoda zwracajaca wartosc naladowania akumulatora.
*
* @return poziom naladowania akumulatora w procentach
*/ | package logicLayer.sensors;
/**
* Metoda odpowiedzialna za poziom naladowania akumulatora.
* Implementuje interfejs Sensor.
*
* @author Daniel Londka
* @author Szymon Jacon
*
* @see logicLayer.sensors.Sensor
*/
public class AccumulatorLoadSensor implements Sensor {
public static double maxLoad = 100.0;
private double currentLoad;
/**
* Konstruktor, ustawia pole odpowiedzialne za obecny poziom naladowania na maksymalny.
*/
public AccumulatorLoadSensor() {
this.currentLoad = maxLoad;
}
public void setCurrentLoad(double currentLoad) {
this.currentLoad = currentLoad;
}
@Override
public String toString() {
return "Poziom naładowania akumulatora: " + currentLoad + "/" + maxLoad;
}
/**
* Metoda zwracajaca wartosc <SUF>*/
@Override
public double getValue() {
return currentLoad;
}
/**
* Metoda zwracajaca informacje o statusie akumulatora.
*
* @return stan akumulatora czy wszystko jest dobrze, czy nalezy sprawdzic, czy jest zle
*/
@Override
public int status() {
if (currentLoad <= maxLoad && currentLoad >= 0.6 * maxLoad) return GOOD;
if (currentLoad < 0.6 * maxLoad && currentLoad >= 0.1 * maxLoad) return CHECK;
else return BAD;
}
}
| f | null |
382 | 6871_4 | brzaskun/NetBeansProjects | 4,438 | npkpir_23/src/java/view/Vat27FKView.java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package view;
import comparator.Dokfkcomparator;
import dao.Deklaracjavat27DAO;
import dao.PodatnikDAO;
import dao.DokDAOfk;
import dao.VatuepodatnikDAO;
import entity.Deklaracjavat27;
import entity.Vat27;
import entityfk.Dokfk;
import entityfk.EVatwpisFK;
import entityfk.Vatuepodatnik;
import entityfk.VatuepodatnikPK;
import error.E;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.PostConstruct;
import javax.inject.Named;
import javax.faces.view.ViewScoped;
import javax.inject.Inject;
import msg.Msg;import pdf.PdfVAT27dekl;
import pdf.PdfVat27;
import pdf.PdfVatUE;
import waluty.Z;
/**
*
* @author Osito
*/
@Named
@ViewScoped
public class Vat27FKView implements Serializable {
//lista gdzie beda podsumowane wartosci
private List<Vat27> klienciWDTWNT;
private List<Vat27> listawybranych;
private List<Dokfk> listaDokfk;
@Inject
private WpisView wpisView;
@Inject
private DokDAOfk dokDAOfk;
@Inject
private VatuepodatnikDAO vatuepodatnikDAO;
private double sumawybranych;
private String opisvatuepkpir;
private boolean deklaracja0korekta1;
private List<Deklaracjavat27> deklaracjevat27;
@Inject
private Deklaracjavat27DAO deklaracjavat27DAO;
@Inject
private Deklaracjavat27 dekl27selected;
@Inject
private PodatnikDAO podatnikDAO;
public Vat27FKView() {
klienciWDTWNT = Collections.synchronizedList(new ArrayList<>());
listaDokfk = Collections.synchronizedList(new ArrayList<>());
}
@PostConstruct
public void init() { //E.m(this);
List<Dokfk> listadokumentow = Collections.synchronizedList(new ArrayList<>());
//List<Dokfk> dokvatmc = Collections.synchronizedList(new ArrayList<>());
Integer rok = wpisView.getRokWpisu();
String mc = wpisView.getMiesiacWpisu();
String podatnik = wpisView.getPodatnikWpisu();
try {
listadokumentow = dokDAOfk.findDokfkPodatnikRokMc(wpisView);
} catch (Exception e) {
E.e(e);
}
opisvatuepkpir = wpisView.getPodatnikWpisu()+" Zestawienie dokumentów do deklaracji VAT-27 na koniec "+ rok+"/"+mc+" rozliczenie miesięczne";
//jest miesiecznie wiec nie ma co wybierac
if (listadokumentow != null) {
Collections.sort(listadokumentow, new Dokfkcomparator());
//a teraz podsumuj klientów
klienciWDTWNT.addAll(kontrahenciUE(listadokumentow));
double sumanettovatue = 0.0;
double sumanettovatuewaluta = 0.0;
for (Dokfk p : listadokumentow) {
for (Vat27 s : klienciWDTWNT) {
if (p.getKontr().getNip().equals(s.getKontrahent().getNip()) && p.getRodzajedok().getSkrot().equals(s.getTransakcja())) {
double[] t = pobierzwartosci(p.getEwidencjaVAT());
double netto = t[0];
double nettowaluta = t[1];
s.setNetto(netto + s.getNetto());
s.setNettowaluta(nettowaluta + s.getNettowaluta());
s.setLiczbadok(s.getLiczbadok() + 1);
s.getZawierafk().add(p);
s.setNazwawaluty(p.getWalutadokumentu());
p.setVat27(s);
listaDokfk.add(p);
sumanettovatue += netto;
sumanettovatuewaluta += nettowaluta;
break;
}
}
}
Vat27 rzadpodsumowanie = new Vat27("podsum.", null, Z.z(sumanettovatue), Z.z(sumanettovatuewaluta));
klienciWDTWNT.add(rzadpodsumowanie);
try {
pobierzdeklaracje27();
Deklaracjavat27 d = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d != null) {
deklaracja0korekta1 = true;
} else {
deklaracja0korekta1 = false;
}
} catch (Exception e) {
E.e(e);
}
//zachowajwbazie(String.valueOf(rok), wpisView.getMiesiacWpisu(), podatnik);
}
}
private void init2() {
try {
pobierzdeklaracje27();
Deklaracjavat27 d = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d != null) {
deklaracja0korekta1 = true;
}
} catch (Exception e) {
E.e(e);
}
}
public void init3() {
try {
Deklaracjavat27 d = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d != null) {
deklaracja0korekta1 = true;
} else {
deklaracja0korekta1 = false;
}
for (Deklaracjavat27 dek : deklaracjevat27) {
if (dek.getRok().equals(wpisView.getRokWpisuSt()) && dek.getMiesiac().equals(wpisView.getMiesiacWpisu())) {
deklaracja0korekta1 = true;
}
}
} catch (Exception e) {
E.e(e);
}
}
public void pobierzdeklaracje27() {
deklaracjevat27 = deklaracjavat27DAO.findbyPodatnikRok(wpisView);
if (deklaracjevat27 == null) {
deklaracjevat27 = Collections.synchronizedList(new ArrayList<>());
}
}
// try {
// pobierzdanezdeklaracji();
// } catch (Exception e) { E.e(e);
// }
private double[] pobierzwartosci(List<EVatwpisFK> lista) {
double netto = 0.0;
double nettowaluta = 0.0;
for (EVatwpisFK p : lista) {
netto += p.getNetto();
nettowaluta += p.getNettowwalucie();
}
return new double[]{Z.z(netto),Z.z(nettowaluta)};
}
private void zachowajwbazie(String rok, String symbolokresu, String klient) {
Vatuepodatnik vatuepodatnik = new Vatuepodatnik();
VatuepodatnikPK vatuepodatnikPK = new VatuepodatnikPK();
vatuepodatnikPK.setRok(rok);
vatuepodatnikPK.setSymbolokresu(symbolokresu);
vatuepodatnikPK.setKlient(klient);
vatuepodatnik.setVatuepodatnikPK(vatuepodatnikPK);
vatuepodatnik.setKlienciwdtwnt(klienciWDTWNT);
vatuepodatnik.setMc0kw1(Boolean.TRUE);
vatuepodatnik.setRozliczone(Boolean.FALSE);
//bo czasami nie edytowalo nie wiem dlaczego
try {
vatuepodatnikDAO.remove(vatuepodatnik);
} catch (Exception e) { E.e(e); };
try {
vatuepodatnikDAO.create(vatuepodatnik);
Msg.msg("i", "Zachowano dane do VAT-27");
} catch (Exception e) { E.e(e);
Msg.msg("e", "Błąd podczas zachowywania danych do VAT-UE");
}
}
private Set<Vat27> kontrahenciUE(List<Dokfk> listadokumentow) {
Set<Vat27> klienty = new HashSet<>();
for (Dokfk p : listadokumentow) {
if (warunekkontrahenci(p)) {
//wyszukujemy dokumenty WNT i WDT dodajemu do sumy
Vat27 veu = new Vat27(p.getRodzajedok().getSkrot(), p.getKontr(), 0.0, 0);
veu.setZawierafk(new ArrayList<>());
klienty.add(veu);
}
}
return klienty;
}
private boolean warunekkontrahenci(Dokfk p) {
boolean zwrot = false;
zwrot = p.getRodzajedok().getRodzajtransakcji().equals("odwrotne obciążenie sprzedawca");
return zwrot;
}
public void podsumuj() {
sumawybranych = 0.0;
for (Vat27 p : listawybranych) {
sumawybranych += p.getNetto();
}
}
public void drukujewidencjeUEfk() {
try {
if (listawybranych != null && !listawybranych.isEmpty()) {
PdfVatUE.drukujewidencje(listawybranych, wpisView,"VAT-27");
} else {
PdfVatUE.drukujewidencje(klienciWDTWNT, wpisView,"VAT-27");
}
} catch (Exception e) { E.e(e);
}
}
public void drukujewidencjeUEfkTabela() {
try {
if (listawybranych != null && !listawybranych.isEmpty()) {
PdfVat27.drukujewidencjeTabela(listawybranych, wpisView,"VAT-27");
} else {
PdfVat27.drukujewidencjeTabela(klienciWDTWNT, wpisView,"VAT-27");
}
} catch (Exception e) { E.e(e);
}
}
public void usundekl(Deklaracjavat27 d) {
try {
deklaracjavat27DAO.remove(d);
deklaracjevat27.remove(d);
for (Vat27 p : d.getPozycje()) {
if (!p.getZawierafk().isEmpty()) {
for (Dokfk dok:p.getZawierafk()) {
dok.setVat27(null);
}
dokDAOfk.editList(p.getZawierafk());
}
}
try {
pobierzdeklaracje27();
Deklaracjavat27 d2 = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d2 != null) {
deklaracja0korekta1 = true;
} else {
deklaracja0korekta1 = false;
}
} catch (Exception e) {
E.e(e);
}
Msg.dP();
} catch (Exception e) {
Msg.dPe();
}
}
public void drukuj(Deklaracjavat27 d) {
try {
if (d == null) {
Msg.msg("e", "Nie wybrano deklaracji");
} else {
PdfVAT27dekl.drukujVAT(podatnikDAO, d, wpisView);
Msg.msg("Wydrukowano deklaracje");
}
} catch (Exception e) {
Msg.msg("e", "Wystąpił błąd, nie wydrukowano ewidencji");
}
}
//<editor-fold defaultstate="collapsed" desc="comment">
public WpisView getWpisView() {
return wpisView;
}
public void setWpisView(WpisView wpisView) {
this.wpisView = wpisView;
}
public List<Dokfk> getListaDokfk() {
return listaDokfk;
}
public void setListaDokfk(List<Dokfk> listaDokfk) {
this.listaDokfk = listaDokfk;
}
public String getOpisvatuepkpir() {
return opisvatuepkpir;
}
public void setOpisvatuepkpir(String opisvatuepkpir) {
this.opisvatuepkpir = opisvatuepkpir;
}
public List<Vat27> getKlienciWDTWNT() {
return klienciWDTWNT;
}
public void setKlienciWDTWNT(List<Vat27> klienciWDTWNT) {
this.klienciWDTWNT = klienciWDTWNT;
}
public List<Vat27> getListawybranych() {
return listawybranych;
}
public void setListawybranych(List<Vat27> listawybranych) {
this.listawybranych = listawybranych;
}
public boolean isDeklaracja0korekta1() {
return deklaracja0korekta1;
}
public void setDeklaracja0korekta1(boolean deklaracja0korekta1) {
this.deklaracja0korekta1 = deklaracja0korekta1;
}
public List<Deklaracjavat27> getDeklaracjevat27() {
return deklaracjevat27;
}
public void setDeklaracjevat27(List<Deklaracjavat27> deklaracjevat27) {
this.deklaracjevat27 = deklaracjevat27;
}
public Deklaracjavat27 getDekl27selected() {
return dekl27selected;
}
public void setDekl27selected(Deklaracjavat27 dekl27selected) {
this.dekl27selected = dekl27selected;
}
public double getSumawybranych() {
return sumawybranych;
}
public void setSumawybranych(double sumawybranych) {
this.sumawybranych = sumawybranych;
}
//</editor-fold>
}
| //jest miesiecznie wiec nie ma co wybierac
| /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package view;
import comparator.Dokfkcomparator;
import dao.Deklaracjavat27DAO;
import dao.PodatnikDAO;
import dao.DokDAOfk;
import dao.VatuepodatnikDAO;
import entity.Deklaracjavat27;
import entity.Vat27;
import entityfk.Dokfk;
import entityfk.EVatwpisFK;
import entityfk.Vatuepodatnik;
import entityfk.VatuepodatnikPK;
import error.E;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.PostConstruct;
import javax.inject.Named;
import javax.faces.view.ViewScoped;
import javax.inject.Inject;
import msg.Msg;import pdf.PdfVAT27dekl;
import pdf.PdfVat27;
import pdf.PdfVatUE;
import waluty.Z;
/**
*
* @author Osito
*/
@Named
@ViewScoped
public class Vat27FKView implements Serializable {
//lista gdzie beda podsumowane wartosci
private List<Vat27> klienciWDTWNT;
private List<Vat27> listawybranych;
private List<Dokfk> listaDokfk;
@Inject
private WpisView wpisView;
@Inject
private DokDAOfk dokDAOfk;
@Inject
private VatuepodatnikDAO vatuepodatnikDAO;
private double sumawybranych;
private String opisvatuepkpir;
private boolean deklaracja0korekta1;
private List<Deklaracjavat27> deklaracjevat27;
@Inject
private Deklaracjavat27DAO deklaracjavat27DAO;
@Inject
private Deklaracjavat27 dekl27selected;
@Inject
private PodatnikDAO podatnikDAO;
public Vat27FKView() {
klienciWDTWNT = Collections.synchronizedList(new ArrayList<>());
listaDokfk = Collections.synchronizedList(new ArrayList<>());
}
@PostConstruct
public void init() { //E.m(this);
List<Dokfk> listadokumentow = Collections.synchronizedList(new ArrayList<>());
//List<Dokfk> dokvatmc = Collections.synchronizedList(new ArrayList<>());
Integer rok = wpisView.getRokWpisu();
String mc = wpisView.getMiesiacWpisu();
String podatnik = wpisView.getPodatnikWpisu();
try {
listadokumentow = dokDAOfk.findDokfkPodatnikRokMc(wpisView);
} catch (Exception e) {
E.e(e);
}
opisvatuepkpir = wpisView.getPodatnikWpisu()+" Zestawienie dokumentów do deklaracji VAT-27 na koniec "+ rok+"/"+mc+" rozliczenie miesięczne";
//jest miesiecznie <SUF>
if (listadokumentow != null) {
Collections.sort(listadokumentow, new Dokfkcomparator());
//a teraz podsumuj klientów
klienciWDTWNT.addAll(kontrahenciUE(listadokumentow));
double sumanettovatue = 0.0;
double sumanettovatuewaluta = 0.0;
for (Dokfk p : listadokumentow) {
for (Vat27 s : klienciWDTWNT) {
if (p.getKontr().getNip().equals(s.getKontrahent().getNip()) && p.getRodzajedok().getSkrot().equals(s.getTransakcja())) {
double[] t = pobierzwartosci(p.getEwidencjaVAT());
double netto = t[0];
double nettowaluta = t[1];
s.setNetto(netto + s.getNetto());
s.setNettowaluta(nettowaluta + s.getNettowaluta());
s.setLiczbadok(s.getLiczbadok() + 1);
s.getZawierafk().add(p);
s.setNazwawaluty(p.getWalutadokumentu());
p.setVat27(s);
listaDokfk.add(p);
sumanettovatue += netto;
sumanettovatuewaluta += nettowaluta;
break;
}
}
}
Vat27 rzadpodsumowanie = new Vat27("podsum.", null, Z.z(sumanettovatue), Z.z(sumanettovatuewaluta));
klienciWDTWNT.add(rzadpodsumowanie);
try {
pobierzdeklaracje27();
Deklaracjavat27 d = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d != null) {
deklaracja0korekta1 = true;
} else {
deklaracja0korekta1 = false;
}
} catch (Exception e) {
E.e(e);
}
//zachowajwbazie(String.valueOf(rok), wpisView.getMiesiacWpisu(), podatnik);
}
}
private void init2() {
try {
pobierzdeklaracje27();
Deklaracjavat27 d = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d != null) {
deklaracja0korekta1 = true;
}
} catch (Exception e) {
E.e(e);
}
}
public void init3() {
try {
Deklaracjavat27 d = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d != null) {
deklaracja0korekta1 = true;
} else {
deklaracja0korekta1 = false;
}
for (Deklaracjavat27 dek : deklaracjevat27) {
if (dek.getRok().equals(wpisView.getRokWpisuSt()) && dek.getMiesiac().equals(wpisView.getMiesiacWpisu())) {
deklaracja0korekta1 = true;
}
}
} catch (Exception e) {
E.e(e);
}
}
public void pobierzdeklaracje27() {
deklaracjevat27 = deklaracjavat27DAO.findbyPodatnikRok(wpisView);
if (deklaracjevat27 == null) {
deklaracjevat27 = Collections.synchronizedList(new ArrayList<>());
}
}
// try {
// pobierzdanezdeklaracji();
// } catch (Exception e) { E.e(e);
// }
private double[] pobierzwartosci(List<EVatwpisFK> lista) {
double netto = 0.0;
double nettowaluta = 0.0;
for (EVatwpisFK p : lista) {
netto += p.getNetto();
nettowaluta += p.getNettowwalucie();
}
return new double[]{Z.z(netto),Z.z(nettowaluta)};
}
private void zachowajwbazie(String rok, String symbolokresu, String klient) {
Vatuepodatnik vatuepodatnik = new Vatuepodatnik();
VatuepodatnikPK vatuepodatnikPK = new VatuepodatnikPK();
vatuepodatnikPK.setRok(rok);
vatuepodatnikPK.setSymbolokresu(symbolokresu);
vatuepodatnikPK.setKlient(klient);
vatuepodatnik.setVatuepodatnikPK(vatuepodatnikPK);
vatuepodatnik.setKlienciwdtwnt(klienciWDTWNT);
vatuepodatnik.setMc0kw1(Boolean.TRUE);
vatuepodatnik.setRozliczone(Boolean.FALSE);
//bo czasami nie edytowalo nie wiem dlaczego
try {
vatuepodatnikDAO.remove(vatuepodatnik);
} catch (Exception e) { E.e(e); };
try {
vatuepodatnikDAO.create(vatuepodatnik);
Msg.msg("i", "Zachowano dane do VAT-27");
} catch (Exception e) { E.e(e);
Msg.msg("e", "Błąd podczas zachowywania danych do VAT-UE");
}
}
private Set<Vat27> kontrahenciUE(List<Dokfk> listadokumentow) {
Set<Vat27> klienty = new HashSet<>();
for (Dokfk p : listadokumentow) {
if (warunekkontrahenci(p)) {
//wyszukujemy dokumenty WNT i WDT dodajemu do sumy
Vat27 veu = new Vat27(p.getRodzajedok().getSkrot(), p.getKontr(), 0.0, 0);
veu.setZawierafk(new ArrayList<>());
klienty.add(veu);
}
}
return klienty;
}
private boolean warunekkontrahenci(Dokfk p) {
boolean zwrot = false;
zwrot = p.getRodzajedok().getRodzajtransakcji().equals("odwrotne obciążenie sprzedawca");
return zwrot;
}
public void podsumuj() {
sumawybranych = 0.0;
for (Vat27 p : listawybranych) {
sumawybranych += p.getNetto();
}
}
public void drukujewidencjeUEfk() {
try {
if (listawybranych != null && !listawybranych.isEmpty()) {
PdfVatUE.drukujewidencje(listawybranych, wpisView,"VAT-27");
} else {
PdfVatUE.drukujewidencje(klienciWDTWNT, wpisView,"VAT-27");
}
} catch (Exception e) { E.e(e);
}
}
public void drukujewidencjeUEfkTabela() {
try {
if (listawybranych != null && !listawybranych.isEmpty()) {
PdfVat27.drukujewidencjeTabela(listawybranych, wpisView,"VAT-27");
} else {
PdfVat27.drukujewidencjeTabela(klienciWDTWNT, wpisView,"VAT-27");
}
} catch (Exception e) { E.e(e);
}
}
public void usundekl(Deklaracjavat27 d) {
try {
deklaracjavat27DAO.remove(d);
deklaracjevat27.remove(d);
for (Vat27 p : d.getPozycje()) {
if (!p.getZawierafk().isEmpty()) {
for (Dokfk dok:p.getZawierafk()) {
dok.setVat27(null);
}
dokDAOfk.editList(p.getZawierafk());
}
}
try {
pobierzdeklaracje27();
Deklaracjavat27 d2 = deklaracjavat27DAO.findbyPodatnikRokMc(wpisView);
if (d2 != null) {
deklaracja0korekta1 = true;
} else {
deklaracja0korekta1 = false;
}
} catch (Exception e) {
E.e(e);
}
Msg.dP();
} catch (Exception e) {
Msg.dPe();
}
}
public void drukuj(Deklaracjavat27 d) {
try {
if (d == null) {
Msg.msg("e", "Nie wybrano deklaracji");
} else {
PdfVAT27dekl.drukujVAT(podatnikDAO, d, wpisView);
Msg.msg("Wydrukowano deklaracje");
}
} catch (Exception e) {
Msg.msg("e", "Wystąpił błąd, nie wydrukowano ewidencji");
}
}
//<editor-fold defaultstate="collapsed" desc="comment">
public WpisView getWpisView() {
return wpisView;
}
public void setWpisView(WpisView wpisView) {
this.wpisView = wpisView;
}
public List<Dokfk> getListaDokfk() {
return listaDokfk;
}
public void setListaDokfk(List<Dokfk> listaDokfk) {
this.listaDokfk = listaDokfk;
}
public String getOpisvatuepkpir() {
return opisvatuepkpir;
}
public void setOpisvatuepkpir(String opisvatuepkpir) {
this.opisvatuepkpir = opisvatuepkpir;
}
public List<Vat27> getKlienciWDTWNT() {
return klienciWDTWNT;
}
public void setKlienciWDTWNT(List<Vat27> klienciWDTWNT) {
this.klienciWDTWNT = klienciWDTWNT;
}
public List<Vat27> getListawybranych() {
return listawybranych;
}
public void setListawybranych(List<Vat27> listawybranych) {
this.listawybranych = listawybranych;
}
public boolean isDeklaracja0korekta1() {
return deklaracja0korekta1;
}
public void setDeklaracja0korekta1(boolean deklaracja0korekta1) {
this.deklaracja0korekta1 = deklaracja0korekta1;
}
public List<Deklaracjavat27> getDeklaracjevat27() {
return deklaracjevat27;
}
public void setDeklaracjevat27(List<Deklaracjavat27> deklaracjevat27) {
this.deklaracjevat27 = deklaracjevat27;
}
public Deklaracjavat27 getDekl27selected() {
return dekl27selected;
}
public void setDekl27selected(Deklaracjavat27 dekl27selected) {
this.dekl27selected = dekl27selected;
}
public double getSumawybranych() {
return sumawybranych;
}
public void setSumawybranych(double sumawybranych) {
this.sumawybranych = sumawybranych;
}
//</editor-fold>
}
| f | null |
383 | 10299_124 | brzozasr/exchange-rates-nbp | 3,667 | src/main/java/enumtypes/CurrencyCodeTableB.java | package enumtypes;
/**
* Trzyliterowy kod waluty (standard ISO 4217) dla tabeli typu B
*/
public enum CurrencyCodeTableB {
/**
* dirham ZEA (Zjednoczone Emiraty Arabskie)
*/
AED,
/**
* afgani (Afganistan), waluta archiwalna zastąpiona przez New Afghani (AFN)
*/
AFA,
/**
* afgani (Afganistan)
*/
AFN,
/**
* lek (Albania)
*/
ALL,
/**
* dram (Armenia)
*/
AMD,
/**
* gulden Antyli Holenderskich
*/
ANG,
/**
* kwanza (Angola)
*/
AOA,
/**
* kwanza (Angola)
*/
AON,
/**
* peso argentyńskie
*/
ARS,
/**
* florin arubański
*/
AWG,
/**
* manat azerbejdżański
*/
AZN,
/**
* wymienialna marka (Bośnia i Hercegowina)
*/
BAM,
/**
* dolar barbadoski
*/
BBD,
/**
* taka (Bangladesz)
*/
BDT,
/**
* lew (Bułgaria)
*/
BGN,
/**
* dinar bahrajski
*/
BHD,
/**
* frank burundyjski
*/
BIF,
/**
* dolar brunejski
*/
BND,
/**
* boliwiano (Boliwia)
*/
BOB,
/**
* real (Brazylia)
*/
BRL,
/**
* dolar bahamski
*/
BSD,
/**
* pula (Botswana)
*/
BWP,
/**
* rubel białoruski
*/
BYN,
/**
* rubel (Białoruś)
*/
BYR,
/**
* dolar belizeński
*/
BZD,
/**
* frank kongijski (Dem. Republika Konga)
*/
CDF,
/**
* peso (Chile)
*/
CLP,
/**
* yuan renminbi (Chiny)
*/
CNY,
/**
* peso kolumbijskie
*/
COP,
/**
* colon kostarykański
*/
CRC,
/**
* peso kubańskie
*/
CUP,
/**
* escudo Zielonego Przylądka
*/
CVE,
/**
* funt cypryjski
*/
CYP,
/**
* frank Dżibuti
*/
DJF,
/**
* peso dominikańskie
*/
DOP,
/**
* dinar algierski
*/
DZD,
/**
* funt egipski
*/
EGP,
/**
* nakfa (Erytrea)
*/
ERN,
/**
* birr etiopski
*/
ETB,
/**
* dolar Fidżi
*/
FJD,
/**
* lari (Gruzja)
*/
GEL,
/**
* cedi ghańskie (Ghana)
*/
GHC,
/**
* Ghana cedi
*/
GHS,
/**
* funt gibraltarski
*/
GIP,
/**
* dalasi (Gambia)
*/
GMD,
/**
* frank gwinejski
*/
GNF,
/**
* quetzal (Gwatemala)
*/
GTQ,
/**
* dolar gujański
*/
GYD,
/**
* dolar Hongkongu
*/
HKD,
/**
* lempira (Honduras)
*/
HNL,
/**
* kuna (Chorwacja)
*/
HRK,
/**
* gourde (Haiti)
*/
HTG,
/**
* rupia indonezyjska
*/
IDR,
/**
* nowy izraelski szekel
*/
ILS,
/**
* rupia indyjska
*/
INR,
/**
* dinar iracki
*/
IQD,
/**
* rial irański
*/
IRR,
/**
* korona islandzka
*/
ISK,
/**
* dolar jamajski
*/
JMD,
/**
* dinar jordański
*/
JOD,
/**
* szyling kenijski
*/
KES,
/**
* som (Kirgistan)
*/
KGS,
/**
* riel (Kambodża)
*/
KHR,
/**
* frank Komorów
*/
KMF,
/**
* won południowokoreański
*/
KRW,
/**
* dinar kuwejcki
*/
KWD,
/**
* tenge (Kazachstan)
*/
KZT,
/**
* kip (Laos)
*/
LAK,
/**
* funt libański
*/
LBP,
/**
* rupia lankijska
*/
LKR,
/**
* dolar liberyjski
*/
LRD,
/**
* loti (Lesotho)
*/
LSL,
/**
* korona estońska (waluta archiwalna)
*/
LTL,
/**
* łat łotewski (waluta archiwalna)
*/
LVL,
/**
* dinar libijski
*/
LYD,
/**
* dirham marokański
*/
MAD,
/**
* lej Mołdawii
*/
MDL,
/**
* ariary (Madagaskar)
*/
MGA,
/**
* ariary malgaski (Madagaskar)
*/
MGF,
/**
* denar (Macedonia)
*/
MKD,
/**
* kyat (Myanmar, Birma)
*/
MMK,
/**
* tugrik (Mongolia)
*/
MNT,
/**
* pataca (Makau)
*/
MOP,
/**
* ugija mauretańska
*/
MRO,
/**
* ouguiya (Mauretania)
*/
MRU,
/**
* lira maltańska, funt maltański (waluta archiwalna)
*/
MTL,
/**
* rupia Mauritiusu
*/
MUR,
/**
* rupia (Malediwy)
*/
MVR,
/**
* kwacha malawijska
*/
MWK,
/**
* peso meksykańskie
*/
MXN,
/**
* ringgit (Malezja)
*/
MYR,
/**
* metical mozambicki
*/
MZM,
/**
* metical (Mozambik)
*/
MZN,
/**
* dolar namibijski
*/
NAD,
/**
* naira (Nigeria)
*/
NGN,
/**
* cordoba oro (Nikaragua)
*/
NIO,
/**
* rupia nepalska
*/
NPR,
/**
* dolar nowozelandzki
*/
NZD,
/**
* rial omański
*/
OMR,
/**
* balboa (Panama)
*/
PAB,
/**
* sol (Peru)
*/
PEN,
/**
* kina (Papua-Nowa Gwinea)
*/
PGK,
/**
* peso filipińskie
*/
PHP,
/**
* rupia pakistańska
*/
PKR,
/**
* guarani (Paragwaj)
*/
PYG,
/**
* rial katarski
*/
QAR,
/**
* lej rumuński (przed denominacją 1 lipca 2005)
*/
ROL,
/**
* dinar serbski
*/
RSD,
/**
* rubel rosyjski
*/
RUB,
/**
* frank rwandyjski
*/
RWF,
/**
* rial saudyjsk
*/
SAR,
/**
* dolar Wysp Salomona
*/
SBD,
/**
* rupia seszelska
*/
SCR,
/**
* dinar sudański (zastąpiony przez funta sudańskiego SDG) w dniu 1 lipca 2007 roku
*/
SDD,
/**
* funt sudański
*/
SDG,
/**
* dolar singapurski
*/
SGD,
/**
* tolara słoweński (waluta archiwalna)
*/
SIT,
/**
* korona słowacka (waluta archiwalna)
*/
SKK,
/**
* leone (Sierra Leone)
*/
SLL,
/**
* szyling somalijski
*/
SOS,
/**
* dolar surinamski
*/
SRD,
/**
* gulden surinamski (Surinamu) do 1 stycznia 2004
*/
SRG,
/**
* funt południowosudański
*/
SSP,
/**
* dobra (Wyspa Świętego Tomasza i Książęcej)
*/
STD,
/**
* dobra (Wyspy Świętego Tomasza i Książęca)
*/
STN,
/**
* colon kostarykański
*/
SVC,
/**
* funt syryjski
*/
SYP,
/**
* lilangeni (Eswatini)
*/
SZL,
/**
* bat (Tajlandia)
*/
THB,
/**
* somoni (Tadżykistan)
*/
TJS,
/**
* nowy manat (Turkmenistan)
*/
TMT,
/**
* dinar tunezyjski
*/
TND,
/**
* pa'anga (Tonga)
*/
TOP,
/**
* lira turecka od 1 stycznia 2005 do 31 grudnia 2008 była zastąpiona przez nową lirę TRY
*/
TRL,
/**
* dolar Trynidadu i Tobago
*/
TTD,
/**
* nowy dolar tajwański
*/
TWD,
/**
* szyling tanzański
*/
TZS,
/**
* hrywna (Ukraina)
*/
UAH,
/**
* szyling ugandyjski
*/
UGX,
/**
* dolar amerykański
*/
USD,
/**
* peso urugwajskie
*/
UYU,
/**
* sum (Uzbekistan)
*/
UZS,
/**
* boliwar wenezuelski
*/
VEB,
/**
* boliwar soberano (Wenezuela)
*/
VES,
/**
* dong (Wietnam)
*/
VND,
/**
* vatu (Vanuatu)
*/
VUV,
/**
* tala (Samoa)
*/
WST,
/**
* frank CFA BEAC (Bank Państw Afryki Środkowej)
*/
XAF,
/**
* dolar wschodniokaraibski
*/
XCD,
/**
* frank CFA BCEAO (Centralny Bank Państw Afryki Zachodniej)
*/
XOF,
/**
* frank CFP (waluta używana w Polinezji Francuskiej, Nowej Kaledonii oraz Wallis i Futunie)
*/
XPF,
/**
* rial jemeński
*/
YER,
/**
* dinar jugosłowiański
*/
YUM,
/**
* rand (Republika Południowej Afryki)
*/
ZAR,
/**
* kwacha zambijska
*/
ZMK,
/**
* kwacha zambijska
*/
ZMW,
/**
* dolar zimbabwe
*/
ZWD,
/**
* dolar Zimbabwe
*/
ZWL
}
| /**
* dobra (Wyspa Świętego Tomasza i Książęcej)
*/ | package enumtypes;
/**
* Trzyliterowy kod waluty (standard ISO 4217) dla tabeli typu B
*/
public enum CurrencyCodeTableB {
/**
* dirham ZEA (Zjednoczone Emiraty Arabskie)
*/
AED,
/**
* afgani (Afganistan), waluta archiwalna zastąpiona przez New Afghani (AFN)
*/
AFA,
/**
* afgani (Afganistan)
*/
AFN,
/**
* lek (Albania)
*/
ALL,
/**
* dram (Armenia)
*/
AMD,
/**
* gulden Antyli Holenderskich
*/
ANG,
/**
* kwanza (Angola)
*/
AOA,
/**
* kwanza (Angola)
*/
AON,
/**
* peso argentyńskie
*/
ARS,
/**
* florin arubański
*/
AWG,
/**
* manat azerbejdżański
*/
AZN,
/**
* wymienialna marka (Bośnia i Hercegowina)
*/
BAM,
/**
* dolar barbadoski
*/
BBD,
/**
* taka (Bangladesz)
*/
BDT,
/**
* lew (Bułgaria)
*/
BGN,
/**
* dinar bahrajski
*/
BHD,
/**
* frank burundyjski
*/
BIF,
/**
* dolar brunejski
*/
BND,
/**
* boliwiano (Boliwia)
*/
BOB,
/**
* real (Brazylia)
*/
BRL,
/**
* dolar bahamski
*/
BSD,
/**
* pula (Botswana)
*/
BWP,
/**
* rubel białoruski
*/
BYN,
/**
* rubel (Białoruś)
*/
BYR,
/**
* dolar belizeński
*/
BZD,
/**
* frank kongijski (Dem. Republika Konga)
*/
CDF,
/**
* peso (Chile)
*/
CLP,
/**
* yuan renminbi (Chiny)
*/
CNY,
/**
* peso kolumbijskie
*/
COP,
/**
* colon kostarykański
*/
CRC,
/**
* peso kubańskie
*/
CUP,
/**
* escudo Zielonego Przylądka
*/
CVE,
/**
* funt cypryjski
*/
CYP,
/**
* frank Dżibuti
*/
DJF,
/**
* peso dominikańskie
*/
DOP,
/**
* dinar algierski
*/
DZD,
/**
* funt egipski
*/
EGP,
/**
* nakfa (Erytrea)
*/
ERN,
/**
* birr etiopski
*/
ETB,
/**
* dolar Fidżi
*/
FJD,
/**
* lari (Gruzja)
*/
GEL,
/**
* cedi ghańskie (Ghana)
*/
GHC,
/**
* Ghana cedi
*/
GHS,
/**
* funt gibraltarski
*/
GIP,
/**
* dalasi (Gambia)
*/
GMD,
/**
* frank gwinejski
*/
GNF,
/**
* quetzal (Gwatemala)
*/
GTQ,
/**
* dolar gujański
*/
GYD,
/**
* dolar Hongkongu
*/
HKD,
/**
* lempira (Honduras)
*/
HNL,
/**
* kuna (Chorwacja)
*/
HRK,
/**
* gourde (Haiti)
*/
HTG,
/**
* rupia indonezyjska
*/
IDR,
/**
* nowy izraelski szekel
*/
ILS,
/**
* rupia indyjska
*/
INR,
/**
* dinar iracki
*/
IQD,
/**
* rial irański
*/
IRR,
/**
* korona islandzka
*/
ISK,
/**
* dolar jamajski
*/
JMD,
/**
* dinar jordański
*/
JOD,
/**
* szyling kenijski
*/
KES,
/**
* som (Kirgistan)
*/
KGS,
/**
* riel (Kambodża)
*/
KHR,
/**
* frank Komorów
*/
KMF,
/**
* won południowokoreański
*/
KRW,
/**
* dinar kuwejcki
*/
KWD,
/**
* tenge (Kazachstan)
*/
KZT,
/**
* kip (Laos)
*/
LAK,
/**
* funt libański
*/
LBP,
/**
* rupia lankijska
*/
LKR,
/**
* dolar liberyjski
*/
LRD,
/**
* loti (Lesotho)
*/
LSL,
/**
* korona estońska (waluta archiwalna)
*/
LTL,
/**
* łat łotewski (waluta archiwalna)
*/
LVL,
/**
* dinar libijski
*/
LYD,
/**
* dirham marokański
*/
MAD,
/**
* lej Mołdawii
*/
MDL,
/**
* ariary (Madagaskar)
*/
MGA,
/**
* ariary malgaski (Madagaskar)
*/
MGF,
/**
* denar (Macedonia)
*/
MKD,
/**
* kyat (Myanmar, Birma)
*/
MMK,
/**
* tugrik (Mongolia)
*/
MNT,
/**
* pataca (Makau)
*/
MOP,
/**
* ugija mauretańska
*/
MRO,
/**
* ouguiya (Mauretania)
*/
MRU,
/**
* lira maltańska, funt maltański (waluta archiwalna)
*/
MTL,
/**
* rupia Mauritiusu
*/
MUR,
/**
* rupia (Malediwy)
*/
MVR,
/**
* kwacha malawijska
*/
MWK,
/**
* peso meksykańskie
*/
MXN,
/**
* ringgit (Malezja)
*/
MYR,
/**
* metical mozambicki
*/
MZM,
/**
* metical (Mozambik)
*/
MZN,
/**
* dolar namibijski
*/
NAD,
/**
* naira (Nigeria)
*/
NGN,
/**
* cordoba oro (Nikaragua)
*/
NIO,
/**
* rupia nepalska
*/
NPR,
/**
* dolar nowozelandzki
*/
NZD,
/**
* rial omański
*/
OMR,
/**
* balboa (Panama)
*/
PAB,
/**
* sol (Peru)
*/
PEN,
/**
* kina (Papua-Nowa Gwinea)
*/
PGK,
/**
* peso filipińskie
*/
PHP,
/**
* rupia pakistańska
*/
PKR,
/**
* guarani (Paragwaj)
*/
PYG,
/**
* rial katarski
*/
QAR,
/**
* lej rumuński (przed denominacją 1 lipca 2005)
*/
ROL,
/**
* dinar serbski
*/
RSD,
/**
* rubel rosyjski
*/
RUB,
/**
* frank rwandyjski
*/
RWF,
/**
* rial saudyjsk
*/
SAR,
/**
* dolar Wysp Salomona
*/
SBD,
/**
* rupia seszelska
*/
SCR,
/**
* dinar sudański (zastąpiony przez funta sudańskiego SDG) w dniu 1 lipca 2007 roku
*/
SDD,
/**
* funt sudański
*/
SDG,
/**
* dolar singapurski
*/
SGD,
/**
* tolara słoweński (waluta archiwalna)
*/
SIT,
/**
* korona słowacka (waluta archiwalna)
*/
SKK,
/**
* leone (Sierra Leone)
*/
SLL,
/**
* szyling somalijski
*/
SOS,
/**
* dolar surinamski
*/
SRD,
/**
* gulden surinamski (Surinamu) do 1 stycznia 2004
*/
SRG,
/**
* funt południowosudański
*/
SSP,
/**
* dobra (Wyspa Świętego <SUF>*/
STD,
/**
* dobra (Wyspy Świętego Tomasza i Książęca)
*/
STN,
/**
* colon kostarykański
*/
SVC,
/**
* funt syryjski
*/
SYP,
/**
* lilangeni (Eswatini)
*/
SZL,
/**
* bat (Tajlandia)
*/
THB,
/**
* somoni (Tadżykistan)
*/
TJS,
/**
* nowy manat (Turkmenistan)
*/
TMT,
/**
* dinar tunezyjski
*/
TND,
/**
* pa'anga (Tonga)
*/
TOP,
/**
* lira turecka od 1 stycznia 2005 do 31 grudnia 2008 była zastąpiona przez nową lirę TRY
*/
TRL,
/**
* dolar Trynidadu i Tobago
*/
TTD,
/**
* nowy dolar tajwański
*/
TWD,
/**
* szyling tanzański
*/
TZS,
/**
* hrywna (Ukraina)
*/
UAH,
/**
* szyling ugandyjski
*/
UGX,
/**
* dolar amerykański
*/
USD,
/**
* peso urugwajskie
*/
UYU,
/**
* sum (Uzbekistan)
*/
UZS,
/**
* boliwar wenezuelski
*/
VEB,
/**
* boliwar soberano (Wenezuela)
*/
VES,
/**
* dong (Wietnam)
*/
VND,
/**
* vatu (Vanuatu)
*/
VUV,
/**
* tala (Samoa)
*/
WST,
/**
* frank CFA BEAC (Bank Państw Afryki Środkowej)
*/
XAF,
/**
* dolar wschodniokaraibski
*/
XCD,
/**
* frank CFA BCEAO (Centralny Bank Państw Afryki Zachodniej)
*/
XOF,
/**
* frank CFP (waluta używana w Polinezji Francuskiej, Nowej Kaledonii oraz Wallis i Futunie)
*/
XPF,
/**
* rial jemeński
*/
YER,
/**
* dinar jugosłowiański
*/
YUM,
/**
* rand (Republika Południowej Afryki)
*/
ZAR,
/**
* kwacha zambijska
*/
ZMK,
/**
* kwacha zambijska
*/
ZMW,
/**
* dolar zimbabwe
*/
ZWD,
/**
* dolar Zimbabwe
*/
ZWL
}
| f | null |
384 | 7045_3 | bykowskiolaf/uz.java | 1,090 | Lab5/src/Samochod.java | //1. Stwórz klasę o nazwie Samochod reprezentującą dane pojazdu zawierającą następujące pola:
//marka,
//model,
//pojemność silnika,
//typ nadwozia,
//typ silnika,
//rok produkcji,
//data 1 rejestracji,
//cena.
//
//Klasa powinna zawierać osobne metody służące do ustawiania i zwracania wartości
//poszczególnych pól obiektów.
//Napisz metodę, która sprawdzi, czy samochód posiada jeszcze gwarancję (wiek
//pojazdu do 2 lat licząc od daty rejestracji) i zwróci informację w formie komunikatu
//tekstowego.
import lombok.ToString;
import java.time.LocalDate;
@ToString
public class Samochod {
String brand;
String model;
double engineSize;
static Samochod.bodyType bodyType;
static Samochod.engineType engineType;
int yearOfProduction;
LocalDate firstRegisteredDate;
double price;
public Samochod() {
this.brand = "";
this.model = "";
this.engineSize = 0;
this.bodyType = bodyType.SEDAN;
this.engineType = engineType.GAS;
this.yearOfProduction = 0;
this.firstRegisteredDate = LocalDate.now();
this.price = 0;
}
public Samochod(String brand, String model, double engineSize, Samochod.bodyType bodyType, Samochod.engineType engineType, int yearOfProduction, LocalDate firstRegisteredDate, double price) {
this.brand = brand;
this.model = model;
this.engineSize = engineSize;
this.bodyType = bodyType;
this.engineType = engineType;
this.yearOfProduction = yearOfProduction;
this.firstRegisteredDate = firstRegisteredDate;
this.price = price;
}
public enum bodyType {
SEDAN, KOMBI, HATCHBACK, CABRIO, SUV, PICKUP, VAN
}
public enum engineType {
GAS, DIESEL, ELECTRIC, HYBRID
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public double getEngineSize() {
return engineSize;
}
public void setEngineSize(double engineSize) {
this.engineSize = engineSize;
}
public Samochod.bodyType getTypNadwozia() {
return bodyType;
}
public void setTypNadwozia(Samochod.bodyType typNadwozia) {
this.bodyType = typNadwozia;
}
public Samochod.engineType getTypSilnika() {
return engineType;
}
public void setTypSilnika(Samochod.engineType typSilnika) {
this.engineType = typSilnika;
}
public int getYearOfProduction() {
return yearOfProduction;
}
public void setYearOfProduction(int yearOfProduction) {
this.yearOfProduction = yearOfProduction;
}
public LocalDate getFirstRegisteredDate() {
return firstRegisteredDate;
}
public void setFirstRegisteredDate(LocalDate firstRegisteredDate) {
this.firstRegisteredDate = firstRegisteredDate;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public boolean checkIfStillHasWarranty() {
LocalDate today = LocalDate.now();
LocalDate warrantyEnd = this.firstRegisteredDate.plusYears(2);
return today.isBefore(warrantyEnd);
}
}
| //poszczególnych pól obiektów. | //1. Stwórz klasę o nazwie Samochod reprezentującą dane pojazdu zawierającą następujące pola:
//marka,
//model,
//pojemność silnika,
//typ nadwozia,
//typ silnika,
//rok produkcji,
//data 1 rejestracji,
//cena.
//
//Klasa powinna zawierać osobne metody służące do ustawiania i zwracania wartości
//poszczególnych pól <SUF>
//Napisz metodę, która sprawdzi, czy samochód posiada jeszcze gwarancję (wiek
//pojazdu do 2 lat licząc od daty rejestracji) i zwróci informację w formie komunikatu
//tekstowego.
import lombok.ToString;
import java.time.LocalDate;
@ToString
public class Samochod {
String brand;
String model;
double engineSize;
static Samochod.bodyType bodyType;
static Samochod.engineType engineType;
int yearOfProduction;
LocalDate firstRegisteredDate;
double price;
public Samochod() {
this.brand = "";
this.model = "";
this.engineSize = 0;
this.bodyType = bodyType.SEDAN;
this.engineType = engineType.GAS;
this.yearOfProduction = 0;
this.firstRegisteredDate = LocalDate.now();
this.price = 0;
}
public Samochod(String brand, String model, double engineSize, Samochod.bodyType bodyType, Samochod.engineType engineType, int yearOfProduction, LocalDate firstRegisteredDate, double price) {
this.brand = brand;
this.model = model;
this.engineSize = engineSize;
this.bodyType = bodyType;
this.engineType = engineType;
this.yearOfProduction = yearOfProduction;
this.firstRegisteredDate = firstRegisteredDate;
this.price = price;
}
public enum bodyType {
SEDAN, KOMBI, HATCHBACK, CABRIO, SUV, PICKUP, VAN
}
public enum engineType {
GAS, DIESEL, ELECTRIC, HYBRID
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public double getEngineSize() {
return engineSize;
}
public void setEngineSize(double engineSize) {
this.engineSize = engineSize;
}
public Samochod.bodyType getTypNadwozia() {
return bodyType;
}
public void setTypNadwozia(Samochod.bodyType typNadwozia) {
this.bodyType = typNadwozia;
}
public Samochod.engineType getTypSilnika() {
return engineType;
}
public void setTypSilnika(Samochod.engineType typSilnika) {
this.engineType = typSilnika;
}
public int getYearOfProduction() {
return yearOfProduction;
}
public void setYearOfProduction(int yearOfProduction) {
this.yearOfProduction = yearOfProduction;
}
public LocalDate getFirstRegisteredDate() {
return firstRegisteredDate;
}
public void setFirstRegisteredDate(LocalDate firstRegisteredDate) {
this.firstRegisteredDate = firstRegisteredDate;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public boolean checkIfStillHasWarranty() {
LocalDate today = LocalDate.now();
LocalDate warrantyEnd = this.firstRegisteredDate.plusYears(2);
return today.isBefore(warrantyEnd);
}
}
| f | null |
387 | 5778_0 | cerbin1/Matura-informatyka | 639 | programy/Anagramy.java | public class Anagramy {
public static void main(String... args) {
// Anagram - kiedy dwa wyrazy składaja sie z tych samych liter
String wyraz1 = "karol";
String wyraz2 = "rolka";
char[] znaki1 = wyrazNaZnaki(wyraz1);
char[] znaki2 = wyrazNaZnaki(wyraz2);
posortujBabelkowoWyraz(znaki1);
posortujBabelkowoWyraz(znaki2);
System.out.println("wyraz 1: " + new String(znaki1));
System.out.println("wyraz 2: " + new String(znaki2));
System.out.println("Czy anagram? " + czyAnagramy(znaki1, znaki2));
}
private static boolean czyAnagramy(char[] znaki1, char[] znaki2) {
if (znaki1.length != znaki2.length) {
return false;
}
for (int i = 0; i < znaki1.length; i++) {
if (znaki1[i] != znaki2[i]) {
return false;
}
}
return true;
}
private static char[] wyrazNaZnaki(String wyraz) {
char[] znaki = new char[wyraz.length()];
for (int i = 0; i < wyraz.length(); i++) {
znaki[i] = wyraz.charAt(i);
}
return znaki;
}
private static void posortujBabelkowoWyraz(char[] wyraz) {
boolean zmiana = true;
for (int i = 1; i < wyraz.length && zmiana; i++) {
zmiana = false;
for (int j = 0; j < wyraz.length - i; j++) {
if (wyraz[j] > wyraz[j + 1]) {
char temp = wyraz[j];
wyraz[j] = wyraz[j + 1];
wyraz[j + 1] = temp;
zmiana = true;
}
}
}
}
} | // Anagram - kiedy dwa wyrazy składaja sie z tych samych liter | public class Anagramy {
public static void main(String... args) {
// Anagram - <SUF>
String wyraz1 = "karol";
String wyraz2 = "rolka";
char[] znaki1 = wyrazNaZnaki(wyraz1);
char[] znaki2 = wyrazNaZnaki(wyraz2);
posortujBabelkowoWyraz(znaki1);
posortujBabelkowoWyraz(znaki2);
System.out.println("wyraz 1: " + new String(znaki1));
System.out.println("wyraz 2: " + new String(znaki2));
System.out.println("Czy anagram? " + czyAnagramy(znaki1, znaki2));
}
private static boolean czyAnagramy(char[] znaki1, char[] znaki2) {
if (znaki1.length != znaki2.length) {
return false;
}
for (int i = 0; i < znaki1.length; i++) {
if (znaki1[i] != znaki2[i]) {
return false;
}
}
return true;
}
private static char[] wyrazNaZnaki(String wyraz) {
char[] znaki = new char[wyraz.length()];
for (int i = 0; i < wyraz.length(); i++) {
znaki[i] = wyraz.charAt(i);
}
return znaki;
}
private static void posortujBabelkowoWyraz(char[] wyraz) {
boolean zmiana = true;
for (int i = 1; i < wyraz.length && zmiana; i++) {
zmiana = false;
for (int j = 0; j < wyraz.length - i; j++) {
if (wyraz[j] > wyraz[j + 1]) {
char temp = wyraz[j];
wyraz[j] = wyraz[j + 1];
wyraz[j + 1] = temp;
zmiana = true;
}
}
}
}
} | f | null |
389 | 5622_5 | cereberus/chartula | 3,916 | java/java_eclipse/PIN 2013 GRIK/src/grik/cortex.java | package grik;
import java.util.ArrayList;
import java.util.Random;
import lejos.util.Matrix;
public class cortex {
// nie możemy uzywac nic z virtual!
public static ArrayList<Integer> pin = new ArrayList<Integer>();
public static Random generator = new Random();
public static void znany_pin() {
//wedlug regulaminu!
pin.clear();
pin.add(1);
pin.add(2);
pin.add(5);
pin.add(4);
pin.add(3);
pin.add(1);
}
public static void losuj_pin() {
cortex.pin.clear();
ArrayList<Integer> cyfry=new ArrayList<Integer>();
cyfry.add(1);
cyfry.add(2);
cyfry.add(3);
cyfry.add(4);
cyfry.add(5);
for (int i=5;i>0;i--)
{
int hmm=cortex.generator.nextInt(i);
cortex.pin.add(cyfry.get(hmm));
cyfry.remove(hmm);
}
int hmm=cortex.pin.get(0);
cortex.pin.add(hmm);
}
public static Matrix pamiec = new Matrix(5, 5);
enum ruchy {
UP, DOWN, LEFT, RIGHT, STAND, BEEP, END;
}
enum orientacja {
GORA, DOL, PRAWO, LEWO
}
// liczymy od lewego dolnego, zaczynamy w prawym dolnym, a wszedzie mamy
// zera
public static pole pozycja = new pole(0, 4);
public static orientacja skierowanie = orientacja.GORA;
public static ruchy[] sztywne = new ruchy[] { ruchy.UP, ruchy.UP, ruchy.UP,
ruchy.UP, ruchy.LEFT, ruchy.LEFT, ruchy.LEFT, ruchy.LEFT,
ruchy.DOWN, ruchy.DOWN, ruchy.DOWN, ruchy.DOWN, ruchy.RIGHT,
ruchy.RIGHT, ruchy.RIGHT, ruchy.UP, ruchy.UP, ruchy.UP, ruchy.LEFT,
ruchy.LEFT, ruchy.DOWN, ruchy.DOWN, ruchy.RIGHT, ruchy.UP,
ruchy.END };
@SuppressWarnings("deprecation")
public static ArrayList<ruchy> sztywnaSekwencja = new ArrayList<ruchy>(
sztywne);
// public static void wypelnij {}
static ArrayList<pole> doZebrania = new ArrayList<pole>(); // lista pol,
// ktore trzeba
// przejechac (i
// na nich
// piknac!) //
// ruchow
static ArrayList<pole> doPrzejechania = new ArrayList<pole>();
public static ArrayList<ArrayList<pole>> numerki = new ArrayList<ArrayList<pole>>();
static ArrayList<ruchy> sekwencja = new ArrayList<ruchy>(); // zawiera
// sekwencje
// ruchow
public static ArrayList<pole> gdzieTeNumerki(double i) {
ArrayList<pole> tu = new ArrayList<pole>();
for (int w = 0; w < 5; w++) {
for (int k = 0; k < 5; k++) {
if (pamiec.get(w, k) == (int) i)
tu.add(new pole(w, k));
}
}
return tu;
}
public static void generujKandydatow() {
numerki.clear();
for (int i = 0; i < pin.size(); i++) {
numerki.add(gdzieTeNumerki(pin.get(i)));
}
}
public static ArrayList<pole> najlepszaDoZebrania() {
// potem ja trzeba jeszcze uzupelnic, minimalizujac zakrecanie
ArrayList<pole> kandydat = new ArrayList<pole>();
int prog = 1000000;
int ilu_kandydatow = 1;
for (int i = 0; i < numerki.size(); i++) {
ilu_kandydatow *= numerki.get(i).size();
}
for (int licznik = 0; licznik < ilu_kandydatow * 10; licznik++) {
ArrayList<pole> tymczasowa = new ArrayList<pole>();
for (int i = 0; i < numerki.size(); i++) {
int losowy = generator.nextInt(numerki.get(i).size());
tymczasowa.add(numerki.get(i).get(losowy));
}
tymczasowa.add(0, pozycja);
int wynik = dlugosc_trasy(tymczasowa) + ilosc_zakretow(tymczasowa);
if (wynik < prog) {
kandydat = tymczasowa;
prog = wynik;
}
}
return kandydat;
}
static ArrayList<pole> zPolaDoPola(pole a, pole b) {
ArrayList<pole> trasunia = new ArrayList<pole>();
pole tymczasowe = a;
if (a.w == b.w && a.k == b.k)
trasunia.add(a);
if (tymczasowe.w > b.w) {
while (tymczasowe.w != b.w) {
tymczasowe = new pole(tymczasowe.w - 1, tymczasowe.k);
trasunia.add(tymczasowe);
}
}
if (tymczasowe.w < b.w) {
while (tymczasowe.w != b.w) {
tymczasowe = new pole(tymczasowe.w + 1, tymczasowe.k);
trasunia.add(tymczasowe);
}
}
if (tymczasowe.k > b.k) {
while (tymczasowe.k != b.k) {
tymczasowe = new pole(tymczasowe.w, tymczasowe.k - 1);
trasunia.add(tymczasowe);
}
}
if (tymczasowe.k < b.k) {
while (tymczasowe.k != b.k) {
tymczasowe = new pole(tymczasowe.w, tymczasowe.k + 1);
trasunia.add(tymczasowe);
}
}
return trasunia;
}
static void aleJakDoPrzejechania()
{
doPrzejechania.clear();
doPrzejechania.add(doZebrania.get(0));
for (int i = 1; i < doZebrania.size(); i++) {
doPrzejechania.addAll(zPolaDoPola(doZebrania.get(i - 1),
doZebrania.get(i)));
}
}
static void aleJakaSekwencjaRuchow() {
sekwencja.clear();
int szukana = 0;
for (int i = 1; i < doPrzejechania.size(); i++) {
pole a = doPrzejechania.get(i - 1);
pole b = doPrzejechania.get(i);
if (pamiec.get(a.w, a.k) == pin.get(szukana)) {
sekwencja.add(ruchy.BEEP);
szukana++;
}
if ((a.w == b.w) && (a.k == b.k)) {
sekwencja.add(ruchy.STAND);
}
if ((a.w < b.w) && (a.k == b.k)) {
sekwencja.add(ruchy.UP);
}
if ((a.w > b.w) && (a.k == b.k)) {
sekwencja.add(ruchy.DOWN);
}
if ((a.w == b.w) && (a.k > b.k)) {
sekwencja.add(ruchy.LEFT);
}
if ((a.w == b.w) && (a.k < b.k)) {
sekwencja.add(ruchy.RIGHT);
}
}
sekwencja.add(ruchy.BEEP);
sekwencja.add(ruchy.END);
}
public static boolean czyJuzMamywymagane()
// wymagane cyferki w pamieci do złozenia pinu :)
{
ArrayList<Integer> liczebnosci = new ArrayList<Integer>();
for (int i = 0; i < pin.size(); i++) {
liczebnosci.add(0);
int pinek = pin.get(i);
for (int w = 4; w > -1; w--) {
for (int k = 0; k < 5; k++)
if (pamiec.get(w, k) == pinek) {
liczebnosci.set(i, liczebnosci.get(i) + 1);
}
}
}
if (liczebnosci.contains(0))
return false;
else
return true;
}
public static void piszpamiec() {
for (int w = 4; w > -1; w--) {
for (int k = 0; k < 5; k++) {
System.out.print((int) pamiec.get(w, k));
System.out.print(" ");
}
System.out.println("");
}
}
public static double odleglosc(float x1, float y1, float x2, float y2) { // z
// pitagorasa,
// oczywiście.
return Math.abs(Math.sqrt(((x1 - x2) * (x1 - x2))
+ ((y1 - y2) * (y1 - y2))));
// niepotrzebne w pinie!
}
static double[] milimetry = { 0, 2, 4, 9, 12, 17, 26, 32, 42, 51, 61, 71,
84, 88, 100, 112, 121, 129, 132 };
static double MiliToKat(double mili) {
if (mili < 0)
return 0.0;
if (mili > 135)
return -90.0;
double mniejsza = 0.0;
double wieksza = 0.0;
int i = 0;
for (i = 0; i < 19; i++) {
if (milimetry[i] <= mili)
mniejsza = i;
else
break;
}
for (i = 0; i < 19; i++) {
if (milimetry[i] >= mili) {
wieksza = i;
break;
}
}
return ((wieksza + mniejsza) / 2.0) * -5.0;
}
static double KatToMili(double kat)
{
if (kat < -90)
return 135.0;
if (kat > 0)
return 0.0;
return (milimetry[(int) kat / -5]);
}
public static void czyscPamiec() {
pamiec = new Matrix(5, 5);
}
public static int dlugosc_trasy(ArrayList<pole> jakiej) {
int dlug = 0;
for (int i = 1; i < jakiej.size(); i++) {
dlug += Math.abs(jakiej.get(i).w - jakiej.get(i - 1).w)
+ Math.abs(jakiej.get(i).k - jakiej.get(i - 1).k);
}
return dlug;
}
public static int ilosc_zakretow(ArrayList<pole> jakiej) {
int ile = 0;
if (jakiej.size() < 2)
return 0;
for (int i = 2; i < jakiej.size(); i++) {
if ((jakiej.get(i).w != jakiej.get(i - 2).w)
&& (jakiej.get(i).k != jakiej.get(i - 2).k))
ile++;
}
return ile;
}
}
| // niepotrzebne w pinie! | package grik;
import java.util.ArrayList;
import java.util.Random;
import lejos.util.Matrix;
public class cortex {
// nie możemy uzywac nic z virtual!
public static ArrayList<Integer> pin = new ArrayList<Integer>();
public static Random generator = new Random();
public static void znany_pin() {
//wedlug regulaminu!
pin.clear();
pin.add(1);
pin.add(2);
pin.add(5);
pin.add(4);
pin.add(3);
pin.add(1);
}
public static void losuj_pin() {
cortex.pin.clear();
ArrayList<Integer> cyfry=new ArrayList<Integer>();
cyfry.add(1);
cyfry.add(2);
cyfry.add(3);
cyfry.add(4);
cyfry.add(5);
for (int i=5;i>0;i--)
{
int hmm=cortex.generator.nextInt(i);
cortex.pin.add(cyfry.get(hmm));
cyfry.remove(hmm);
}
int hmm=cortex.pin.get(0);
cortex.pin.add(hmm);
}
public static Matrix pamiec = new Matrix(5, 5);
enum ruchy {
UP, DOWN, LEFT, RIGHT, STAND, BEEP, END;
}
enum orientacja {
GORA, DOL, PRAWO, LEWO
}
// liczymy od lewego dolnego, zaczynamy w prawym dolnym, a wszedzie mamy
// zera
public static pole pozycja = new pole(0, 4);
public static orientacja skierowanie = orientacja.GORA;
public static ruchy[] sztywne = new ruchy[] { ruchy.UP, ruchy.UP, ruchy.UP,
ruchy.UP, ruchy.LEFT, ruchy.LEFT, ruchy.LEFT, ruchy.LEFT,
ruchy.DOWN, ruchy.DOWN, ruchy.DOWN, ruchy.DOWN, ruchy.RIGHT,
ruchy.RIGHT, ruchy.RIGHT, ruchy.UP, ruchy.UP, ruchy.UP, ruchy.LEFT,
ruchy.LEFT, ruchy.DOWN, ruchy.DOWN, ruchy.RIGHT, ruchy.UP,
ruchy.END };
@SuppressWarnings("deprecation")
public static ArrayList<ruchy> sztywnaSekwencja = new ArrayList<ruchy>(
sztywne);
// public static void wypelnij {}
static ArrayList<pole> doZebrania = new ArrayList<pole>(); // lista pol,
// ktore trzeba
// przejechac (i
// na nich
// piknac!) //
// ruchow
static ArrayList<pole> doPrzejechania = new ArrayList<pole>();
public static ArrayList<ArrayList<pole>> numerki = new ArrayList<ArrayList<pole>>();
static ArrayList<ruchy> sekwencja = new ArrayList<ruchy>(); // zawiera
// sekwencje
// ruchow
public static ArrayList<pole> gdzieTeNumerki(double i) {
ArrayList<pole> tu = new ArrayList<pole>();
for (int w = 0; w < 5; w++) {
for (int k = 0; k < 5; k++) {
if (pamiec.get(w, k) == (int) i)
tu.add(new pole(w, k));
}
}
return tu;
}
public static void generujKandydatow() {
numerki.clear();
for (int i = 0; i < pin.size(); i++) {
numerki.add(gdzieTeNumerki(pin.get(i)));
}
}
public static ArrayList<pole> najlepszaDoZebrania() {
// potem ja trzeba jeszcze uzupelnic, minimalizujac zakrecanie
ArrayList<pole> kandydat = new ArrayList<pole>();
int prog = 1000000;
int ilu_kandydatow = 1;
for (int i = 0; i < numerki.size(); i++) {
ilu_kandydatow *= numerki.get(i).size();
}
for (int licznik = 0; licznik < ilu_kandydatow * 10; licznik++) {
ArrayList<pole> tymczasowa = new ArrayList<pole>();
for (int i = 0; i < numerki.size(); i++) {
int losowy = generator.nextInt(numerki.get(i).size());
tymczasowa.add(numerki.get(i).get(losowy));
}
tymczasowa.add(0, pozycja);
int wynik = dlugosc_trasy(tymczasowa) + ilosc_zakretow(tymczasowa);
if (wynik < prog) {
kandydat = tymczasowa;
prog = wynik;
}
}
return kandydat;
}
static ArrayList<pole> zPolaDoPola(pole a, pole b) {
ArrayList<pole> trasunia = new ArrayList<pole>();
pole tymczasowe = a;
if (a.w == b.w && a.k == b.k)
trasunia.add(a);
if (tymczasowe.w > b.w) {
while (tymczasowe.w != b.w) {
tymczasowe = new pole(tymczasowe.w - 1, tymczasowe.k);
trasunia.add(tymczasowe);
}
}
if (tymczasowe.w < b.w) {
while (tymczasowe.w != b.w) {
tymczasowe = new pole(tymczasowe.w + 1, tymczasowe.k);
trasunia.add(tymczasowe);
}
}
if (tymczasowe.k > b.k) {
while (tymczasowe.k != b.k) {
tymczasowe = new pole(tymczasowe.w, tymczasowe.k - 1);
trasunia.add(tymczasowe);
}
}
if (tymczasowe.k < b.k) {
while (tymczasowe.k != b.k) {
tymczasowe = new pole(tymczasowe.w, tymczasowe.k + 1);
trasunia.add(tymczasowe);
}
}
return trasunia;
}
static void aleJakDoPrzejechania()
{
doPrzejechania.clear();
doPrzejechania.add(doZebrania.get(0));
for (int i = 1; i < doZebrania.size(); i++) {
doPrzejechania.addAll(zPolaDoPola(doZebrania.get(i - 1),
doZebrania.get(i)));
}
}
static void aleJakaSekwencjaRuchow() {
sekwencja.clear();
int szukana = 0;
for (int i = 1; i < doPrzejechania.size(); i++) {
pole a = doPrzejechania.get(i - 1);
pole b = doPrzejechania.get(i);
if (pamiec.get(a.w, a.k) == pin.get(szukana)) {
sekwencja.add(ruchy.BEEP);
szukana++;
}
if ((a.w == b.w) && (a.k == b.k)) {
sekwencja.add(ruchy.STAND);
}
if ((a.w < b.w) && (a.k == b.k)) {
sekwencja.add(ruchy.UP);
}
if ((a.w > b.w) && (a.k == b.k)) {
sekwencja.add(ruchy.DOWN);
}
if ((a.w == b.w) && (a.k > b.k)) {
sekwencja.add(ruchy.LEFT);
}
if ((a.w == b.w) && (a.k < b.k)) {
sekwencja.add(ruchy.RIGHT);
}
}
sekwencja.add(ruchy.BEEP);
sekwencja.add(ruchy.END);
}
public static boolean czyJuzMamywymagane()
// wymagane cyferki w pamieci do złozenia pinu :)
{
ArrayList<Integer> liczebnosci = new ArrayList<Integer>();
for (int i = 0; i < pin.size(); i++) {
liczebnosci.add(0);
int pinek = pin.get(i);
for (int w = 4; w > -1; w--) {
for (int k = 0; k < 5; k++)
if (pamiec.get(w, k) == pinek) {
liczebnosci.set(i, liczebnosci.get(i) + 1);
}
}
}
if (liczebnosci.contains(0))
return false;
else
return true;
}
public static void piszpamiec() {
for (int w = 4; w > -1; w--) {
for (int k = 0; k < 5; k++) {
System.out.print((int) pamiec.get(w, k));
System.out.print(" ");
}
System.out.println("");
}
}
public static double odleglosc(float x1, float y1, float x2, float y2) { // z
// pitagorasa,
// oczywiście.
return Math.abs(Math.sqrt(((x1 - x2) * (x1 - x2))
+ ((y1 - y2) * (y1 - y2))));
// niepotrzebne w <SUF>
}
static double[] milimetry = { 0, 2, 4, 9, 12, 17, 26, 32, 42, 51, 61, 71,
84, 88, 100, 112, 121, 129, 132 };
static double MiliToKat(double mili) {
if (mili < 0)
return 0.0;
if (mili > 135)
return -90.0;
double mniejsza = 0.0;
double wieksza = 0.0;
int i = 0;
for (i = 0; i < 19; i++) {
if (milimetry[i] <= mili)
mniejsza = i;
else
break;
}
for (i = 0; i < 19; i++) {
if (milimetry[i] >= mili) {
wieksza = i;
break;
}
}
return ((wieksza + mniejsza) / 2.0) * -5.0;
}
static double KatToMili(double kat)
{
if (kat < -90)
return 135.0;
if (kat > 0)
return 0.0;
return (milimetry[(int) kat / -5]);
}
public static void czyscPamiec() {
pamiec = new Matrix(5, 5);
}
public static int dlugosc_trasy(ArrayList<pole> jakiej) {
int dlug = 0;
for (int i = 1; i < jakiej.size(); i++) {
dlug += Math.abs(jakiej.get(i).w - jakiej.get(i - 1).w)
+ Math.abs(jakiej.get(i).k - jakiej.get(i - 1).k);
}
return dlug;
}
public static int ilosc_zakretow(ArrayList<pole> jakiej) {
int ile = 0;
if (jakiej.size() < 2)
return 0;
for (int i = 2; i < jakiej.size(); i++) {
if ((jakiej.get(i).w != jakiej.get(i - 2).w)
&& (jakiej.get(i).k != jakiej.get(i - 2).k))
ile++;
}
return ile;
}
}
| f | null |
390 | 10609_0 | cezarygerard/simplesecurep2p | 1,062 | res/examples/serwer/Klient.java | //package serwer.Serwer_1;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.SocketTimeoutException;
import javax.swing.JOptionPane;
/**
* Klasa ta s�u�y do ob�ugi konkretnego klienta. Jak wida� jest runnable czyli mo�na j� odpali� w nowym w�tku.
* Flaga isRunning robi to co zawsze,
* mySocket gniazdko
* streamy to strumienie danych robi� to co zawsze
*/
public class Klient implements Runnable {
private boolean isRunning;
private Socket mySocket;
private InputStream myInputStream;
private OutputStream myOutputStream;
/**
* Kontruktor inicjalizuje wszystko
*/
Klient(Socket inpSocket) {
isRunning = true;
mySocket = inpSocket;
try {
myInputStream = inpSocket.getInputStream();
myOutputStream = inpSocket.getOutputStream();
mySocket.setSoTimeout(1000);
}
catch(IOException e) {
System.out.println("[i] " + e.getMessage());
closeConnection();
}
}
/**
* metoda robi to co w przypadku klienta, wysy�a jedynie dane, zasada jest taka sama, �e koniec linijki jest informacj�, �e trzeba przetworzy� dan� i dlatego ka�dy
* string jest nadawany z ko�cem linii
*/
public void sendMessage(String inpString) {
BufferedWriter tempBufferedWriter = new BufferedWriter(new OutputStreamWriter(myOutputStream));
try {
tempBufferedWriter.write(inpString);
tempBufferedWriter.write('\n');
tempBufferedWriter.flush();
}
catch (IOException e) {
JOptionPane.showMessageDialog(null, "B��d wysy�ania", "Serwer - B��d wysy�ania", JOptionPane.ERROR_MESSAGE);
closeConnection();
}
}
/**
* wysy�anie, nie ma co opisywa�
*/
private void processMessage(String inpMessage) {
System.out.println("Odebrano od klienta: " + inpMessage);
sendMessage(inpMessage);
}
/**
* to co zawsze, klasa jest runnable to znaczy, ze musi by� run, ona wygl�da tak jak w kliencie
*/
@Override
public void run() {
BufferedReader tempBufferedReader = new BufferedReader(new InputStreamReader(myInputStream));
String tempReaderString;
while(isRunning) {
try {
tempReaderString = tempBufferedReader.readLine();
if(tempReaderString != null) {
processMessage(tempReaderString);
}
}
catch(SocketTimeoutException te) {
continue;
}
catch(IOException e) {
JOptionPane.showMessageDialog(null, "B��d odczytu", "Serwer - B��d odczytu", JOptionPane.ERROR_MESSAGE);
closeConnection();
}
}
}
/**
* bez komentarza
*/
private void closeConnection() {
try {
isRunning = false;
myInputStream.close();
myOutputStream.close();
mySocket.close();
}
catch(Exception ex) { }
}
}
| /**
* Klasa ta s�u�y do ob�ugi konkretnego klienta. Jak wida� jest runnable czyli mo�na j� odpali� w nowym w�tku.
* Flaga isRunning robi to co zawsze,
* mySocket gniazdko
* streamy to strumienie danych robi� to co zawsze
*/ | //package serwer.Serwer_1;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.SocketTimeoutException;
import javax.swing.JOptionPane;
/**
* Klasa ta s�u�y <SUF>*/
public class Klient implements Runnable {
private boolean isRunning;
private Socket mySocket;
private InputStream myInputStream;
private OutputStream myOutputStream;
/**
* Kontruktor inicjalizuje wszystko
*/
Klient(Socket inpSocket) {
isRunning = true;
mySocket = inpSocket;
try {
myInputStream = inpSocket.getInputStream();
myOutputStream = inpSocket.getOutputStream();
mySocket.setSoTimeout(1000);
}
catch(IOException e) {
System.out.println("[i] " + e.getMessage());
closeConnection();
}
}
/**
* metoda robi to co w przypadku klienta, wysy�a jedynie dane, zasada jest taka sama, �e koniec linijki jest informacj�, �e trzeba przetworzy� dan� i dlatego ka�dy
* string jest nadawany z ko�cem linii
*/
public void sendMessage(String inpString) {
BufferedWriter tempBufferedWriter = new BufferedWriter(new OutputStreamWriter(myOutputStream));
try {
tempBufferedWriter.write(inpString);
tempBufferedWriter.write('\n');
tempBufferedWriter.flush();
}
catch (IOException e) {
JOptionPane.showMessageDialog(null, "B��d wysy�ania", "Serwer - B��d wysy�ania", JOptionPane.ERROR_MESSAGE);
closeConnection();
}
}
/**
* wysy�anie, nie ma co opisywa�
*/
private void processMessage(String inpMessage) {
System.out.println("Odebrano od klienta: " + inpMessage);
sendMessage(inpMessage);
}
/**
* to co zawsze, klasa jest runnable to znaczy, ze musi by� run, ona wygl�da tak jak w kliencie
*/
@Override
public void run() {
BufferedReader tempBufferedReader = new BufferedReader(new InputStreamReader(myInputStream));
String tempReaderString;
while(isRunning) {
try {
tempReaderString = tempBufferedReader.readLine();
if(tempReaderString != null) {
processMessage(tempReaderString);
}
}
catch(SocketTimeoutException te) {
continue;
}
catch(IOException e) {
JOptionPane.showMessageDialog(null, "B��d odczytu", "Serwer - B��d odczytu", JOptionPane.ERROR_MESSAGE);
closeConnection();
}
}
}
/**
* bez komentarza
*/
private void closeConnection() {
try {
isRunning = false;
myInputStream.close();
myOutputStream.close();
mySocket.close();
}
catch(Exception ex) { }
}
}
| f | null |
392 | 5221_4 | coi-gov-pl/pomocua-ogloszenia | 534 | src/main/java/pl/gov/coi/pomocua/ads/captcha/CaptchaProperties.java | package pl.gov.coi.pomocua.ads.captcha;
import com.google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1Client;
import com.google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1Settings;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import java.io.IOException;
@Data
@ConfigurationProperties(prefix = "app.captcha")
public class CaptchaProperties {
/**
* Identyfikator projektu google cloud.
* https://console.cloud.google.com/projectcreate
*/
private String googleCloudProjectId;
/**
* Klucz recaptcha.
* https://console.cloud.google.com/security/recaptcha
*/
private String siteKey;
/**
* Klucz API z Google Cloud.
* https://cloud.google.com/recaptcha-enterprise/docs/set-up-non-google-cloud-environments-api-keys
*/
private String googleCloudApiKey;
/**
* Poziom akceptowalnej oceny. Po przekroczeniu tej wartości zapytania są odrzucane.
* Możliwa skala to wartości od 0 do 1.
* Gdzie wartość 0 - podejrzana, 1 - niepodejrzana.
*/
private Float acceptLevel;
/**
* Flaga włączająca i wyłączająca walidację captcha.
*/
private boolean enabled = true;
@Bean
RecaptchaEnterpriseServiceV1Beta1Client recaptchaEnterpriseServiceClient() throws IOException {
var builder = RecaptchaEnterpriseServiceV1Beta1Settings.newBuilder();
builder.getStubSettingsBuilder().setApiKey(googleCloudApiKey);
var settings = builder.build();
return RecaptchaEnterpriseServiceV1Beta1Client.create(settings);
}
}
| /**
* Flaga włączająca i wyłączająca walidację captcha.
*/ | package pl.gov.coi.pomocua.ads.captcha;
import com.google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1Client;
import com.google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1Settings;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import java.io.IOException;
@Data
@ConfigurationProperties(prefix = "app.captcha")
public class CaptchaProperties {
/**
* Identyfikator projektu google cloud.
* https://console.cloud.google.com/projectcreate
*/
private String googleCloudProjectId;
/**
* Klucz recaptcha.
* https://console.cloud.google.com/security/recaptcha
*/
private String siteKey;
/**
* Klucz API z Google Cloud.
* https://cloud.google.com/recaptcha-enterprise/docs/set-up-non-google-cloud-environments-api-keys
*/
private String googleCloudApiKey;
/**
* Poziom akceptowalnej oceny. Po przekroczeniu tej wartości zapytania są odrzucane.
* Możliwa skala to wartości od 0 do 1.
* Gdzie wartość 0 - podejrzana, 1 - niepodejrzana.
*/
private Float acceptLevel;
/**
* Flaga włączająca i <SUF>*/
private boolean enabled = true;
@Bean
RecaptchaEnterpriseServiceV1Beta1Client recaptchaEnterpriseServiceClient() throws IOException {
var builder = RecaptchaEnterpriseServiceV1Beta1Settings.newBuilder();
builder.getStubSettingsBuilder().setApiKey(googleCloudApiKey);
var settings = builder.build();
return RecaptchaEnterpriseServiceV1Beta1Client.create(settings);
}
}
| f | null |
393 | 7765_19 | cooligus/jfe | 746 | src/Part1/Zadanie21.java | package Part1;
import java.util.Scanner;
public class Zadanie21 {
public static void main(String[] args) {
// Napisz program, który przeprowadza takie obliczenia. Program powinien wyświetlać
//prośbę o wprowadzenie następujących danych:
//kwoty pieniędzy początkowo zdeponowanej na koncie,
//rocznej stopy oprocentowania,
// ile razy w roku odsetki są kapitalizowane (np. przy kapitalizacji miesięcznej wpisz 12,
// a przy kapitalizacji kwartalnej — 4),
//liczby lat, przez jakie środki będą znajdować się na koncie i generować odsetki.
//Po wprowadzeniu danych wejściowych program powinien obliczać i wyświetlać
//kwotę, jaka znajdzie się na koncie po określonej liczbie lat.
Scanner scan = new Scanner(System.in);
System.out.println("Podaj kwotę pieniędzy początkowo zdeponowych na koncie: ");
double startMoney = scan.nextDouble();
System.out.println("Podaj roczną stopę oprocentowania: ");
double yearPercentFoot = scan.nextDouble();
System.out.println("Ile razy chcesz kapitalizować hajs?");
int capitalizationsPerYear = scan.nextInt();
System.out.println("Jak długo chcesz trzymać hajs?");
int yearsOfStorage = scan.nextInt();
//Gdy bank wypłaca procent składany, płaci odsetki nie tylko od zdeponowanej kwoty,
//ale też od zakumulowanej z czasem kwoty odsetek. Załóżmy, że chcesz zdeponować
//pewną kwotę na rachunku oszczędnościowym i pozwolić na akumulowanie procentu
//składanego przez określoną liczbę lat. Oto wzór na obliczenie stanu konta po
//określonej liczbie lat:
//A = P(1 +r/n)nt
//Oto wartości z tego wzoru:
//A to kwota pieniędzy na koncie po określonej liczbie lat,
//P to kwota pierwotnie zdeponowana na koncie,
// r to roczna stopa oprocentowania,
//n określa, ile razy w roku odsetki są doliczane do kapitału,
// t to liczba lat.
double finalMoney = startMoney * Math.pow((1 + (double)(yearPercentFoot/capitalizationsPerYear)), capitalizationsPerYear * yearsOfStorage);
System.out.println(finalMoney);
}
}
| //n określa, ile razy w roku odsetki są doliczane do kapitału, | package Part1;
import java.util.Scanner;
public class Zadanie21 {
public static void main(String[] args) {
// Napisz program, który przeprowadza takie obliczenia. Program powinien wyświetlać
//prośbę o wprowadzenie następujących danych:
//kwoty pieniędzy początkowo zdeponowanej na koncie,
//rocznej stopy oprocentowania,
// ile razy w roku odsetki są kapitalizowane (np. przy kapitalizacji miesięcznej wpisz 12,
// a przy kapitalizacji kwartalnej — 4),
//liczby lat, przez jakie środki będą znajdować się na koncie i generować odsetki.
//Po wprowadzeniu danych wejściowych program powinien obliczać i wyświetlać
//kwotę, jaka znajdzie się na koncie po określonej liczbie lat.
Scanner scan = new Scanner(System.in);
System.out.println("Podaj kwotę pieniędzy początkowo zdeponowych na koncie: ");
double startMoney = scan.nextDouble();
System.out.println("Podaj roczną stopę oprocentowania: ");
double yearPercentFoot = scan.nextDouble();
System.out.println("Ile razy chcesz kapitalizować hajs?");
int capitalizationsPerYear = scan.nextInt();
System.out.println("Jak długo chcesz trzymać hajs?");
int yearsOfStorage = scan.nextInt();
//Gdy bank wypłaca procent składany, płaci odsetki nie tylko od zdeponowanej kwoty,
//ale też od zakumulowanej z czasem kwoty odsetek. Załóżmy, że chcesz zdeponować
//pewną kwotę na rachunku oszczędnościowym i pozwolić na akumulowanie procentu
//składanego przez określoną liczbę lat. Oto wzór na obliczenie stanu konta po
//określonej liczbie lat:
//A = P(1 +r/n)nt
//Oto wartości z tego wzoru:
//A to kwota pieniędzy na koncie po określonej liczbie lat,
//P to kwota pierwotnie zdeponowana na koncie,
// r to roczna stopa oprocentowania,
//n określa, <SUF>
// t to liczba lat.
double finalMoney = startMoney * Math.pow((1 + (double)(yearPercentFoot/capitalizationsPerYear)), capitalizationsPerYear * yearsOfStorage);
System.out.println(finalMoney);
}
}
| f | null |
395 | 3827_2 | darialasecka/bomberman | 677 | server/src/Server.java | import java.util.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Server extends Thread{
public static int port = 8080;
public static ServerSocket serverSocket = null;
public static List<Player> players = new ArrayList<>();
public static List<Room> rooms = new ArrayList<>();
public static int id = 0;
public static int roomNumber = 0;
public static int bombNumber = 0;
public static int boxNumber = 0;
public static int blastNumber = 0;
public static int powerUpNumber = 0;
/** Places new players in correspondings rooms*/
public static void main(String args[]) {
try {
serverSocket = new ServerSocket(port);//nie mogę bo static
} catch (IOException e) {
e.printStackTrace();
System.out.println("Failed to create ServerSocket.");
}
System.out.println("Server is running...");
Room room = null;
try {
room = new Room(roomNumber);
rooms.add(room);
System.out.println("Created room " + roomNumber);
while (true) {
try {
Socket socket = serverSocket.accept();
if(room.active_game || room.is_full) {
roomNumber++;
room = new Room(roomNumber);
rooms.add(room);
System.out.println("Created room " + roomNumber);
}
Player player = new Player(40,40, Integer.toString(id), socket, roomNumber);
room.players_in_room.add(player);
room.curr_number_of_players ++;
players.add(player);
new Multi(player).start(); //coś co ogarnie klientów
id++;
if(room.curr_number_of_players == room.MAX_CAPACITY){
room.is_full = true;
}
} catch (Exception e){
e.printStackTrace();
System.out.println("Failed to connect to client.");
}
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("Failed to create room.");
}
}
} | //coś co ogarnie klientów | import java.util.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Server extends Thread{
public static int port = 8080;
public static ServerSocket serverSocket = null;
public static List<Player> players = new ArrayList<>();
public static List<Room> rooms = new ArrayList<>();
public static int id = 0;
public static int roomNumber = 0;
public static int bombNumber = 0;
public static int boxNumber = 0;
public static int blastNumber = 0;
public static int powerUpNumber = 0;
/** Places new players in correspondings rooms*/
public static void main(String args[]) {
try {
serverSocket = new ServerSocket(port);//nie mogę bo static
} catch (IOException e) {
e.printStackTrace();
System.out.println("Failed to create ServerSocket.");
}
System.out.println("Server is running...");
Room room = null;
try {
room = new Room(roomNumber);
rooms.add(room);
System.out.println("Created room " + roomNumber);
while (true) {
try {
Socket socket = serverSocket.accept();
if(room.active_game || room.is_full) {
roomNumber++;
room = new Room(roomNumber);
rooms.add(room);
System.out.println("Created room " + roomNumber);
}
Player player = new Player(40,40, Integer.toString(id), socket, roomNumber);
room.players_in_room.add(player);
room.curr_number_of_players ++;
players.add(player);
new Multi(player).start(); //coś co <SUF>
id++;
if(room.curr_number_of_players == room.MAX_CAPACITY){
room.is_full = true;
}
} catch (Exception e){
e.printStackTrace();
System.out.println("Failed to connect to client.");
}
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("Failed to create room.");
}
}
} | f | null |
396 | 6932_2 | davvvidy/CampMaster | 2,031 | src/main/java/menu/BadgesMenu.java | package menu;
import dao.PersBadgesDAO;
import dao.PersonsDAO;
import entity.PersBadge;
import entity.Person;
import entity.User;
import lombok.extern.log4j.Log4j;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.List;
import java.util.Scanner;
@Log4j
public class BadgesMenu {
private final User user;
private final Scanner scanner = new Scanner(System.in);
public BadgesMenu(User user) {
this.user = user;
}
private void showBadges(int showBadgesByPersonID) {
PersBadgesDAO persBadgesDAO = new PersBadgesDAO();
List<PersBadge> badgesList = persBadgesDAO.findByPersonIdJoinBadgesJoinPerson(showBadgesByPersonID); //lista powiązań osoba - odznaka dla danego id osoby
if (badgesList.isEmpty()) {
PersonsDAO personsDAO = new PersonsDAO();
Person person = personsDAO.findById(showBadgesByPersonID);
System.out.println("Przykro nam, dla: " + person.getFirstName() + " " + person.getLastName() +
" nie ma odznak wprowadzonych do bazy danych.");
} else {
//To, żeby wypisał personalia zanim wypisze odznaki
String personalia = badgesList.get(0).getPerson().getFirstName() + " " + badgesList.get(0).getPerson().getLastName();
System.out.println(personalia + " - Odznaki:");
//Tu wypisanie odznak
for (PersBadge each : badgesList) {
System.out.println("Nazwa odznaki: " + each.getBadge().getName() + "\t\tOpis odznaki: " + each.getBadge().getDescription());
}
}
}
private LocalDate getDateFromScanner() {
final String FORMAT = "dd.MM.yyyy";
System.out.println("Podaj datę w formacie " + FORMAT + ": ");
String stringDatyScan = scanner.nextLine();
DateTimeFormatter format = DateTimeFormatter.ofPattern(FORMAT);
LocalDate wczytanaData = LocalDate.parse(stringDatyScan, format);
System.out.println(wczytanaData);
return wczytanaData;
}
public void badgesMenuScreen() {
System.out.println("\nWitaj w CampMaster - Odznaki");
String menu = "\nDokonaj wyboru:\n1. Podejrzyj odznaki.\n2. Nadaj odznakę.\n3. Usuń odznakę.\n4. Wróć.\n5. Wyloguj.";
do {
System.out.println(menu);
int selectedValue;
try {
selectedValue = Integer.parseInt(scanner.nextLine());
} catch (NumberFormatException e) {
System.out.println("Podaj właściwą wartość z przedziału 1-5.");
continue;
}
switch (selectedValue) {
case 1:
if (user.getPrivilegeId() == 3) {
PersonsDAO personsDAO = new PersonsDAO();
List<Person> parentsChildren = personsDAO.createListOfParentsChildren(user.getPersonId());
for (Person each : parentsChildren) {
showBadges(each.getPersonId());
}
} else if (user.getPrivilegeId() == 4) {
showBadges(user.getPersonId());
} else if (user.getPrivilegeId() == 2 || user.getPrivilegeId() == 1){
try {
System.out.println("Podaj person_ID dziecka:");
int personId = Integer.parseInt(scanner.nextLine());
showBadges(personId);
} catch (NullPointerException | NumberFormatException e) {
System.out.println("Podano niewłaściwe dane dziecka, odznaki lub format daty. Podaj prawidłowe.");
log.error(e);
continue;
}
}
break;
case 2:
if (user.getPrivilegeId() == 2 || user.getPrivilegeId() == 1) {
try {
System.out.println("Podaj person ID dziecka:");
int personId = Integer.parseInt(scanner.nextLine());
System.out.println("Podaj badge ID odznaki:");
int badgeId = Integer.parseInt(scanner.nextLine());
System.out.println("Data zdobycia odznaki.");
LocalDate acquired = getDateFromScanner();
PersBadge persBadges = new PersBadge();
persBadges.setBadgeId(badgeId);
persBadges.setPersonId(personId);
persBadges.setAcquired(acquired);
PersBadgesDAO persBadgesDAO = new PersBadgesDAO();
persBadgesDAO.save(persBadges);
showBadges(personId);
} catch (NullPointerException | DateTimeParseException | NumberFormatException e) {
System.out.println("Podano niewłaściwe dane dziecka, odznaki lub format daty. Podaj prawidłowe dane.");
log.error(e);
continue;
}
} else {
System.out.println("Nie masz odpowiednich uprawnień!");
}
break;
case 3:
if (user.getPrivilegeId() == 2 || user.getPrivilegeId() == 1) {
try {
System.out.println("Podaj person ID dziecka:");
int personId = Integer.parseInt(scanner.nextLine());
System.out.println("Podaj badge ID odznaki:");
int badgeId = Integer.parseInt(scanner.nextLine());
PersBadge persBadges = new PersBadge();
persBadges.setBadgeId(badgeId);
persBadges.setPersonId(personId);
PersBadgesDAO persBadgesDAO = new PersBadgesDAO();
persBadgesDAO.delete(persBadges);
showBadges(personId);
} catch (NullPointerException | NumberFormatException e) {
System.out.println("Podano niewłaściwe dane dziecka lub odznaki. Podaj prawidłowe.");
log.error(e);
continue;
//Wypisuje błąd przy złym person_id (tak chcę) ale nie wypisuje błędu przy złym badge_id
}
} else {
System.out.println("Nie masz odpowiednich uprawnień!");
}
break;
case 4:
return;
case 5:
System.exit(-1);
break;
default:
System.out.println("Nie dokonano właściwego wyboru. Wybierz wartość z przedziału 1-5.");
}
} while (true);
}
}
| //Tu wypisanie odznak
| package menu;
import dao.PersBadgesDAO;
import dao.PersonsDAO;
import entity.PersBadge;
import entity.Person;
import entity.User;
import lombok.extern.log4j.Log4j;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.List;
import java.util.Scanner;
@Log4j
public class BadgesMenu {
private final User user;
private final Scanner scanner = new Scanner(System.in);
public BadgesMenu(User user) {
this.user = user;
}
private void showBadges(int showBadgesByPersonID) {
PersBadgesDAO persBadgesDAO = new PersBadgesDAO();
List<PersBadge> badgesList = persBadgesDAO.findByPersonIdJoinBadgesJoinPerson(showBadgesByPersonID); //lista powiązań osoba - odznaka dla danego id osoby
if (badgesList.isEmpty()) {
PersonsDAO personsDAO = new PersonsDAO();
Person person = personsDAO.findById(showBadgesByPersonID);
System.out.println("Przykro nam, dla: " + person.getFirstName() + " " + person.getLastName() +
" nie ma odznak wprowadzonych do bazy danych.");
} else {
//To, żeby wypisał personalia zanim wypisze odznaki
String personalia = badgesList.get(0).getPerson().getFirstName() + " " + badgesList.get(0).getPerson().getLastName();
System.out.println(personalia + " - Odznaki:");
//Tu wypisanie <SUF>
for (PersBadge each : badgesList) {
System.out.println("Nazwa odznaki: " + each.getBadge().getName() + "\t\tOpis odznaki: " + each.getBadge().getDescription());
}
}
}
private LocalDate getDateFromScanner() {
final String FORMAT = "dd.MM.yyyy";
System.out.println("Podaj datę w formacie " + FORMAT + ": ");
String stringDatyScan = scanner.nextLine();
DateTimeFormatter format = DateTimeFormatter.ofPattern(FORMAT);
LocalDate wczytanaData = LocalDate.parse(stringDatyScan, format);
System.out.println(wczytanaData);
return wczytanaData;
}
public void badgesMenuScreen() {
System.out.println("\nWitaj w CampMaster - Odznaki");
String menu = "\nDokonaj wyboru:\n1. Podejrzyj odznaki.\n2. Nadaj odznakę.\n3. Usuń odznakę.\n4. Wróć.\n5. Wyloguj.";
do {
System.out.println(menu);
int selectedValue;
try {
selectedValue = Integer.parseInt(scanner.nextLine());
} catch (NumberFormatException e) {
System.out.println("Podaj właściwą wartość z przedziału 1-5.");
continue;
}
switch (selectedValue) {
case 1:
if (user.getPrivilegeId() == 3) {
PersonsDAO personsDAO = new PersonsDAO();
List<Person> parentsChildren = personsDAO.createListOfParentsChildren(user.getPersonId());
for (Person each : parentsChildren) {
showBadges(each.getPersonId());
}
} else if (user.getPrivilegeId() == 4) {
showBadges(user.getPersonId());
} else if (user.getPrivilegeId() == 2 || user.getPrivilegeId() == 1){
try {
System.out.println("Podaj person_ID dziecka:");
int personId = Integer.parseInt(scanner.nextLine());
showBadges(personId);
} catch (NullPointerException | NumberFormatException e) {
System.out.println("Podano niewłaściwe dane dziecka, odznaki lub format daty. Podaj prawidłowe.");
log.error(e);
continue;
}
}
break;
case 2:
if (user.getPrivilegeId() == 2 || user.getPrivilegeId() == 1) {
try {
System.out.println("Podaj person ID dziecka:");
int personId = Integer.parseInt(scanner.nextLine());
System.out.println("Podaj badge ID odznaki:");
int badgeId = Integer.parseInt(scanner.nextLine());
System.out.println("Data zdobycia odznaki.");
LocalDate acquired = getDateFromScanner();
PersBadge persBadges = new PersBadge();
persBadges.setBadgeId(badgeId);
persBadges.setPersonId(personId);
persBadges.setAcquired(acquired);
PersBadgesDAO persBadgesDAO = new PersBadgesDAO();
persBadgesDAO.save(persBadges);
showBadges(personId);
} catch (NullPointerException | DateTimeParseException | NumberFormatException e) {
System.out.println("Podano niewłaściwe dane dziecka, odznaki lub format daty. Podaj prawidłowe dane.");
log.error(e);
continue;
}
} else {
System.out.println("Nie masz odpowiednich uprawnień!");
}
break;
case 3:
if (user.getPrivilegeId() == 2 || user.getPrivilegeId() == 1) {
try {
System.out.println("Podaj person ID dziecka:");
int personId = Integer.parseInt(scanner.nextLine());
System.out.println("Podaj badge ID odznaki:");
int badgeId = Integer.parseInt(scanner.nextLine());
PersBadge persBadges = new PersBadge();
persBadges.setBadgeId(badgeId);
persBadges.setPersonId(personId);
PersBadgesDAO persBadgesDAO = new PersBadgesDAO();
persBadgesDAO.delete(persBadges);
showBadges(personId);
} catch (NullPointerException | NumberFormatException e) {
System.out.println("Podano niewłaściwe dane dziecka lub odznaki. Podaj prawidłowe.");
log.error(e);
continue;
//Wypisuje błąd przy złym person_id (tak chcę) ale nie wypisuje błędu przy złym badge_id
}
} else {
System.out.println("Nie masz odpowiednich uprawnień!");
}
break;
case 4:
return;
case 5:
System.exit(-1);
break;
default:
System.out.println("Nie dokonano właściwego wyboru. Wybierz wartość z przedziału 1-5.");
}
} while (true);
}
}
| f | null |
397 | 6215_20 | dawidolko/Algorithms-Data-Structures | 1,189 | Kolokwium/kolokwium2/A/A3_BDB/LinkedList.java | package A.A3_BDB;
// A3 Implementacja listy powiązanej liczb całkowitch "LinkedList" - BDB
// Klasa LinkedList reprezentuje listę powiązaną przechowującą liczby całkowite.
public class LinkedList {
public ListElem first, last; // Referencje do pierwszego i ostatniego elementu listy
// Konstruktor inicjuje listę jako pustą.
public LinkedList() {
first = null;
last = null;
}
// Metoda isEmpty sprawdza, czy lista jest pusta.
public boolean isEmpty() {
return first == null;
}
// Metoda insertFirst dodaje nowy element na początek listy.
public void insertFirst(int x) {
ListElem e = new ListElem(x);
if (isEmpty()) last = e; // Jeśli lista była pusta, ustawia "last" na nowy element
else first.previous = e; // W przeciwnym razie, ustawia "previous" obecnie pierwszego elementu na nowy element
e.next = first; // Ustawia "next" nowego elementu na dotychczasowy pierwszy element
first = e; // Ustawia "first" na nowy element
}
// Metoda insertLast dodaje nowy element na koniec listy.
public void insertLast(int x) {
ListElem e = new ListElem(x);
if (isEmpty()) first = e; // Jeśli lista była pusta, ustawia "first" na nowy element
else last.next = e; // W przeciwnym razie, ustawia "next" obecnie ostatniego elementu na nowy element
e.previous = last; // Ustawia "previous" nowego elementu na dotychczasowy ostatni element
last = e; // Ustawia "last" na nowy element
}
// Metoda removeFirst usuwa pierwszy element z listy i zwraca go.
public ListElem removeFirst() {
if (isEmpty()) return null;
ListElem temp = first;
if (first.next == null) last = null; // Jeśli był tylko jeden element, ustawia "last" na null
else first.next.previous = null; // W przeciwnym razie, ustawia "previous" drugiego elementu na null
first = first.next; // Ustawia "first" na drugi element
return temp;
}
// Metoda removeLast usuwa ostatni element z listy i zwraca go.
public ListElem removeLast() {
if (isEmpty()) return null;
ListElem temp = last;
if (last.previous == null) first = null; // Jeśli był tylko jeden element, ustawia "first" na null
else last.previous.next = null; // W przeciwnym razie, ustawia "next" przedostatniego elementu na null
last = last.previous; // Ustawia "last" na przedostatni element
return temp;
}
// Metoda print wypisuje zawartość listy na konsoli.
public void print() {
System.out.println("Zawartosc listy:");
ListElem current = first;
while (current != null) {
System.out.print(current.Data + " ");
current = current.next;
}
}
// Metoda find wyszukuje element o określonej wartości w liście.
// Zwraca true, jeśli element zostanie znaleziony, lub false w przeciwnym przypadku.
public boolean find(int elem) {
if (isEmpty()) return false;
ListElem current = first; // Rozpoczynamy od pierwszego elementu
while (current.Data != elem) {
if (current.next == null) return false;
else current = current.next;
}
return true;
}
// Metoda main zawiera przykładowe użycie klasy LinkedList.
public static void main(String[] args) {
LinkedList list = new LinkedList();
int p1 = 12;
list.insertFirst(p1);
list.insertFirst(13);
list.insertFirst(14);
list.insertLast(2);
list.insertLast(7);
list.insertLast(5);
list.print();
list.removeFirst();
list.print();
System.out.println("\n" + list.find(133333));
}
} | // Jeśli był tylko jeden element, ustawia "first" na null
| package A.A3_BDB;
// A3 Implementacja listy powiązanej liczb całkowitch "LinkedList" - BDB
// Klasa LinkedList reprezentuje listę powiązaną przechowującą liczby całkowite.
public class LinkedList {
public ListElem first, last; // Referencje do pierwszego i ostatniego elementu listy
// Konstruktor inicjuje listę jako pustą.
public LinkedList() {
first = null;
last = null;
}
// Metoda isEmpty sprawdza, czy lista jest pusta.
public boolean isEmpty() {
return first == null;
}
// Metoda insertFirst dodaje nowy element na początek listy.
public void insertFirst(int x) {
ListElem e = new ListElem(x);
if (isEmpty()) last = e; // Jeśli lista była pusta, ustawia "last" na nowy element
else first.previous = e; // W przeciwnym razie, ustawia "previous" obecnie pierwszego elementu na nowy element
e.next = first; // Ustawia "next" nowego elementu na dotychczasowy pierwszy element
first = e; // Ustawia "first" na nowy element
}
// Metoda insertLast dodaje nowy element na koniec listy.
public void insertLast(int x) {
ListElem e = new ListElem(x);
if (isEmpty()) first = e; // Jeśli lista była pusta, ustawia "first" na nowy element
else last.next = e; // W przeciwnym razie, ustawia "next" obecnie ostatniego elementu na nowy element
e.previous = last; // Ustawia "previous" nowego elementu na dotychczasowy ostatni element
last = e; // Ustawia "last" na nowy element
}
// Metoda removeFirst usuwa pierwszy element z listy i zwraca go.
public ListElem removeFirst() {
if (isEmpty()) return null;
ListElem temp = first;
if (first.next == null) last = null; // Jeśli był tylko jeden element, ustawia "last" na null
else first.next.previous = null; // W przeciwnym razie, ustawia "previous" drugiego elementu na null
first = first.next; // Ustawia "first" na drugi element
return temp;
}
// Metoda removeLast usuwa ostatni element z listy i zwraca go.
public ListElem removeLast() {
if (isEmpty()) return null;
ListElem temp = last;
if (last.previous == null) first = null; // Jeśli był <SUF>
else last.previous.next = null; // W przeciwnym razie, ustawia "next" przedostatniego elementu na null
last = last.previous; // Ustawia "last" na przedostatni element
return temp;
}
// Metoda print wypisuje zawartość listy na konsoli.
public void print() {
System.out.println("Zawartosc listy:");
ListElem current = first;
while (current != null) {
System.out.print(current.Data + " ");
current = current.next;
}
}
// Metoda find wyszukuje element o określonej wartości w liście.
// Zwraca true, jeśli element zostanie znaleziony, lub false w przeciwnym przypadku.
public boolean find(int elem) {
if (isEmpty()) return false;
ListElem current = first; // Rozpoczynamy od pierwszego elementu
while (current.Data != elem) {
if (current.next == null) return false;
else current = current.next;
}
return true;
}
// Metoda main zawiera przykładowe użycie klasy LinkedList.
public static void main(String[] args) {
LinkedList list = new LinkedList();
int p1 = 12;
list.insertFirst(p1);
list.insertFirst(13);
list.insertFirst(14);
list.insertLast(2);
list.insertLast(7);
list.insertLast(5);
list.print();
list.removeFirst();
list.print();
System.out.println("\n" + list.find(133333));
}
} | f | null |
398 | 5623_0 | dawidolko/Numerical-Methods | 363 | LABS/Java/Bisekcja/Bisekcja.java |
package Bisekcja;
public class Bisekcja {
static int licznik = 0;
static double bisekcja(double a, double b) {
double x = (a+b)/2;
double fx = (x+1)*Math.pow((x-1),4); //wzór funkcji
if(Math.abs(a-b) > Math.pow(10,-8)) { //Math.pow(10,-8) dokładność do jakiej liczymy
if (fx == 0)
return x;
else {
licznik++;
double fa = (a + 1) * Math.pow((a - 1), 4);
double fb = (a + 1) * Math.pow((a - 1), 4);
if (fa * fx < 0) {
b = x;
return bisekcja(a, b);
} else {
a = x;
return bisekcja(a, b);
}
}
} else {
return x;
}
}
public static void main(String[] args) {
System.out.println(bisekcja(-1.5, -0.75)); //przedział gdzie znajduje się pierwiastek
System.out.println("Licznik iteracji: " + licznik);
}
}
| //Math.pow(10,-8) dokładność do jakiej liczymy |
package Bisekcja;
public class Bisekcja {
static int licznik = 0;
static double bisekcja(double a, double b) {
double x = (a+b)/2;
double fx = (x+1)*Math.pow((x-1),4); //wzór funkcji
if(Math.abs(a-b) > Math.pow(10,-8)) { //Math.pow(10,-8) dokładność <SUF>
if (fx == 0)
return x;
else {
licznik++;
double fa = (a + 1) * Math.pow((a - 1), 4);
double fb = (a + 1) * Math.pow((a - 1), 4);
if (fa * fx < 0) {
b = x;
return bisekcja(a, b);
} else {
a = x;
return bisekcja(a, b);
}
}
} else {
return x;
}
}
public static void main(String[] args) {
System.out.println(bisekcja(-1.5, -0.75)); //przedział gdzie znajduje się pierwiastek
System.out.println("Licznik iteracji: " + licznik);
}
}
| f | null |
399 | 4576_5 | dawidolko/Programming-Java | 654 | Kolokwium/exam1v2/kolokwium1v2/kolokwium1/src/Zadanie4/Main.java | package Zadanie4;
//POLECENIE:
// A) Utwórz klasę Pracownik, dziedziczącą po klasie Osoba. Klasa zawiera dodatkowo dwa pola:
//
// zawod: String;
// staz_pracy:int;
//
// - Utwórz przynajmniej dwa przeciążenia konstruktora.
//
// B) Dokonaj hermetyzacji pól klasy, tworząc metody udostępniające pola, zwróć uwagę, że niektóre pola typu liczbowego powinny zawsze być dodatnie.
//
// C) Przesłoń metodę WyswietlDaneOsoby(), tak aby wyświetlała wszystkie dane osoby.
//
// D) Przetestuj działanie programu, podobnie jak w zadaniu 3, wyniki wypisz w komentarzu pod kodem.
public class Main {
public static void main(String[] args) {
Pracownik pracownik1 = new Pracownik();
pracownik1.setImie("Jan");
pracownik1.setNazwisko("Kowalski");
pracownik1.setWiek(35);
pracownik1.setKrajPochodzenia("Polska");
pracownik1.setZawod("Informatyk");
pracownik1.setStazPracy(7);
pracownik1.WyswietlDaneOsoby();
Pracownik pracownik2 = new Pracownik("Anna", "Nowak", "Nauczyciel");
pracownik2.setWiek(28);
pracownik2.setKrajPochodzenia("Niemcy");
pracownik2.setStazPracy(3);
pracownik2.WyswietlDaneOsoby();
}
}
// Dane osoby:
// Imię: Jan
// Nazwisko: Kowalski
// Wiek: 35
// Kraj pochodzenia: Polska
// Zawód: Informatyk
// Staż pracy: 7 lat
//
// Dane osoby:
// Imię: Anna
// Nazwisko: Nowak
// Wiek: 28
// Kraj pochodzenia: Niemcy
// Zawód: Nauczyciel
// Staż pracy: 3 lat
| // Kraj pochodzenia: Polska
| package Zadanie4;
//POLECENIE:
// A) Utwórz klasę Pracownik, dziedziczącą po klasie Osoba. Klasa zawiera dodatkowo dwa pola:
//
// zawod: String;
// staz_pracy:int;
//
// - Utwórz przynajmniej dwa przeciążenia konstruktora.
//
// B) Dokonaj hermetyzacji pól klasy, tworząc metody udostępniające pola, zwróć uwagę, że niektóre pola typu liczbowego powinny zawsze być dodatnie.
//
// C) Przesłoń metodę WyswietlDaneOsoby(), tak aby wyświetlała wszystkie dane osoby.
//
// D) Przetestuj działanie programu, podobnie jak w zadaniu 3, wyniki wypisz w komentarzu pod kodem.
public class Main {
public static void main(String[] args) {
Pracownik pracownik1 = new Pracownik();
pracownik1.setImie("Jan");
pracownik1.setNazwisko("Kowalski");
pracownik1.setWiek(35);
pracownik1.setKrajPochodzenia("Polska");
pracownik1.setZawod("Informatyk");
pracownik1.setStazPracy(7);
pracownik1.WyswietlDaneOsoby();
Pracownik pracownik2 = new Pracownik("Anna", "Nowak", "Nauczyciel");
pracownik2.setWiek(28);
pracownik2.setKrajPochodzenia("Niemcy");
pracownik2.setStazPracy(3);
pracownik2.WyswietlDaneOsoby();
}
}
// Dane osoby:
// Imię: Jan
// Nazwisko: Kowalski
// Wiek: 35
// Kraj pochodzenia: <SUF>
// Zawód: Informatyk
// Staż pracy: 7 lat
//
// Dane osoby:
// Imię: Anna
// Nazwisko: Nowak
// Wiek: 28
// Kraj pochodzenia: Niemcy
// Zawód: Nauczyciel
// Staż pracy: 3 lat
| f | null |
401 | 10602_1 | ddavid09/simulation-petrol-station-dissimlab-javafx | 537 | src/pl/dawidziak/model/events/StartPayEvent.java | package pl.dawidziak.model.events;
import dissimlab.simcore.BasicSimEvent;
import dissimlab.simcore.SimControlException;
import pl.dawidziak.model.*;
import pl.dawidziak.view.EnvironmentChangeListener;
import java.util.Arrays;
import java.util.List;
public class StartPayEvent extends BasicSimEvent<Environment, Stand> {
public StartPayEvent(Environment entity, double delay, Stand o) throws SimControlException {
super(entity, delay, o);
}
@Override
protected void stateChange() throws SimControlException {
Environment environment = getSimObj();
Stand stand = transitionParams;
Client client = stand.getStoredClient();
List<Stand> standsList = Arrays.asList(environment.counterStands);
int standIndex = standsList.indexOf(stand)+1;
System.out.println(String.format("%-14.4f", simTime()) + "Klient nr " + client.idNumber + " rozpoczal placenie w kasie nr " + standIndex);
//Poniewaz w poleceniu nie zostal sparametryzowany czas placenia w kasie, czasy zostaly wylosowane z rozkladem takim jak czas tankowania PB oraz podzielone przez 3
//poniewaz czas placenia jest zawsze krotszy niz czas tankowania
RandomGenerator RandomGen = new RandomGenerator();
Distribution distribution= environment.simParameters.PBtankTimeDistrib;
double delay = RandomGen.generate(distribution);
new FinishPayEvent(environment, delay/2, stand);
slowSim(environment);
}
private void slowSim(Environment environment) {
environment.simManager.pauseSimulation();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
environment.simManager.resumeSimulation();
}
@Override
protected void onTermination() throws SimControlException {
}
@Override
protected void onInterruption() throws SimControlException {
}
}
| //poniewaz czas placenia jest zawsze krotszy niz czas tankowania | package pl.dawidziak.model.events;
import dissimlab.simcore.BasicSimEvent;
import dissimlab.simcore.SimControlException;
import pl.dawidziak.model.*;
import pl.dawidziak.view.EnvironmentChangeListener;
import java.util.Arrays;
import java.util.List;
public class StartPayEvent extends BasicSimEvent<Environment, Stand> {
public StartPayEvent(Environment entity, double delay, Stand o) throws SimControlException {
super(entity, delay, o);
}
@Override
protected void stateChange() throws SimControlException {
Environment environment = getSimObj();
Stand stand = transitionParams;
Client client = stand.getStoredClient();
List<Stand> standsList = Arrays.asList(environment.counterStands);
int standIndex = standsList.indexOf(stand)+1;
System.out.println(String.format("%-14.4f", simTime()) + "Klient nr " + client.idNumber + " rozpoczal placenie w kasie nr " + standIndex);
//Poniewaz w poleceniu nie zostal sparametryzowany czas placenia w kasie, czasy zostaly wylosowane z rozkladem takim jak czas tankowania PB oraz podzielone przez 3
//poniewaz czas <SUF>
RandomGenerator RandomGen = new RandomGenerator();
Distribution distribution= environment.simParameters.PBtankTimeDistrib;
double delay = RandomGen.generate(distribution);
new FinishPayEvent(environment, delay/2, stand);
slowSim(environment);
}
private void slowSim(Environment environment) {
environment.simManager.pauseSimulation();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
environment.simManager.resumeSimulation();
}
@Override
protected void onTermination() throws SimControlException {
}
@Override
protected void onInterruption() throws SimControlException {
}
}
| f | null |
402 | 5983_1 | ddominet/ECTS-blockchain | 253 | src/main/java/com/example/ecoin/TransactionOutput.java | package com.example.ecoin;
import java.security.PublicKey;
public class TransactionOutput {
public String id;
public PublicKey reciepient; //odbiorca (nowy właściciel)
public float value; //kwota
public String parentTransactionId; //identyfikator tranzakcji do którego należy ten output
//Konstruktor
public TransactionOutput(PublicKey reciepient, float value, String parentTransactionId) {
this.reciepient = reciepient;
this.value = value;
this.parentTransactionId = parentTransactionId;
this.id = StringUtil.applySha256(StringUtil.getStringFromKey(reciepient)+Float.toString(value)+parentTransactionId);
}
//sprawdż czy coin należy do ciebie
public boolean isMine(PublicKey publicKey) {
return (publicKey == reciepient);
}
}
| //identyfikator tranzakcji do którego należy ten output | package com.example.ecoin;
import java.security.PublicKey;
public class TransactionOutput {
public String id;
public PublicKey reciepient; //odbiorca (nowy właściciel)
public float value; //kwota
public String parentTransactionId; //identyfikator tranzakcji <SUF>
//Konstruktor
public TransactionOutput(PublicKey reciepient, float value, String parentTransactionId) {
this.reciepient = reciepient;
this.value = value;
this.parentTransactionId = parentTransactionId;
this.id = StringUtil.applySha256(StringUtil.getStringFromKey(reciepient)+Float.toString(value)+parentTransactionId);
}
//sprawdż czy coin należy do ciebie
public boolean isMine(PublicKey publicKey) {
return (publicKey == reciepient);
}
}
| f | null |
403 | 5208_11 | dedyk/JapaneseDictionaryWeb | 5,478 | src/main/java/pl/idedyk/japanese/dictionary/web/queue/QueueService.java | package pl.idedyk.japanese.dictionary.web.queue;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.URI;
import java.net.UnknownHostException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import jakarta.annotation.PostConstruct;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import pl.idedyk.japanese.dictionary.web.mysql.MySQLConnector;
import pl.idedyk.japanese.dictionary.web.mysql.model.QueueItem;
import pl.idedyk.japanese.dictionary.web.mysql.model.QueueItemStatus;
@Service
public class QueueService {
private static final Logger logger = LogManager.getLogger(QueueService.class);
@Autowired
private MySQLConnector mySQLConnector;
@Value("${local.dir.job.queue}")
private String localDirJobQueueDir;
private File localDirJobQueueDirFile;
private File localDirJobQueryArchiveDirFile;
//
private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
@PostConstruct
public void init() {
logger.info("Inicjalizowanie QueueService");
localDirJobQueueDirFile = new File(localDirJobQueueDir);
if (localDirJobQueueDirFile.exists() == false) {
logger.info("Tworzę katalog " + localDirJobQueueDir + " do ewentualnej lokalnej kolejki");
localDirJobQueueDirFile.mkdirs();
}
if (localDirJobQueueDirFile.exists() == false || localDirJobQueueDirFile.canWrite() == false) {
logger.error("Nie mogę zainicjalizować katalogu " + localDirJobQueueDir + " do ewentualnej lokalnej kolejki");
throw new RuntimeException();
}
//
localDirJobQueryArchiveDirFile = new File(localDirJobQueueDirFile, "archive");
if (localDirJobQueryArchiveDirFile.exists() == false) {
logger.info("Tworzę katalog " + localDirJobQueryArchiveDirFile.getPath() + " do archiwum lokalnej kolejki");
localDirJobQueryArchiveDirFile.mkdirs();
}
if (localDirJobQueryArchiveDirFile.exists() == false || localDirJobQueryArchiveDirFile.canWrite() == false) {
logger.error("Nie mogę zainicjalizować katalogu " + localDirJobQueryArchiveDirFile.getPath() + " do archiwum lokalnej kolejki");
throw new RuntimeException();
}
}
public void sendToQueue(String queueName, byte[] object) throws SQLException {
// stworzenie nowego elementu do kolejki
QueueItem queueItem = new QueueItem();
queueItem.setName(queueName);
queueItem.setStatus(QueueItemStatus.WAITING);
queueItem.setHostName(getHostName());
queueItem.setSendTimestamp(new Timestamp(new Date().getTime()));
queueItem.setDeliveryCount(0);
queueItem.setNextAttempt(queueItem.getSendTimestamp());
queueItem.setObject(object);
// zapisanie do lokalnego katalogu z kolejka
saveToLocalDir(queueItem);
/*
try {
// wstawienie do kolejki
mySQLConnector.insertQueueItem(queueItem);
} catch (SQLException e) {
throw e;
}
*/
}
private String getHostName() {
try {
return InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException e) {
return "localhost";
}
}
private void saveToLocalDir(QueueItem queueItem) {
// logger.info("Zapisanie do lokalnego katalogu kolejki");
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String dateString = sdf.format(queueItem.getSendTimestamp());
String randomFileName = UUID.randomUUID().toString();
File queueItemFileBody = new File(localDirJobQueueDirFile, queueItem.getName() + "_" + dateString + "_" + randomFileName);
File queueItemBodyReady = new File(localDirJobQueueDirFile, queueItem.getName() + "_" + dateString + "_" + randomFileName + ".ready");
ByteArrayOutputStream bos = null;
ObjectOutput objectOutput = null;
FileOutputStream fos = null;
try {
// serializacja obiektu
bos = new ByteArrayOutputStream();
objectOutput = new ObjectOutputStream(bos);
objectOutput.writeObject(queueItem);
objectOutput.close();
bos.close();
byte[] queueItemByteArray = bos.toByteArray();
fos = new FileOutputStream(queueItemFileBody);
fos.write(queueItemByteArray);
queueItemBodyReady.createNewFile();
} catch (IOException e) {
logger.error("Błąd zapisu do lokalnego katalogu kolejki", e);
} finally {
if (fos != null) {
try {
fos.close();
} catch (Exception e) {
// noop
}
}
}
}
public List<QueueItem> getNextItemQueueItem(String queueName) throws SQLException {
List<QueueItem> result = mySQLConnector.getNextQueueItem(queueName, getHostName());
if (result != null) {
for (QueueItem queueItem : result) {
// zachowanie zgodnosci
if (queueItem.getHostName() == null) {
queueItem.setHostName(getHostName());
}
}
}
return result;
}
public void setQueueItemDone(QueueItem queueItem) throws SQLException {
queueItem.setStatus(QueueItemStatus.DONE);
// uaktualnie wpisu
mySQLConnector.updateQueueItem(queueItem);
}
public void setQueueItemError(QueueItem queueItem) throws SQLException {
queueItem.setStatus(QueueItemStatus.ERROR);
// uaktualnie wpisu
mySQLConnector.updateQueueItem(queueItem);
}
public void delayQueueItem(QueueItem queueItem) throws SQLException {
int deliveryCount = queueItem.getDeliveryCount() + 1;
Timestamp nextAttempt = queueItem.getNextAttempt();
Calendar calendar = Calendar.getInstance();
calendar.setTime(nextAttempt);
calendar.add(Calendar.SECOND, 10 * deliveryCount * 2);
nextAttempt = new Timestamp(calendar.getTime().getTime());
queueItem.setDeliveryCount(deliveryCount);
queueItem.setNextAttempt(nextAttempt);
// uaktualnie wpisu
mySQLConnector.updateQueueItem(queueItem);
}
public void processLocalDirQueueItems() {
// proba znalezienia plikow z lokalnego katalogu kolejki
File[] queueItemsFileReadyList = localDirJobQueueDirFile.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.isFile() == false) {
return false;
}
String fileName = pathname.getName();
if (fileName.endsWith(".ready") == true) {
return true;
}
return false;
}
});
Arrays.sort(queueItemsFileReadyList, new Comparator<File>() {
@Override
public int compare(File f1, File f2) {
if (f1.lastModified() < f2.lastModified()) {
return -1;
} else if (f1.lastModified() > f2.lastModified()) {
return 1;
} else {
return 0;
}
}
});
if (queueItemsFileReadyList != null && queueItemsFileReadyList.length > 0) {
// logger.info("Znaleziono pliki z lokalnej kolejki");
for (File currentReadyQueueItemFile : queueItemsFileReadyList) {
File queueItemFile = new File(currentReadyQueueItemFile.getParent(), currentReadyQueueItemFile.getName().substring(0, currentReadyQueueItemFile.getName().length() - ".ready".length()));
// logger.info("Przetwarzam plik " + queueItemFile.getName());
ObjectInputStream ois = null;
QueueItem queueItem = null;
try {
ois = new ObjectInputStream(new FileInputStream(queueItemFile));
queueItem = (QueueItem)ois.readObject();
} catch (Exception e) {
logger.error("Błąd podczas odczytywania pliku z lokalnej kolejki: " + queueItemFile.getName(), e);
continue;
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
// noop
}
}
}
// zachowanie zgodnosci
if (queueItem.getHostName() == null) {
queueItem.setHostName(getHostName());
}
try {
// proba wstawienia do bazy danych
mySQLConnector.insertQueueItem(queueItem);
} catch (SQLException e) {
logger.error("Błąd wstawienia do bazy danych z lokalnej kolejki: " + e.getMessage());
continue;
}
// udalo sie, kasujemy plik ready
currentReadyQueueItemFile.delete();
// przenosimy plik do archiwum
// sprawdzenie i ewentualne utworzenie katalogu z data
File localDirJobQueryArchiveDirWithDateFile = new File(localDirJobQueryArchiveDirFile, dateFormat.format(queueItem.getSendTimestamp()));
if (localDirJobQueryArchiveDirWithDateFile.exists() == false && localDirJobQueryArchiveDirWithDateFile.isDirectory() == false) { // tworzymy katalog
localDirJobQueryArchiveDirWithDateFile.mkdir();
}
// przenosimy plik do wspolnego archiwum
FileSystem archiveFileSystem = null;
try {
// utworzenie nazwy pliku z archiwum
Calendar querySendTimestampCalendar = Calendar.getInstance();
querySendTimestampCalendar.setTime(queueItem.getSendTimestamp());
int sendTimestampHourOfDay = querySendTimestampCalendar.get(Calendar.HOUR_OF_DAY);
String archivePartFileName = dateFormat.format(querySendTimestampCalendar.getTime()) + "_" + (sendTimestampHourOfDay < 10 ? "0" + sendTimestampHourOfDay : sendTimestampHourOfDay)
+ "_" + (querySendTimestampCalendar.get(Calendar.MINUTE) / 10) + "0";
//
File archiveFile = new File(localDirJobQueryArchiveDirWithDateFile, archivePartFileName + ".zip");
URI archiveFileUri = URI.create("jar:file:" + archiveFile.getAbsolutePath());
// utworzenie archiwum
Map<String, String> archiveEnv = new HashMap<>();
archiveEnv.put("create", String.valueOf(archiveFile.exists() == false));
archiveFileSystem = FileSystems.newFileSystem(archiveFileUri, archiveEnv);
// przenoszenie pliku do archiwum
Path queueItemFilePathInArchiveFile = archiveFileSystem.getPath(queueItemFile.getName());
Files.copy(queueItemFile.toPath(), queueItemFilePathInArchiveFile, StandardCopyOption.REPLACE_EXISTING);
} catch (Exception e) {
logger.error("Błąd podczas przenoszenia pliku do archiwum: " + e.getMessage());
} finally {
if (archiveFileSystem != null) {
try {
archiveFileSystem.close();
} catch (IOException e) {
logger.error("Błąd podczas przenoszenia pliku do archiwum: " + e.getMessage());
}
}
}
// kasujemy plik
queueItemFile.delete();
}
}
}
/*
private void copyAndGzipFile(File source, File destination) throws IOException {
byte[] buffer = new byte[1024];
FileInputStream sourceInputStream = null;
GZIPOutputStream destinationOutputStream = null;
try {
sourceInputStream = new FileInputStream(source);
destinationOutputStream = new GZIPOutputStream(new FileOutputStream(destination));
int len;
while ((len = sourceInputStream.read(buffer)) > 0) {
destinationOutputStream.write(buffer, 0, len);
}
} finally {
if (sourceInputStream != null) {
sourceInputStream.close();
}
if (destinationOutputStream != null) {
destinationOutputStream.finish();
destinationOutputStream.close();
}
}
}
*/
public void deleteLocalDirArchiveOldQueueItems(final int olderThanDays) {
// pobieramy liste plikow do skasowania
File[] oldQueueItemsDirListFiles = localDirJobQueryArchiveDirFile.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.isFile() == true) {
return false;
}
if (pathname.isDirectory() == false) {
return false;
}
Date pathnameDate = null;
try {
pathnameDate = dateFormat.parse(pathname.getName());
} catch (ParseException e) { // zly format nazwy katalogu
return false;
}
// nazwa katalogu jest w odpowiednim formacie, wiec sprawdzamy liczbe dni
Calendar calendarNowMinusDays = Calendar.getInstance();
calendarNowMinusDays.add(Calendar.DAY_OF_YEAR, -olderThanDays);
if (calendarNowMinusDays.getTime().getTime() > pathnameDate.getTime()) { // kasujemy
return true;
} else {
return false;
}
}
});
// kasujemy pliki
for (File directoryToDelete : oldQueueItemsDirListFiles) {
logger.info("Kasuje katalog archiwum: " + directoryToDelete.getName());
// najpierw kasujemy pliki z tego katalogu
File[] directoryToDeleteListFiles = directoryToDelete.listFiles();
for (File fileToDelete : directoryToDeleteListFiles) {
fileToDelete.delete();
}
// a pozniej sam katalog (powinien byc) pusty
directoryToDelete.delete();
}
}
//
/*
public static void main(String[] args) {
org.apache.log4j.BasicConfigurator.configure();
QueueService queueService = new QueueService();
queueService.localDirJobQueueDir = "/opt/apache-tomcat-8.0.8/local-job-queue";
queueService.init();
queueService.deleteLocalDirArchiveOldQueueItems(10);
}
*/
}
| // przenosimy plik do wspolnego archiwum | package pl.idedyk.japanese.dictionary.web.queue;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.URI;
import java.net.UnknownHostException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import jakarta.annotation.PostConstruct;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import pl.idedyk.japanese.dictionary.web.mysql.MySQLConnector;
import pl.idedyk.japanese.dictionary.web.mysql.model.QueueItem;
import pl.idedyk.japanese.dictionary.web.mysql.model.QueueItemStatus;
@Service
public class QueueService {
private static final Logger logger = LogManager.getLogger(QueueService.class);
@Autowired
private MySQLConnector mySQLConnector;
@Value("${local.dir.job.queue}")
private String localDirJobQueueDir;
private File localDirJobQueueDirFile;
private File localDirJobQueryArchiveDirFile;
//
private final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
@PostConstruct
public void init() {
logger.info("Inicjalizowanie QueueService");
localDirJobQueueDirFile = new File(localDirJobQueueDir);
if (localDirJobQueueDirFile.exists() == false) {
logger.info("Tworzę katalog " + localDirJobQueueDir + " do ewentualnej lokalnej kolejki");
localDirJobQueueDirFile.mkdirs();
}
if (localDirJobQueueDirFile.exists() == false || localDirJobQueueDirFile.canWrite() == false) {
logger.error("Nie mogę zainicjalizować katalogu " + localDirJobQueueDir + " do ewentualnej lokalnej kolejki");
throw new RuntimeException();
}
//
localDirJobQueryArchiveDirFile = new File(localDirJobQueueDirFile, "archive");
if (localDirJobQueryArchiveDirFile.exists() == false) {
logger.info("Tworzę katalog " + localDirJobQueryArchiveDirFile.getPath() + " do archiwum lokalnej kolejki");
localDirJobQueryArchiveDirFile.mkdirs();
}
if (localDirJobQueryArchiveDirFile.exists() == false || localDirJobQueryArchiveDirFile.canWrite() == false) {
logger.error("Nie mogę zainicjalizować katalogu " + localDirJobQueryArchiveDirFile.getPath() + " do archiwum lokalnej kolejki");
throw new RuntimeException();
}
}
public void sendToQueue(String queueName, byte[] object) throws SQLException {
// stworzenie nowego elementu do kolejki
QueueItem queueItem = new QueueItem();
queueItem.setName(queueName);
queueItem.setStatus(QueueItemStatus.WAITING);
queueItem.setHostName(getHostName());
queueItem.setSendTimestamp(new Timestamp(new Date().getTime()));
queueItem.setDeliveryCount(0);
queueItem.setNextAttempt(queueItem.getSendTimestamp());
queueItem.setObject(object);
// zapisanie do lokalnego katalogu z kolejka
saveToLocalDir(queueItem);
/*
try {
// wstawienie do kolejki
mySQLConnector.insertQueueItem(queueItem);
} catch (SQLException e) {
throw e;
}
*/
}
private String getHostName() {
try {
return InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException e) {
return "localhost";
}
}
private void saveToLocalDir(QueueItem queueItem) {
// logger.info("Zapisanie do lokalnego katalogu kolejki");
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String dateString = sdf.format(queueItem.getSendTimestamp());
String randomFileName = UUID.randomUUID().toString();
File queueItemFileBody = new File(localDirJobQueueDirFile, queueItem.getName() + "_" + dateString + "_" + randomFileName);
File queueItemBodyReady = new File(localDirJobQueueDirFile, queueItem.getName() + "_" + dateString + "_" + randomFileName + ".ready");
ByteArrayOutputStream bos = null;
ObjectOutput objectOutput = null;
FileOutputStream fos = null;
try {
// serializacja obiektu
bos = new ByteArrayOutputStream();
objectOutput = new ObjectOutputStream(bos);
objectOutput.writeObject(queueItem);
objectOutput.close();
bos.close();
byte[] queueItemByteArray = bos.toByteArray();
fos = new FileOutputStream(queueItemFileBody);
fos.write(queueItemByteArray);
queueItemBodyReady.createNewFile();
} catch (IOException e) {
logger.error("Błąd zapisu do lokalnego katalogu kolejki", e);
} finally {
if (fos != null) {
try {
fos.close();
} catch (Exception e) {
// noop
}
}
}
}
public List<QueueItem> getNextItemQueueItem(String queueName) throws SQLException {
List<QueueItem> result = mySQLConnector.getNextQueueItem(queueName, getHostName());
if (result != null) {
for (QueueItem queueItem : result) {
// zachowanie zgodnosci
if (queueItem.getHostName() == null) {
queueItem.setHostName(getHostName());
}
}
}
return result;
}
public void setQueueItemDone(QueueItem queueItem) throws SQLException {
queueItem.setStatus(QueueItemStatus.DONE);
// uaktualnie wpisu
mySQLConnector.updateQueueItem(queueItem);
}
public void setQueueItemError(QueueItem queueItem) throws SQLException {
queueItem.setStatus(QueueItemStatus.ERROR);
// uaktualnie wpisu
mySQLConnector.updateQueueItem(queueItem);
}
public void delayQueueItem(QueueItem queueItem) throws SQLException {
int deliveryCount = queueItem.getDeliveryCount() + 1;
Timestamp nextAttempt = queueItem.getNextAttempt();
Calendar calendar = Calendar.getInstance();
calendar.setTime(nextAttempt);
calendar.add(Calendar.SECOND, 10 * deliveryCount * 2);
nextAttempt = new Timestamp(calendar.getTime().getTime());
queueItem.setDeliveryCount(deliveryCount);
queueItem.setNextAttempt(nextAttempt);
// uaktualnie wpisu
mySQLConnector.updateQueueItem(queueItem);
}
public void processLocalDirQueueItems() {
// proba znalezienia plikow z lokalnego katalogu kolejki
File[] queueItemsFileReadyList = localDirJobQueueDirFile.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.isFile() == false) {
return false;
}
String fileName = pathname.getName();
if (fileName.endsWith(".ready") == true) {
return true;
}
return false;
}
});
Arrays.sort(queueItemsFileReadyList, new Comparator<File>() {
@Override
public int compare(File f1, File f2) {
if (f1.lastModified() < f2.lastModified()) {
return -1;
} else if (f1.lastModified() > f2.lastModified()) {
return 1;
} else {
return 0;
}
}
});
if (queueItemsFileReadyList != null && queueItemsFileReadyList.length > 0) {
// logger.info("Znaleziono pliki z lokalnej kolejki");
for (File currentReadyQueueItemFile : queueItemsFileReadyList) {
File queueItemFile = new File(currentReadyQueueItemFile.getParent(), currentReadyQueueItemFile.getName().substring(0, currentReadyQueueItemFile.getName().length() - ".ready".length()));
// logger.info("Przetwarzam plik " + queueItemFile.getName());
ObjectInputStream ois = null;
QueueItem queueItem = null;
try {
ois = new ObjectInputStream(new FileInputStream(queueItemFile));
queueItem = (QueueItem)ois.readObject();
} catch (Exception e) {
logger.error("Błąd podczas odczytywania pliku z lokalnej kolejki: " + queueItemFile.getName(), e);
continue;
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
// noop
}
}
}
// zachowanie zgodnosci
if (queueItem.getHostName() == null) {
queueItem.setHostName(getHostName());
}
try {
// proba wstawienia do bazy danych
mySQLConnector.insertQueueItem(queueItem);
} catch (SQLException e) {
logger.error("Błąd wstawienia do bazy danych z lokalnej kolejki: " + e.getMessage());
continue;
}
// udalo sie, kasujemy plik ready
currentReadyQueueItemFile.delete();
// przenosimy plik do archiwum
// sprawdzenie i ewentualne utworzenie katalogu z data
File localDirJobQueryArchiveDirWithDateFile = new File(localDirJobQueryArchiveDirFile, dateFormat.format(queueItem.getSendTimestamp()));
if (localDirJobQueryArchiveDirWithDateFile.exists() == false && localDirJobQueryArchiveDirWithDateFile.isDirectory() == false) { // tworzymy katalog
localDirJobQueryArchiveDirWithDateFile.mkdir();
}
// przenosimy plik <SUF>
FileSystem archiveFileSystem = null;
try {
// utworzenie nazwy pliku z archiwum
Calendar querySendTimestampCalendar = Calendar.getInstance();
querySendTimestampCalendar.setTime(queueItem.getSendTimestamp());
int sendTimestampHourOfDay = querySendTimestampCalendar.get(Calendar.HOUR_OF_DAY);
String archivePartFileName = dateFormat.format(querySendTimestampCalendar.getTime()) + "_" + (sendTimestampHourOfDay < 10 ? "0" + sendTimestampHourOfDay : sendTimestampHourOfDay)
+ "_" + (querySendTimestampCalendar.get(Calendar.MINUTE) / 10) + "0";
//
File archiveFile = new File(localDirJobQueryArchiveDirWithDateFile, archivePartFileName + ".zip");
URI archiveFileUri = URI.create("jar:file:" + archiveFile.getAbsolutePath());
// utworzenie archiwum
Map<String, String> archiveEnv = new HashMap<>();
archiveEnv.put("create", String.valueOf(archiveFile.exists() == false));
archiveFileSystem = FileSystems.newFileSystem(archiveFileUri, archiveEnv);
// przenoszenie pliku do archiwum
Path queueItemFilePathInArchiveFile = archiveFileSystem.getPath(queueItemFile.getName());
Files.copy(queueItemFile.toPath(), queueItemFilePathInArchiveFile, StandardCopyOption.REPLACE_EXISTING);
} catch (Exception e) {
logger.error("Błąd podczas przenoszenia pliku do archiwum: " + e.getMessage());
} finally {
if (archiveFileSystem != null) {
try {
archiveFileSystem.close();
} catch (IOException e) {
logger.error("Błąd podczas przenoszenia pliku do archiwum: " + e.getMessage());
}
}
}
// kasujemy plik
queueItemFile.delete();
}
}
}
/*
private void copyAndGzipFile(File source, File destination) throws IOException {
byte[] buffer = new byte[1024];
FileInputStream sourceInputStream = null;
GZIPOutputStream destinationOutputStream = null;
try {
sourceInputStream = new FileInputStream(source);
destinationOutputStream = new GZIPOutputStream(new FileOutputStream(destination));
int len;
while ((len = sourceInputStream.read(buffer)) > 0) {
destinationOutputStream.write(buffer, 0, len);
}
} finally {
if (sourceInputStream != null) {
sourceInputStream.close();
}
if (destinationOutputStream != null) {
destinationOutputStream.finish();
destinationOutputStream.close();
}
}
}
*/
public void deleteLocalDirArchiveOldQueueItems(final int olderThanDays) {
// pobieramy liste plikow do skasowania
File[] oldQueueItemsDirListFiles = localDirJobQueryArchiveDirFile.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.isFile() == true) {
return false;
}
if (pathname.isDirectory() == false) {
return false;
}
Date pathnameDate = null;
try {
pathnameDate = dateFormat.parse(pathname.getName());
} catch (ParseException e) { // zly format nazwy katalogu
return false;
}
// nazwa katalogu jest w odpowiednim formacie, wiec sprawdzamy liczbe dni
Calendar calendarNowMinusDays = Calendar.getInstance();
calendarNowMinusDays.add(Calendar.DAY_OF_YEAR, -olderThanDays);
if (calendarNowMinusDays.getTime().getTime() > pathnameDate.getTime()) { // kasujemy
return true;
} else {
return false;
}
}
});
// kasujemy pliki
for (File directoryToDelete : oldQueueItemsDirListFiles) {
logger.info("Kasuje katalog archiwum: " + directoryToDelete.getName());
// najpierw kasujemy pliki z tego katalogu
File[] directoryToDeleteListFiles = directoryToDelete.listFiles();
for (File fileToDelete : directoryToDeleteListFiles) {
fileToDelete.delete();
}
// a pozniej sam katalog (powinien byc) pusty
directoryToDelete.delete();
}
}
//
/*
public static void main(String[] args) {
org.apache.log4j.BasicConfigurator.configure();
QueueService queueService = new QueueService();
queueService.localDirJobQueueDir = "/opt/apache-tomcat-8.0.8/local-job-queue";
queueService.init();
queueService.deleteLocalDirArchiveOldQueueItems(10);
}
*/
}
| f | null |
404 | 9965_0 | deeckowy/II-UWr | 517 | ProgramowanieObiektowe/project/Entity/Enemy.java | /**
* Klasa reprezentująca przeciwnika, dzidziczy po klasie Entity.
* Metoda attack odpowiada za atak na graczu i wypisanie komunikatu na
* liscie zdarzen w gui.
* Metoda isdead zwraca wartość prawda/fałsz w zależności od zdrowia przeciwnika.
*/
package Entity;
import java.io.IOException;
import java.nio.file.Path;
import org.jsfml.graphics.Sprite;
import org.jsfml.graphics.Texture;
import Gui.Gui;
import Consts.Consts;
public class Enemy extends Entity
{
private static Texture look;
static
{
look = new Texture();
try {
look.loadFromFile(Path.of("src/enemy.png"));
} catch (IOException e) {
e.printStackTrace();
}
}
private Hero player;
private Gui ge;
public Enemy(Hero p,Gui g)
{
this.player=p;
this.lvl=rng.nextInt(this.player.getlvl()*2)+1;
this.strength=rng.nextInt(this.lvl)*100/50;
this.hp=1+rng.nextInt(this.lvl)*100/50;
this.dexterity=1+rng.nextInt(this.lvl)*100/50;
this.defence=rng.nextInt(this.lvl)*100/50;
this.ge=g;
this.slook=new Sprite(look);
this.slook.setScale(Consts.graphicscale,Consts.graphicscale);
}
public void attack(){this.ge.addmsg("Enemy deals you " +this.player.hit(this.strength)+" dmg");}
public boolean isdead(){return !(this.hp>0);}
} | /**
* Klasa reprezentująca przeciwnika, dzidziczy po klasie Entity.
* Metoda attack odpowiada za atak na graczu i wypisanie komunikatu na
* liscie zdarzen w gui.
* Metoda isdead zwraca wartość prawda/fałsz w zależności od zdrowia przeciwnika.
*/ | /**
* Klasa reprezentująca przeciwnika, <SUF>*/
package Entity;
import java.io.IOException;
import java.nio.file.Path;
import org.jsfml.graphics.Sprite;
import org.jsfml.graphics.Texture;
import Gui.Gui;
import Consts.Consts;
public class Enemy extends Entity
{
private static Texture look;
static
{
look = new Texture();
try {
look.loadFromFile(Path.of("src/enemy.png"));
} catch (IOException e) {
e.printStackTrace();
}
}
private Hero player;
private Gui ge;
public Enemy(Hero p,Gui g)
{
this.player=p;
this.lvl=rng.nextInt(this.player.getlvl()*2)+1;
this.strength=rng.nextInt(this.lvl)*100/50;
this.hp=1+rng.nextInt(this.lvl)*100/50;
this.dexterity=1+rng.nextInt(this.lvl)*100/50;
this.defence=rng.nextInt(this.lvl)*100/50;
this.ge=g;
this.slook=new Sprite(look);
this.slook.setScale(Consts.graphicscale,Consts.graphicscale);
}
public void attack(){this.ge.addmsg("Enemy deals you " +this.player.hit(this.strength)+" dmg");}
public boolean isdead(){return !(this.hp>0);}
} | f | null |
405 | 10096_24 | dehydrogenaza/design-patterns-examples | 1,494 | src/main/java/mediator/mediator/WorkplaceMediator.java | package mediator.mediator;
import mediator.employees.EmployeeBase;
import mediator.employees.CEO;
import java.util.List;
//Mediator to wzorzec, który upraszcza *dwustronną komunikację* między siecią obiektów. Przez "komunikację" można
// rozumieć dowolne przesyłanie danych czy wywoływanie metod. Poszczególne klasy, zamiast bezpośrednio "rozmawiać" ze
// sobą, komunikują się z mediatorem, który przekazuje ich żądania dalej. Znacznie ułatwia to późniejsze modyfikacje
// takiej sieci.
//
//W poniższym przykładzie tworzymy mediator "firmy", w której mogą być CEO, Accountant, HR i Programmer. Każdy z nich
// może wysyłać "wiadomości" (mogłyby to być w rzeczywistości dowolne wywołania metod) do reszty zespołu albo tylko
// do CEO. To mediator zadecyduje, komu i w jaki sposób przekazać te wiadomości.
public class WorkplaceMediator implements IMediator {
//Lista wszystkich pracowników. Wszystkie grupy dziedziczą po EmployeeBase, więc mogę je zmieścić do jednej
// kolekcji, ale wcale nie jest to takie częste w tym wzorcu. Często mediatora wykorzystuje się do skomunikowania
// różnych podsystemów programu (bardzo często są to np. różne elementy interfejsu graficznego), niektóre mogą
// nawet być Singletonami.
private final List<EmployeeBase> employees;
//Kluczem w tym wzorcu jest to, by mediator miał odniesienie do wszystkich "celów" (tutaj: listy pracowników), a
// poszczególne "cele" (pracownicy) mieli odniesienie do mediatora.
//W konstruktorze rejestruję mediatora ('this') u każdego pracownika. Jest to po prostu setter, ale mógłby np.
// być "setter jednorazowy" ze sprawdzeniem, czy inny mediator nie został już zarejestrowany.
public WorkplaceMediator(List<EmployeeBase> employees) {
this.employees = employees;
for (EmployeeBase employee : employees) {
employee.registerMediator(this);
}
}
//Każdy pracownik może wywołać tę metodę dzięki swojemu odniesieniu do mediatora.
//W odpowiedzi mediator wywoła pewną metodę na wszystkich pracownikach — tu w przykładzie wybierze inną metodę,
// jeśli nadawcą był CEO, a inną w pozostałych przypadkach. Typowo na tym etapie parametr "nadawca" (sender)
// decyduje o tym, jakie metody i na czym wywołać.
@Override
public void sendToAll(EmployeeBase sender, String request) {
boolean fromBoss = sender.getClass() == CEO.class;
for (EmployeeBase employee : employees) {
if (fromBoss) {
employee.receiveCriticalRequest(request);
} else {
employee.receiveRequest(request);
}
}
}
//Mediator rzadko przesyła wiadomości do WSZYSTKICH odbiorców — jednym z celów tego wzorca jest właśnie
// uporządkowanie komunikacji, tak by klasy nie musiały obsługiwać "nieistotnych" dla nich żądań.
// W tej metodzie wywoływani są tylko pracownicy INNI niż nadawca.
@Override
public void sendToOthers(EmployeeBase sender, String request) {
for (EmployeeBase employee : employees) {
if (employee == sender) continue;
employee.receiveRequest(request);
}
}
//Z kolei w tej metodzie wywoływani są tylko CEO.
@Override
public void sendToCEO(EmployeeBase sender, String request) {
for (EmployeeBase employee : employees) {
if (employee.getClass() == CEO.class) {
employee.receiveRequest(request);
}
}
}
//Nie ma przeszkód, by mediator zawierał też metody przeznaczone do wykorzystania "z zewnątrz", spoza
// zarejestrowanych "użytkowników" mediatora — choć nie jest to stały element samego wzorca.
//Tutaj każda klasa może wywołać .CEOBoast(), a mediator wyszuka CEO i wywoła jego unikalną metodę .boast().
@Override
public void CEOBoast() {
for (EmployeeBase employee : employees) {
if (employee.getClass() == CEO.class) {
//Hard-cast do CEO, ponieważ 'employee' jest typu 'EmployeeBase',
// a 'EmployeeBase' nie ma potrzebnej metody .boast().
//Oczywiście to nie jest konieczna część wzorca — jak pisałem na początku, bardzo często mediator
// będzie trzymał referencje do konkretnych, określonych obiektów.
((CEO) employee).boast();
}
}
System.out.println("Wszyscy: xD");
}
}
| //Tutaj każda klasa może wywołać .CEOBoast(), a mediator wyszuka CEO i wywoła jego unikalną metodę .boast(). | package mediator.mediator;
import mediator.employees.EmployeeBase;
import mediator.employees.CEO;
import java.util.List;
//Mediator to wzorzec, który upraszcza *dwustronną komunikację* między siecią obiektów. Przez "komunikację" można
// rozumieć dowolne przesyłanie danych czy wywoływanie metod. Poszczególne klasy, zamiast bezpośrednio "rozmawiać" ze
// sobą, komunikują się z mediatorem, który przekazuje ich żądania dalej. Znacznie ułatwia to późniejsze modyfikacje
// takiej sieci.
//
//W poniższym przykładzie tworzymy mediator "firmy", w której mogą być CEO, Accountant, HR i Programmer. Każdy z nich
// może wysyłać "wiadomości" (mogłyby to być w rzeczywistości dowolne wywołania metod) do reszty zespołu albo tylko
// do CEO. To mediator zadecyduje, komu i w jaki sposób przekazać te wiadomości.
public class WorkplaceMediator implements IMediator {
//Lista wszystkich pracowników. Wszystkie grupy dziedziczą po EmployeeBase, więc mogę je zmieścić do jednej
// kolekcji, ale wcale nie jest to takie częste w tym wzorcu. Często mediatora wykorzystuje się do skomunikowania
// różnych podsystemów programu (bardzo często są to np. różne elementy interfejsu graficznego), niektóre mogą
// nawet być Singletonami.
private final List<EmployeeBase> employees;
//Kluczem w tym wzorcu jest to, by mediator miał odniesienie do wszystkich "celów" (tutaj: listy pracowników), a
// poszczególne "cele" (pracownicy) mieli odniesienie do mediatora.
//W konstruktorze rejestruję mediatora ('this') u każdego pracownika. Jest to po prostu setter, ale mógłby np.
// być "setter jednorazowy" ze sprawdzeniem, czy inny mediator nie został już zarejestrowany.
public WorkplaceMediator(List<EmployeeBase> employees) {
this.employees = employees;
for (EmployeeBase employee : employees) {
employee.registerMediator(this);
}
}
//Każdy pracownik może wywołać tę metodę dzięki swojemu odniesieniu do mediatora.
//W odpowiedzi mediator wywoła pewną metodę na wszystkich pracownikach — tu w przykładzie wybierze inną metodę,
// jeśli nadawcą był CEO, a inną w pozostałych przypadkach. Typowo na tym etapie parametr "nadawca" (sender)
// decyduje o tym, jakie metody i na czym wywołać.
@Override
public void sendToAll(EmployeeBase sender, String request) {
boolean fromBoss = sender.getClass() == CEO.class;
for (EmployeeBase employee : employees) {
if (fromBoss) {
employee.receiveCriticalRequest(request);
} else {
employee.receiveRequest(request);
}
}
}
//Mediator rzadko przesyła wiadomości do WSZYSTKICH odbiorców — jednym z celów tego wzorca jest właśnie
// uporządkowanie komunikacji, tak by klasy nie musiały obsługiwać "nieistotnych" dla nich żądań.
// W tej metodzie wywoływani są tylko pracownicy INNI niż nadawca.
@Override
public void sendToOthers(EmployeeBase sender, String request) {
for (EmployeeBase employee : employees) {
if (employee == sender) continue;
employee.receiveRequest(request);
}
}
//Z kolei w tej metodzie wywoływani są tylko CEO.
@Override
public void sendToCEO(EmployeeBase sender, String request) {
for (EmployeeBase employee : employees) {
if (employee.getClass() == CEO.class) {
employee.receiveRequest(request);
}
}
}
//Nie ma przeszkód, by mediator zawierał też metody przeznaczone do wykorzystania "z zewnątrz", spoza
// zarejestrowanych "użytkowników" mediatora — choć nie jest to stały element samego wzorca.
//Tutaj każda <SUF>
@Override
public void CEOBoast() {
for (EmployeeBase employee : employees) {
if (employee.getClass() == CEO.class) {
//Hard-cast do CEO, ponieważ 'employee' jest typu 'EmployeeBase',
// a 'EmployeeBase' nie ma potrzebnej metody .boast().
//Oczywiście to nie jest konieczna część wzorca — jak pisałem na początku, bardzo często mediator
// będzie trzymał referencje do konkretnych, określonych obiektów.
((CEO) employee).boast();
}
}
System.out.println("Wszyscy: xD");
}
}
| f | null |
406 | 9854_3 | delekta/agh-po | 667 | lab7/MapBoundary.java | package agh.cs.lab7;
import agh.cs.lab2.Vector2d;
import agh.cs.lab3.Animal;
import java.util.Comparator;
import java.util.SortedSet;
import java.util.TreeSet;
public class MapBoundary implements IPositionChangeObserver{
private Comparator yComparator = new YComparator();
private Comparator xComparator = new XComparator();
private SortedSet<IMapElement> ySorted = new TreeSet<>(yComparator);
private SortedSet<IMapElement> xSorted = new TreeSet<>(xComparator);
public void addXSorted(IMapElement element){
xSorted.add(element);
}
public void addYSorted(IMapElement element){
ySorted.add(element);
}
//Getters
public Comparator getYComparator() {
return yComparator;
}
public Comparator getXComparator() {
return xComparator;
}
public SortedSet<IMapElement> getYSorted() {
return ySorted;
}
public SortedSet<IMapElement> getXSorted() {
return xSorted;
}
// Added during lab7
// [aphollo github] 6. W przypadku aktualizacji pozycji obiektu, należy sprawdzić,
// czy należy zaktualizować odpowiedni indeksi zrobić to, tylko jeśli jest to konieczne.
// Rozumiem ze aktualizujemy gdy zmieniany element jest większy niż aktualnie największy element
// My PositionChanged
public void updateSortedElements(Vector2d oldPosition, Vector2d newPosition, IMapElement element){
if(isGreaterThanLast(xComparator, xSorted, element)){
addXSorted(element);
}if(isGreaterThanLast(yComparator, ySorted, element)){
addYSorted(element);
}
}
// Added during lab7
// If added element or updated element is greater than last in sortedSet => update sortedSet
private boolean isGreaterThanLast(Comparator comparator, SortedSet sortedSet, IMapElement element){
if(comparator.compare(element, sortedSet.last()) > 0){
return true;
}
else{
return false;
}
}
@Override
public void positionChanged(Vector2d oldPosition, Vector2d newPosition) {
}
}
| // Rozumiem ze aktualizujemy gdy zmieniany element jest większy niż aktualnie największy element | package agh.cs.lab7;
import agh.cs.lab2.Vector2d;
import agh.cs.lab3.Animal;
import java.util.Comparator;
import java.util.SortedSet;
import java.util.TreeSet;
public class MapBoundary implements IPositionChangeObserver{
private Comparator yComparator = new YComparator();
private Comparator xComparator = new XComparator();
private SortedSet<IMapElement> ySorted = new TreeSet<>(yComparator);
private SortedSet<IMapElement> xSorted = new TreeSet<>(xComparator);
public void addXSorted(IMapElement element){
xSorted.add(element);
}
public void addYSorted(IMapElement element){
ySorted.add(element);
}
//Getters
public Comparator getYComparator() {
return yComparator;
}
public Comparator getXComparator() {
return xComparator;
}
public SortedSet<IMapElement> getYSorted() {
return ySorted;
}
public SortedSet<IMapElement> getXSorted() {
return xSorted;
}
// Added during lab7
// [aphollo github] 6. W przypadku aktualizacji pozycji obiektu, należy sprawdzić,
// czy należy zaktualizować odpowiedni indeksi zrobić to, tylko jeśli jest to konieczne.
// Rozumiem ze <SUF>
// My PositionChanged
public void updateSortedElements(Vector2d oldPosition, Vector2d newPosition, IMapElement element){
if(isGreaterThanLast(xComparator, xSorted, element)){
addXSorted(element);
}if(isGreaterThanLast(yComparator, ySorted, element)){
addYSorted(element);
}
}
// Added during lab7
// If added element or updated element is greater than last in sortedSet => update sortedSet
private boolean isGreaterThanLast(Comparator comparator, SortedSet sortedSet, IMapElement element){
if(comparator.compare(element, sortedSet.last()) > 0){
return true;
}
else{
return false;
}
}
@Override
public void positionChanged(Vector2d oldPosition, Vector2d newPosition) {
}
}
| f | null |
407 | 5196_9 | demsey15/SZI | 4,474 | src/main/java/bohonos/demski/gorska/limiszewska/mieldzioc/logicalLayer/geneticAlgorithm/PathFinder.java | package bohonos.demski.gorska.limiszewska.mieldzioc.logicalLayer.geneticAlgorithm;
import bohonos.demski.gorska.limiszewska.mieldzioc.logicalLayer.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Created by Dominik on 2015-06-05.
*/
public class PathFinder implements IWalker{
private FindProperOrder properOrderFinder = new FindProperOrder();
private Monitor monitor = Monitor.getInstance();
private Control control = Control.getInstance();
public void goThroughTables(List<Integer> tablesToGoThrow){
List<Integer> tablesToGo = new ArrayList<Integer>();
for(Integer i : tablesToGoThrow){
if(!tablesToGo.contains(i)) tablesToGo.add(i);
}
System.out.println("Wywołano algorytm dominika z listą stołów: " + Arrays.toString(tablesToGo.toArray()));
List<Integer> properOrderTabels = properOrderFinder.findProperOrder(tablesToGo);
Coordinates currentPosition = new Coordinates(0, 0); //zaczynamy od współrzędnych (0, 0)
for(int i = 0; i < properOrderTabels.size() + 1; i++){ //+1 bo jeszcze powrot do (0,0)
Coordinates cornerToGo;
if(i < properOrderTabels.size()) {
Coordinates tableToGo = control.getCoordinatesForTableNumber(properOrderTabels.get(i));
cornerToGo = getTheClosestCorner(tableToGo, currentPosition);
}
else{
cornerToGo = new Coordinates(0, 0);
}
List<Coordinates> path = new ArrayList<Coordinates>();
while(!(currentPosition.getRow() == cornerToGo.getRow() && //jesli nie jestesmy jeszcze na miejscu
currentPosition.getColumn() == cornerToGo.getColumn())) {
boolean wasStep = false;
if (currentPosition.getRow() != cornerToGo.getRow()) { //jesli jestesmy na zlej wysokosci
Coordinates toGo;
if (currentPosition.getRow() > cornerToGo.getRow()) { //jesli powinnismy isc w gore
toGo = new Coordinates(currentPosition.getRow() - 1, currentPosition.getColumn()); //spróbuj iść w górę
} else { //jesli powinnismy isc w dol
toGo = new Coordinates(currentPosition.getRow() + 1, currentPosition.getColumn()); //spróbuj iść w dół
}
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasStep = true;
}
}
if(!wasStep && currentPosition.getColumn() != cornerToGo.getColumn()){ //nie bylo ruchu i jestesmy na zlej pozycji w poziomie
Coordinates toGo;
if (currentPosition.getColumn() > cornerToGo.getColumn()) { //nalezy isc w lewo
toGo = new Coordinates(currentPosition.getRow(), currentPosition.getColumn() - 1); //spróbuj iść w lewo
} else {
toGo = new Coordinates(currentPosition.getRow(), currentPosition.getColumn() + 1); //spróbuj iść w prawo
}
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasStep = true;
}
}
if(!wasStep) { //standardowy ruch sie nie udal - wykonaj ruch awaryjny - po skosie
boolean wasHelpingMove = false;
if (currentPosition.getColumn() > cornerToGo.getColumn()) { //należy poruszać się w lewo
if(currentPosition.getRow() > cornerToGo.getRow()){ //należy poruszać się górę
Coordinates toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dół i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{ //należy poruszac sie w gore i w lewo
toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else if(currentPosition.getRow() < cornerToGo.getRow()){ //należy poruszać się w dół i w lewo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w górę i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dół i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else{ //tylko w lewo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w górę i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dol i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
}
else if(currentPosition.getColumn() < cornerToGo.getColumn()){ //należy poruszać się w prawo
if(currentPosition.getRow() > cornerToGo.getRow()){ //należy poruszać się górę
Coordinates toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dół i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{
toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w górę i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else if(currentPosition.getRow() < cornerToGo.getRow()){ //należy poruszać się w dół i w prawo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dół i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else{ //tylko w prawo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dol i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
}
else{ //nalezy poruszac sie tylko w gore / dol
if(currentPosition.getRow() > cornerToGo.getRow()){ //nalezy isc tylko w gore
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w gore i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else{ //nalezy isc tylko w dol
Coordinates toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dol i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dol i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
}
if(!wasHelpingMove){
System.out.println("Nie mogę znaleźć ścieżki!");
break;
}
}
/* //Wypisywanie z opoznieniem sciezki ktora znajduje
System.out.print(currentPosition + ", ");
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
*/
}
if(i < properOrderTabels.size())
System.out.println("Idę do stolika nr: " + properOrderTabels.get(i));
else System.out.println("Wracam do (0, 0)");
System.out.println("Sciezka: " + Arrays.toString(path.toArray()));
monitor.callListenersOnMove(path);
try {
Thread.sleep(3000);
try {
if(i < properOrderTabels.size())
OrdersService.getInstance().removeMealForTableFromTray(properOrderTabels.get(i)); //zdejmij dostarczone potrawy z listy potraw na tacy kelnera
} catch (IOException e) {
e.printStackTrace();
}
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private Coordinates getTheClosestCorner(Coordinates tableCoordinates, Coordinates currentPosition){
Coordinates leftUp = new Coordinates(tableCoordinates.getRow() - 1, tableCoordinates.getColumn() - 1);
Coordinates leftDown = new Coordinates(tableCoordinates.getRow() + 1, tableCoordinates.getColumn() - 1);
Coordinates rightUp = new Coordinates(tableCoordinates.getRow() + 1, tableCoordinates.getColumn() + 1);
Coordinates rightDown = new Coordinates(tableCoordinates.getRow() - 1, tableCoordinates.getColumn() + 1);
List<Coordinates> correctCoordinates = new ArrayList<Coordinates>(4);
if(Map.checkIfCoordinatesAreInMap(leftUp)) correctCoordinates.add(leftUp);
if(Map.checkIfCoordinatesAreInMap(leftDown)) correctCoordinates.add(leftDown);
if(Map.checkIfCoordinatesAreInMap(rightUp)) correctCoordinates.add(rightUp);
if(Map.checkIfCoordinatesAreInMap(rightDown)) correctCoordinates.add(rightDown);
if(correctCoordinates.size() > 0){
Coordinates theBest = correctCoordinates.get(0);
int bestDistance;
for(int i = 1; i < correctCoordinates.size(); i++){
bestDistance = getDistanceBetweenCoordinates(theBest, currentPosition);
Coordinates coord = correctCoordinates.get(i);
int distance = getDistanceBetweenCoordinates(coord, currentPosition);
if(distance < bestDistance) theBest = coord;
}
return theBest;
}
else return null;
}
private int getDistanceBetweenCoordinates(Coordinates coordinates1, Coordinates coordinates2){
return Math.abs(coordinates1.getColumn() - coordinates2.getColumn()) + Math.abs(coordinates1.getRow()
- coordinates2.getRow());
}
public static void main(String[] args) {
Control control = Control.getInstance();
try {
control.prepareMap();
PathFinder f = new PathFinder();
f.goThroughTables(Arrays.asList(new Integer[]{1, 2, 3}));
} catch (IOException e) {
e.printStackTrace();
}
}
}
| //nie bylo ruchu i jestesmy na zlej pozycji w poziomie | package bohonos.demski.gorska.limiszewska.mieldzioc.logicalLayer.geneticAlgorithm;
import bohonos.demski.gorska.limiszewska.mieldzioc.logicalLayer.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Created by Dominik on 2015-06-05.
*/
public class PathFinder implements IWalker{
private FindProperOrder properOrderFinder = new FindProperOrder();
private Monitor monitor = Monitor.getInstance();
private Control control = Control.getInstance();
public void goThroughTables(List<Integer> tablesToGoThrow){
List<Integer> tablesToGo = new ArrayList<Integer>();
for(Integer i : tablesToGoThrow){
if(!tablesToGo.contains(i)) tablesToGo.add(i);
}
System.out.println("Wywołano algorytm dominika z listą stołów: " + Arrays.toString(tablesToGo.toArray()));
List<Integer> properOrderTabels = properOrderFinder.findProperOrder(tablesToGo);
Coordinates currentPosition = new Coordinates(0, 0); //zaczynamy od współrzędnych (0, 0)
for(int i = 0; i < properOrderTabels.size() + 1; i++){ //+1 bo jeszcze powrot do (0,0)
Coordinates cornerToGo;
if(i < properOrderTabels.size()) {
Coordinates tableToGo = control.getCoordinatesForTableNumber(properOrderTabels.get(i));
cornerToGo = getTheClosestCorner(tableToGo, currentPosition);
}
else{
cornerToGo = new Coordinates(0, 0);
}
List<Coordinates> path = new ArrayList<Coordinates>();
while(!(currentPosition.getRow() == cornerToGo.getRow() && //jesli nie jestesmy jeszcze na miejscu
currentPosition.getColumn() == cornerToGo.getColumn())) {
boolean wasStep = false;
if (currentPosition.getRow() != cornerToGo.getRow()) { //jesli jestesmy na zlej wysokosci
Coordinates toGo;
if (currentPosition.getRow() > cornerToGo.getRow()) { //jesli powinnismy isc w gore
toGo = new Coordinates(currentPosition.getRow() - 1, currentPosition.getColumn()); //spróbuj iść w górę
} else { //jesli powinnismy isc w dol
toGo = new Coordinates(currentPosition.getRow() + 1, currentPosition.getColumn()); //spróbuj iść w dół
}
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasStep = true;
}
}
if(!wasStep && currentPosition.getColumn() != cornerToGo.getColumn()){ //nie bylo <SUF>
Coordinates toGo;
if (currentPosition.getColumn() > cornerToGo.getColumn()) { //nalezy isc w lewo
toGo = new Coordinates(currentPosition.getRow(), currentPosition.getColumn() - 1); //spróbuj iść w lewo
} else {
toGo = new Coordinates(currentPosition.getRow(), currentPosition.getColumn() + 1); //spróbuj iść w prawo
}
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasStep = true;
}
}
if(!wasStep) { //standardowy ruch sie nie udal - wykonaj ruch awaryjny - po skosie
boolean wasHelpingMove = false;
if (currentPosition.getColumn() > cornerToGo.getColumn()) { //należy poruszać się w lewo
if(currentPosition.getRow() > cornerToGo.getRow()){ //należy poruszać się górę
Coordinates toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dół i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{ //należy poruszac sie w gore i w lewo
toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else if(currentPosition.getRow() < cornerToGo.getRow()){ //należy poruszać się w dół i w lewo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w górę i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dół i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else{ //tylko w lewo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w górę i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dol i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
}
else if(currentPosition.getColumn() < cornerToGo.getColumn()){ //należy poruszać się w prawo
if(currentPosition.getRow() > cornerToGo.getRow()){ //należy poruszać się górę
Coordinates toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dół i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{
toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w górę i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else if(currentPosition.getRow() < cornerToGo.getRow()){ //należy poruszać się w dół i w prawo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
else{
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dół i w lewo
if(Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD){
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else{ //tylko w prawo
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dol i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
}
else{ //nalezy poruszac sie tylko w gore / dol
if(currentPosition.getRow() > cornerToGo.getRow()){ //nalezy isc tylko w gore
Coordinates toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w górę i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() - 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w gore i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
else{ //nalezy isc tylko w dol
Coordinates toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() + 1); //spróbuj iść po skosie w dol i w prawo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
} else {
toGo = new Coordinates(currentPosition.getRow() + 1,
currentPosition.getColumn() - 1); //spróbuj iść po skosie w dol i w lewo
if (Map.checkIfCoordinatesAreInMap(toGo) && control.getObjectId(toGo) == Map.FREE_FIELD) {
path.add(toGo);
currentPosition = toGo;
wasHelpingMove = true;
}
}
}
}
if(!wasHelpingMove){
System.out.println("Nie mogę znaleźć ścieżki!");
break;
}
}
/* //Wypisywanie z opoznieniem sciezki ktora znajduje
System.out.print(currentPosition + ", ");
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
*/
}
if(i < properOrderTabels.size())
System.out.println("Idę do stolika nr: " + properOrderTabels.get(i));
else System.out.println("Wracam do (0, 0)");
System.out.println("Sciezka: " + Arrays.toString(path.toArray()));
monitor.callListenersOnMove(path);
try {
Thread.sleep(3000);
try {
if(i < properOrderTabels.size())
OrdersService.getInstance().removeMealForTableFromTray(properOrderTabels.get(i)); //zdejmij dostarczone potrawy z listy potraw na tacy kelnera
} catch (IOException e) {
e.printStackTrace();
}
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private Coordinates getTheClosestCorner(Coordinates tableCoordinates, Coordinates currentPosition){
Coordinates leftUp = new Coordinates(tableCoordinates.getRow() - 1, tableCoordinates.getColumn() - 1);
Coordinates leftDown = new Coordinates(tableCoordinates.getRow() + 1, tableCoordinates.getColumn() - 1);
Coordinates rightUp = new Coordinates(tableCoordinates.getRow() + 1, tableCoordinates.getColumn() + 1);
Coordinates rightDown = new Coordinates(tableCoordinates.getRow() - 1, tableCoordinates.getColumn() + 1);
List<Coordinates> correctCoordinates = new ArrayList<Coordinates>(4);
if(Map.checkIfCoordinatesAreInMap(leftUp)) correctCoordinates.add(leftUp);
if(Map.checkIfCoordinatesAreInMap(leftDown)) correctCoordinates.add(leftDown);
if(Map.checkIfCoordinatesAreInMap(rightUp)) correctCoordinates.add(rightUp);
if(Map.checkIfCoordinatesAreInMap(rightDown)) correctCoordinates.add(rightDown);
if(correctCoordinates.size() > 0){
Coordinates theBest = correctCoordinates.get(0);
int bestDistance;
for(int i = 1; i < correctCoordinates.size(); i++){
bestDistance = getDistanceBetweenCoordinates(theBest, currentPosition);
Coordinates coord = correctCoordinates.get(i);
int distance = getDistanceBetweenCoordinates(coord, currentPosition);
if(distance < bestDistance) theBest = coord;
}
return theBest;
}
else return null;
}
private int getDistanceBetweenCoordinates(Coordinates coordinates1, Coordinates coordinates2){
return Math.abs(coordinates1.getColumn() - coordinates2.getColumn()) + Math.abs(coordinates1.getRow()
- coordinates2.getRow());
}
public static void main(String[] args) {
Control control = Control.getInstance();
try {
control.prepareMap();
PathFinder f = new PathFinder();
f.goThroughTables(Arrays.asList(new Integer[]{1, 2, 3}));
} catch (IOException e) {
e.printStackTrace();
}
}
}
| f | null |
409 | 10253_0 | dixu11/zaawansowane-programowanie-124 | 455 | src/main/java/obiektowe/proste/garage/Demo.java | package obiektowe.proste.garage;
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) {
Wheel wheel1 = new Wheel(2);
Wheel wheel2 = new Wheel(2);
Wheel wheel3 = new Wheel(2.2);
Wheel wheel4 = new Wheel(2.2);
List<Wheel> wheels = new ArrayList<>();
wheels.add(wheel1);
wheels.add(wheel2);
wheels.add(wheel3);
wheels.add(wheel4);
Car car = new Car(wheels);
System.out.println(car);
car.flatRandomTire();
System.out.println(car);
}
}
/*
* Przygotuj program w którym zasymulujesz sytuację w której kierowca samochodu łapie gumę w kole i
* zabiera go do warsztatu do naprawy.
w main przygotuj 4 obiekty kół, każde z nich ma mieć ustawione ciśnienie i ma nie być przebite
zbierz wszystkie koła do zbioru i przekaż do obiektu typu Samochod
zasymuluj zdarzenie, że samochód łapie gumę w losowym kole
obiekt typu Warsztat może przyjmować samochód do naprawy
naprawa polega na tym, że warsztat wyszukuje które koło z samochodu jest zepsute i poprawia jego stan
na koniec naprawy warsztat zwraca obiekt typu Paragon zawierający rodzaj usługi, ile razy była
* wykonana oraz łączną cenę
* */ | /*
* Przygotuj program w którym zasymulujesz sytuację w której kierowca samochodu łapie gumę w kole i
* zabiera go do warsztatu do naprawy.
w main przygotuj 4 obiekty kół, każde z nich ma mieć ustawione ciśnienie i ma nie być przebite
zbierz wszystkie koła do zbioru i przekaż do obiektu typu Samochod
zasymuluj zdarzenie, że samochód łapie gumę w losowym kole
obiekt typu Warsztat może przyjmować samochód do naprawy
naprawa polega na tym, że warsztat wyszukuje które koło z samochodu jest zepsute i poprawia jego stan
na koniec naprawy warsztat zwraca obiekt typu Paragon zawierający rodzaj usługi, ile razy była
* wykonana oraz łączną cenę
* */ | package obiektowe.proste.garage;
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) {
Wheel wheel1 = new Wheel(2);
Wheel wheel2 = new Wheel(2);
Wheel wheel3 = new Wheel(2.2);
Wheel wheel4 = new Wheel(2.2);
List<Wheel> wheels = new ArrayList<>();
wheels.add(wheel1);
wheels.add(wheel2);
wheels.add(wheel3);
wheels.add(wheel4);
Car car = new Car(wheels);
System.out.println(car);
car.flatRandomTire();
System.out.println(car);
}
}
/*
* Przygotuj program w <SUF>*/ | f | null |