proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
iluwatar_java-design-patterns
|
java-design-patterns/identity-map/src/main/java/com/iluwatar/identitymap/IdentityMap.java
|
IdentityMap
|
addPerson
|
class IdentityMap {
private Map<Integer, Person> personMap = new HashMap<>();
/**
* Add person to the map.
*/
public void addPerson(Person person) {<FILL_FUNCTION_BODY>}
/**
* Get Person with given id.
*
* @param id : personNationalId as requested by user.
*/
public Person getPerson(int id) {
Person person = personMap.get(id);
if (person == null) {
LOGGER.info("ID not in Map.");
return null;
}
LOGGER.info(person.toString());
return person;
}
/**
* Get the size of the map.
*/
public int size() {
if (personMap == null) {
return 0;
}
return personMap.size();
}
}
|
if (!personMap.containsKey(person.getPersonNationalId())) {
personMap.put(person.getPersonNationalId(), person);
} else { // Ensure that addPerson does not update a record. This situation will never arise in our implementation. Added only for testing purposes.
LOGGER.info("Key already in Map");
}
| 223
| 84
| 307
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/identity-map/src/main/java/com/iluwatar/identitymap/Person.java
|
Person
|
toString
|
class Person implements Serializable {
private static final long serialVersionUID = 1L;
@EqualsAndHashCode.Include
private int personNationalId;
private String name;
private long phoneNum;
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "Person ID is : " + personNationalId + " ; Person Name is : " + name + " ; Phone Number is :" + phoneNum;
| 81
| 40
| 121
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/identity-map/src/main/java/com/iluwatar/identitymap/PersonDbSimulatorImplementation.java
|
PersonDbSimulatorImplementation
|
find
|
class PersonDbSimulatorImplementation implements PersonDbSimulator {
//This simulates a table in the database. To extend logic to multiple tables just add more lists to the implementation.
private List<Person> personList = new ArrayList<>();
static final String NOT_IN_DATA_BASE = " not in DataBase";
static final String ID_STR = "ID : ";
@Override
public Person find(int personNationalId) throws IdNotFoundException {<FILL_FUNCTION_BODY>}
@Override
public void insert(Person person) {
Optional<Person> elem = personList.stream().filter(p -> p.getPersonNationalId() == person.getPersonNationalId()).findFirst();
if (elem.isPresent()) {
LOGGER.info("Record already exists.");
return;
}
personList.add(person);
}
@Override
public void update(Person person) throws IdNotFoundException {
Optional<Person> elem = personList.stream().filter(p -> p.getPersonNationalId() == person.getPersonNationalId()).findFirst();
if (elem.isPresent()) {
elem.get().setName(person.getName());
elem.get().setPhoneNum(person.getPhoneNum());
LOGGER.info("Record updated successfully");
return;
}
throw new IdNotFoundException(ID_STR + person.getPersonNationalId() + NOT_IN_DATA_BASE);
}
/**
* Delete the record corresponding to given ID from the DB.
*
* @param id : personNationalId for person whose record is to be deleted.
*/
public void delete(int id) throws IdNotFoundException {
Optional<Person> elem = personList.stream().filter(p -> p.getPersonNationalId() == id).findFirst();
if (elem.isPresent()) {
personList.remove(elem.get());
LOGGER.info("Record deleted successfully.");
return;
}
throw new IdNotFoundException(ID_STR + id + NOT_IN_DATA_BASE);
}
/**
* Return the size of the database.
*/
public int size() {
if (personList == null) {
return 0;
}
return personList.size();
}
}
|
Optional<Person> elem = personList.stream().filter(p -> p.getPersonNationalId() == personNationalId).findFirst();
if (elem.isEmpty()) {
throw new IdNotFoundException(ID_STR + personNationalId + NOT_IN_DATA_BASE);
}
LOGGER.info(elem.get().toString());
return elem.get();
| 563
| 92
| 655
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/identity-map/src/main/java/com/iluwatar/identitymap/PersonFinder.java
|
PersonFinder
|
getPerson
|
class PersonFinder {
private static final long serialVersionUID = 1L;
// Access to the Identity Map
private IdentityMap identityMap = new IdentityMap();
private PersonDbSimulatorImplementation db = new PersonDbSimulatorImplementation();
/**
* get person corresponding to input ID.
*
* @param key : personNationalId to look for.
*/
public Person getPerson(int key) {<FILL_FUNCTION_BODY>}
}
|
// Try to find person in the identity map
Person person = this.identityMap.getPerson(key);
if (person != null) {
LOGGER.info("Person found in the Map");
return person;
} else {
// Try to find person in the database
person = this.db.find(key);
if (person != null) {
this.identityMap.addPerson(person);
LOGGER.info("Person found in DB.");
return person;
}
LOGGER.info("Person with this ID does not exist.");
return null;
}
| 120
| 149
| 269
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/AbstractFilter.java
|
AbstractFilter
|
execute
|
class AbstractFilter implements Filter {
private Filter next;
public AbstractFilter() {
}
public AbstractFilter(Filter next) {
this.next = next;
}
@Override
public void setNext(Filter filter) {
this.next = filter;
}
@Override
public Filter getNext() {
return next;
}
@Override
public Filter getLast() {
Filter last = this;
while (last.getNext() != null) {
last = last.getNext();
}
return last;
}
@Override
public String execute(Order order) {<FILL_FUNCTION_BODY>}
}
|
if (getNext() != null) {
return getNext().execute(order);
} else {
return "";
}
| 178
| 37
| 215
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/AddressFilter.java
|
AddressFilter
|
execute
|
class AddressFilter extends AbstractFilter {
@Override
public String execute(Order order) {<FILL_FUNCTION_BODY>}
}
|
var result = super.execute(order);
if (order.getAddress() == null || order.getAddress().isEmpty()) {
return result + "Invalid address! ";
} else {
return result;
}
| 37
| 57
| 94
|
<methods>public void <init>() ,public void <init>(com.iluwatar.intercepting.filter.Filter) ,public java.lang.String execute(com.iluwatar.intercepting.filter.Order) ,public com.iluwatar.intercepting.filter.Filter getLast() ,public com.iluwatar.intercepting.filter.Filter getNext() ,public void setNext(com.iluwatar.intercepting.filter.Filter) <variables>private com.iluwatar.intercepting.filter.Filter next
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var filterManager = new FilterManager();
filterManager.addFilter(new NameFilter());
filterManager.addFilter(new ContactFilter());
filterManager.addFilter(new AddressFilter());
filterManager.addFilter(new DepositFilter());
filterManager.addFilter(new OrderFilter());
var client = new Client();
client.setFilterManager(filterManager);
| 56
| 95
| 151
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/Client.java
|
Client
|
actionPerformed
|
class Client extends JFrame { // NOSONAR
private static final long serialVersionUID = 1L;
private transient FilterManager filterManager;
private final JLabel jl;
private final JTextField[] jtFields;
private final JTextArea[] jtAreas;
private final JButton clearButton;
private final JButton processButton;
/**
* Constructor.
*/
public Client() {
super("Client System");
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setSize(300, 300);
jl = new JLabel("RUNNING...");
jtFields = new JTextField[3];
for (var i = 0; i < 3; i++) {
jtFields[i] = new JTextField();
}
jtAreas = new JTextArea[2];
for (var i = 0; i < 2; i++) {
jtAreas[i] = new JTextArea();
}
clearButton = new JButton("Clear");
processButton = new JButton("Process");
setup();
}
private void setup() {
setLayout(new BorderLayout());
var panel = new JPanel();
add(jl, BorderLayout.SOUTH);
add(panel, BorderLayout.CENTER);
panel.setLayout(new GridLayout(6, 2));
panel.add(new JLabel("Name"));
panel.add(jtFields[0]);
panel.add(new JLabel("Contact Number"));
panel.add(jtFields[1]);
panel.add(new JLabel("Address"));
panel.add(jtAreas[0]);
panel.add(new JLabel("Deposit Number"));
panel.add(jtFields[2]);
panel.add(new JLabel("Order"));
panel.add(jtAreas[1]);
panel.add(clearButton);
panel.add(processButton);
clearButton.addActionListener(e -> {
Arrays.stream(jtAreas).forEach(i -> i.setText(""));
Arrays.stream(jtFields).forEach(i -> i.setText(""));
});
processButton.addActionListener(this::actionPerformed);
JRootPane rootPane = SwingUtilities.getRootPane(processButton);
rootPane.setDefaultButton(processButton);
setVisible(true);
}
public void setFilterManager(FilterManager filterManager) {
this.filterManager = filterManager;
}
public String sendRequest(Order order) {
return filterManager.filterRequest(order);
}
private void actionPerformed(ActionEvent e) {<FILL_FUNCTION_BODY>}
}
|
var fieldText1 = jtFields[0].getText();
var fieldText2 = jtFields[1].getText();
var areaText1 = jtAreas[0].getText();
var fieldText3 = jtFields[2].getText();
var areaText2 = jtAreas[1].getText();
var order = new Order(fieldText1, fieldText2, areaText1, fieldText3, areaText2);
jl.setText(sendRequest(order));
| 703
| 120
| 823
|
<methods>public void <init>() throws java.awt.HeadlessException,public void <init>(java.awt.GraphicsConfiguration) ,public void <init>(java.lang.String) throws java.awt.HeadlessException,public void <init>(java.lang.String, java.awt.GraphicsConfiguration) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public java.awt.Container getContentPane() ,public int getDefaultCloseOperation() ,public java.awt.Component getGlassPane() ,public java.awt.Graphics getGraphics() ,public javax.swing.JMenuBar getJMenuBar() ,public javax.swing.JLayeredPane getLayeredPane() ,public javax.swing.JRootPane getRootPane() ,public javax.swing.TransferHandler getTransferHandler() ,public static boolean isDefaultLookAndFeelDecorated() ,public void remove(java.awt.Component) ,public void repaint(long, int, int, int, int) ,public void setContentPane(java.awt.Container) ,public void setDefaultCloseOperation(int) ,public static void setDefaultLookAndFeelDecorated(boolean) ,public void setGlassPane(java.awt.Component) ,public void setIconImage(java.awt.Image) ,public void setJMenuBar(javax.swing.JMenuBar) ,public void setLayeredPane(javax.swing.JLayeredPane) ,public void setLayout(java.awt.LayoutManager) ,public void setTransferHandler(javax.swing.TransferHandler) ,public void update(java.awt.Graphics) <variables>protected javax.accessibility.AccessibleContext accessibleContext,private int defaultCloseOperation,private static final java.lang.Object defaultLookAndFeelDecoratedKey,protected javax.swing.JRootPane rootPane,protected boolean rootPaneCheckingEnabled,private javax.swing.TransferHandler transferHandler
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/ContactFilter.java
|
ContactFilter
|
execute
|
class ContactFilter extends AbstractFilter {
@Override
public String execute(Order order) {<FILL_FUNCTION_BODY>}
}
|
var result = super.execute(order);
var contactNumber = order.getContactNumber();
if (contactNumber == null || contactNumber.isEmpty()
|| contactNumber.matches(".*[^\\d]+.*")
|| contactNumber.length() != 11) {
return result + "Invalid contact number! ";
} else {
return result;
}
| 37
| 96
| 133
|
<methods>public void <init>() ,public void <init>(com.iluwatar.intercepting.filter.Filter) ,public java.lang.String execute(com.iluwatar.intercepting.filter.Order) ,public com.iluwatar.intercepting.filter.Filter getLast() ,public com.iluwatar.intercepting.filter.Filter getNext() ,public void setNext(com.iluwatar.intercepting.filter.Filter) <variables>private com.iluwatar.intercepting.filter.Filter next
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/DepositFilter.java
|
DepositFilter
|
execute
|
class DepositFilter extends AbstractFilter {
@Override
public String execute(Order order) {<FILL_FUNCTION_BODY>}
}
|
var result = super.execute(order);
var depositNumber = order.getDepositNumber();
if (depositNumber == null || depositNumber.isEmpty()) {
return result + "Invalid deposit number! ";
} else {
return result;
}
| 39
| 69
| 108
|
<methods>public void <init>() ,public void <init>(com.iluwatar.intercepting.filter.Filter) ,public java.lang.String execute(com.iluwatar.intercepting.filter.Order) ,public com.iluwatar.intercepting.filter.Filter getLast() ,public com.iluwatar.intercepting.filter.Filter getNext() ,public void setNext(com.iluwatar.intercepting.filter.Filter) <variables>private com.iluwatar.intercepting.filter.Filter next
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/FilterChain.java
|
FilterChain
|
addFilter
|
class FilterChain {
private Filter chain;
/**
* Adds filter.
*/
public void addFilter(Filter filter) {<FILL_FUNCTION_BODY>}
/**
* Execute filter chain.
*/
public String execute(Order order) {
if (chain != null) {
return chain.execute(order);
} else {
return "RUNNING...";
}
}
}
|
if (chain == null) {
chain = filter;
} else {
chain.getLast().setNext(filter);
}
| 116
| 38
| 154
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/NameFilter.java
|
NameFilter
|
execute
|
class NameFilter extends AbstractFilter {
@Override
public String execute(Order order) {<FILL_FUNCTION_BODY>}
}
|
var result = super.execute(order);
var name = order.getName();
if (name == null || name.isEmpty() || name.matches(".*[^\\w|\\s]+.*")) {
return result + "Invalid name! ";
} else {
return result;
}
| 37
| 77
| 114
|
<methods>public void <init>() ,public void <init>(com.iluwatar.intercepting.filter.Filter) ,public java.lang.String execute(com.iluwatar.intercepting.filter.Order) ,public com.iluwatar.intercepting.filter.Filter getLast() ,public com.iluwatar.intercepting.filter.Filter getNext() ,public void setNext(com.iluwatar.intercepting.filter.Filter) <variables>private com.iluwatar.intercepting.filter.Filter next
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/OrderFilter.java
|
OrderFilter
|
execute
|
class OrderFilter extends AbstractFilter {
@Override
public String execute(Order order) {<FILL_FUNCTION_BODY>}
}
|
var result = super.execute(order);
var orderItem = order.getOrderItem();
if (orderItem == null || orderItem.isEmpty()) {
return result + "Invalid order! ";
} else {
return result;
}
| 37
| 64
| 101
|
<methods>public void <init>() ,public void <init>(com.iluwatar.intercepting.filter.Filter) ,public java.lang.String execute(com.iluwatar.intercepting.filter.Order) ,public com.iluwatar.intercepting.filter.Filter getLast() ,public com.iluwatar.intercepting.filter.Filter getNext() ,public void setNext(com.iluwatar.intercepting.filter.Filter) <variables>private com.iluwatar.intercepting.filter.Filter next
|
iluwatar_java-design-patterns
|
java-design-patterns/intercepting-filter/src/main/java/com/iluwatar/intercepting/filter/Target.java
|
Target
|
setup
|
class Target extends JFrame { //NOSONAR
private static final long serialVersionUID = 1L;
private final JTable jt;
private final DefaultTableModel dtm;
private final JButton del;
/**
* Constructor.
*/
public Target() {
super("Order System");
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setSize(640, 480);
dtm = new DefaultTableModel(
new Object[]{"Name", "Contact Number", "Address", "Deposit Number", "Order"}, 0);
jt = new JTable(dtm);
del = new JButton("Delete");
setup();
}
private void setup() {<FILL_FUNCTION_BODY>}
public void execute(String[] request) {
dtm.addRow(new Object[]{request[0], request[1], request[2], request[3], request[4]});
}
class TargetListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
var temp = jt.getSelectedRow();
if (temp == -1) {
return;
}
var temp2 = jt.getSelectedRowCount();
IntStream.range(0, temp2).forEach(i -> dtm.removeRow(temp));
}
}
}
|
setLayout(new BorderLayout());
var bot = new JPanel();
add(jt.getTableHeader(), BorderLayout.NORTH);
bot.setLayout(new BorderLayout());
bot.add(del, BorderLayout.EAST);
add(bot, BorderLayout.SOUTH);
var jsp = new JScrollPane(jt);
jsp.setPreferredSize(new Dimension(500, 250));
add(jsp, BorderLayout.CENTER);
del.addActionListener(new TargetListener());
var rootPane = SwingUtilities.getRootPane(del);
rootPane.setDefaultButton(del);
setVisible(true);
| 349
| 182
| 531
|
<methods>public void <init>() throws java.awt.HeadlessException,public void <init>(java.awt.GraphicsConfiguration) ,public void <init>(java.lang.String) throws java.awt.HeadlessException,public void <init>(java.lang.String, java.awt.GraphicsConfiguration) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public java.awt.Container getContentPane() ,public int getDefaultCloseOperation() ,public java.awt.Component getGlassPane() ,public java.awt.Graphics getGraphics() ,public javax.swing.JMenuBar getJMenuBar() ,public javax.swing.JLayeredPane getLayeredPane() ,public javax.swing.JRootPane getRootPane() ,public javax.swing.TransferHandler getTransferHandler() ,public static boolean isDefaultLookAndFeelDecorated() ,public void remove(java.awt.Component) ,public void repaint(long, int, int, int, int) ,public void setContentPane(java.awt.Container) ,public void setDefaultCloseOperation(int) ,public static void setDefaultLookAndFeelDecorated(boolean) ,public void setGlassPane(java.awt.Component) ,public void setIconImage(java.awt.Image) ,public void setJMenuBar(javax.swing.JMenuBar) ,public void setLayeredPane(javax.swing.JLayeredPane) ,public void setLayout(java.awt.LayoutManager) ,public void setTransferHandler(javax.swing.TransferHandler) ,public void update(java.awt.Graphics) <variables>protected javax.accessibility.AccessibleContext accessibleContext,private int defaultCloseOperation,private static final java.lang.Object defaultLookAndFeelDecoratedKey,protected javax.swing.JRootPane rootPane,protected boolean rootPaneCheckingEnabled,private javax.swing.TransferHandler transferHandler
|
iluwatar_java-design-patterns
|
java-design-patterns/interpreter/src/main/java/com/iluwatar/interpreter/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
* @param args program arguments
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
/**
* Checks whether the input parameter is an operator.
* @param s input string
* @return true if the input parameter is an operator
*/
public static boolean isOperator(String s) {
return s.equals("+") || s.equals("-") || s.equals("*");
}
/**
* Returns correct expression based on the parameters.
* @param s input string
* @param left expression
* @param right expression
* @return expression
*/
public static Expression getOperatorInstance(String s, Expression left, Expression right) {
return switch (s) {
case "+" -> new PlusExpression(left, right);
case "-" -> new MinusExpression(left, right);
default -> new MultiplyExpression(left, right);
};
}
}
|
// the halfling kids are learning some basic math at school
// define the math string we want to parse
final var tokenString = "4 3 2 - 1 + *";
// the stack holds the parsed expressions
var stack = new Stack<Expression>();
// tokenize the string and go through them one by one
var tokenList = tokenString.split(" ");
for (var s : tokenList) {
if (isOperator(s)) {
// when an operator is encountered we expect that the numbers can be popped from the top of
// the stack
var rightExpression = stack.pop();
var leftExpression = stack.pop();
LOGGER.info("popped from stack left: {} right: {}",
leftExpression.interpret(), rightExpression.interpret());
var operator = getOperatorInstance(s, leftExpression, rightExpression);
LOGGER.info("operator: {}", operator);
var result = operator.interpret();
// the operation result is pushed on top of the stack
var resultExpression = new NumberExpression(result);
stack.push(resultExpression);
LOGGER.info("push result to stack: {}", resultExpression.interpret());
} else {
// numbers are pushed on top of the stack
var i = new NumberExpression(s);
stack.push(i);
LOGGER.info("push to stack: {}", i.interpret());
}
}
// in the end, the final result lies on top of the stack
LOGGER.info("result: {}", stack.pop().interpret());
| 260
| 376
| 636
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/iterator/src/main/java/com/iluwatar/iterator/App.java
|
App
|
demonstrateBstIterator
|
class App {
private static final TreasureChest TREASURE_CHEST = new TreasureChest();
private static void demonstrateTreasureChestIteratorForType(ItemType itemType) {
LOGGER.info("------------------------");
LOGGER.info("Item Iterator for ItemType " + itemType + ": ");
var itemIterator = TREASURE_CHEST.iterator(itemType);
while (itemIterator.hasNext()) {
LOGGER.info(itemIterator.next().toString());
}
}
private static void demonstrateBstIterator() {<FILL_FUNCTION_BODY>}
private static TreeNode<Integer> buildIntegerBst() {
var root = new TreeNode<>(8);
root.insert(3);
root.insert(10);
root.insert(1);
root.insert(6);
root.insert(14);
root.insert(4);
root.insert(7);
root.insert(13);
return root;
}
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {
demonstrateTreasureChestIteratorForType(RING);
demonstrateTreasureChestIteratorForType(POTION);
demonstrateTreasureChestIteratorForType(WEAPON);
demonstrateTreasureChestIteratorForType(ANY);
demonstrateBstIterator();
}
}
|
LOGGER.info("------------------------");
LOGGER.info("BST Iterator: ");
var root = buildIntegerBst();
var bstIterator = new BstIterator<>(root);
while (bstIterator.hasNext()) {
LOGGER.info("Next node: " + bstIterator.next().getVal());
}
| 375
| 87
| 462
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/iterator/src/main/java/com/iluwatar/iterator/bst/BstIterator.java
|
BstIterator
|
next
|
class BstIterator<T extends Comparable<T>> implements Iterator<TreeNode<T>> {
private final ArrayDeque<TreeNode<T>> pathStack;
public BstIterator(TreeNode<T> root) {
pathStack = new ArrayDeque<>();
pushPathToNextSmallest(root);
}
/**
* This BstIterator manages to use O(h) extra space, where h is the height of the tree It achieves
* this by maintaining a stack of the nodes to handle (pushing all left nodes first), before
* handling self or right node.
*
* @param node TreeNode that acts as root of the subtree we're interested in.
*/
private void pushPathToNextSmallest(TreeNode<T> node) {
while (node != null) {
pathStack.push(node);
node = node.getLeft();
}
}
/**
* Checks if there exists next element.
*
* @return true if this iterator has a "next" element
*/
@Override
public boolean hasNext() {
return !pathStack.isEmpty();
}
/**
* Gets the next element.
*
* @return TreeNode next. The next element according to our in-order traversal of the given BST
* @throws NoSuchElementException if this iterator does not have a next element
*/
@Override
public TreeNode<T> next() throws NoSuchElementException {<FILL_FUNCTION_BODY>}
}
|
if (pathStack.isEmpty()) {
throw new NoSuchElementException();
}
var next = pathStack.pop();
pushPathToNextSmallest(next.getRight());
return next;
| 388
| 54
| 442
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/iterator/src/main/java/com/iluwatar/iterator/bst/TreeNode.java
|
TreeNode
|
getParentNodeOfValueToBeInserted
|
class TreeNode<T extends Comparable<T>> {
private final T val;
private TreeNode<T> left;
private TreeNode<T> right;
/**
* Creates a TreeNode with a given value, and null children.
*
* @param val The value of the given node
*/
public TreeNode(T val) {
this.val = val;
this.left = null;
this.right = null;
}
public T getVal() {
return val;
}
public TreeNode<T> getLeft() {
return left;
}
private void setLeft(TreeNode<T> left) {
this.left = left;
}
public TreeNode<T> getRight() {
return right;
}
private void setRight(TreeNode<T> right) {
this.right = right;
}
/**
* Inserts new TreeNode based on a given value into the subtree represented by self.
*
* @param valToInsert The value to insert as a new TreeNode
*/
public void insert(T valToInsert) {
var parent = getParentNodeOfValueToBeInserted(valToInsert);
parent.insertNewChild(valToInsert);
}
/**
* Fetch the Parent TreeNode for a given value to insert into the BST.
*
* @param valToInsert Value of the new TreeNode to be inserted
* @return Parent TreeNode of `valToInsert`
*/
private TreeNode<T> getParentNodeOfValueToBeInserted(T valToInsert) {<FILL_FUNCTION_BODY>}
/**
* Returns left or right child of self based on a value that would be inserted; maintaining the
* integrity of the BST.
*
* @param value The value of the TreeNode that would be inserted beneath self
* @return The child TreeNode of self which represents the subtree where `value` would be inserted
*/
private TreeNode<T> traverseOneLevelDown(T value) {
if (this.isGreaterThan(value)) {
return this.left;
}
return this.right;
}
/**
* Add a new Child TreeNode of given value to self. WARNING: This method is destructive (will
* overwrite existing tree structure, if any), and should be called only by this class's insert()
* method.
*
* @param valToInsert Value of the new TreeNode to be inserted
*/
private void insertNewChild(T valToInsert) {
if (this.isLessThanOrEqualTo(valToInsert)) {
this.setRight(new TreeNode<>(valToInsert));
} else {
this.setLeft(new TreeNode<>(valToInsert));
}
}
private boolean isGreaterThan(T val) {
return this.val.compareTo(val) > 0;
}
private boolean isLessThanOrEqualTo(T val) {
return this.val.compareTo(val) < 1;
}
@Override
public String toString() {
return val.toString();
}
}
|
TreeNode<T> parent = null;
var curr = this;
while (curr != null) {
parent = curr;
curr = curr.traverseOneLevelDown(valToInsert);
}
return parent;
| 809
| 68
| 877
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/iterator/src/main/java/com/iluwatar/iterator/list/TreasureChestItemIterator.java
|
TreasureChestItemIterator
|
findNextIdx
|
class TreasureChestItemIterator implements Iterator<Item> {
private final TreasureChest chest;
private int idx;
private final ItemType type;
/**
* Constructor.
*/
public TreasureChestItemIterator(TreasureChest chest, ItemType type) {
this.chest = chest;
this.type = type;
this.idx = -1;
}
@Override
public boolean hasNext() {
return findNextIdx() != -1;
}
@Override
public Item next() {
idx = findNextIdx();
if (idx != -1) {
return chest.getItems().get(idx);
}
return null;
}
private int findNextIdx() {<FILL_FUNCTION_BODY>}
}
|
var items = chest.getItems();
var tempIdx = idx;
while (true) {
tempIdx++;
if (tempIdx >= items.size()) {
tempIdx = -1;
break;
}
if (type.equals(ItemType.ANY) || items.get(tempIdx).getType().equals(type)) {
break;
}
}
return tempIdx;
| 213
| 113
| 326
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/layers/src/main/java/com/iluwatar/layers/Runner.java
|
Runner
|
initializeData
|
class Runner implements CommandLineRunner {
private final CakeBakingService cakeBakingService;
public static final String STRAWBERRY = "strawberry";
@Autowired
public Runner(CakeBakingService cakeBakingService) {
this.cakeBakingService = cakeBakingService;
}
@Override
public void run(String... args) {
//initialize sample data
initializeData();
// create view and render it
var cakeView = new CakeViewImpl(cakeBakingService);
cakeView.render();
}
/**
* Initializes the example data.
*/
private void initializeData() {<FILL_FUNCTION_BODY>}
}
|
cakeBakingService.saveNewLayer(new CakeLayerInfo("chocolate", 1200));
cakeBakingService.saveNewLayer(new CakeLayerInfo("banana", 900));
cakeBakingService.saveNewLayer(new CakeLayerInfo(STRAWBERRY, 950));
cakeBakingService.saveNewLayer(new CakeLayerInfo("lemon", 950));
cakeBakingService.saveNewLayer(new CakeLayerInfo("vanilla", 950));
cakeBakingService.saveNewLayer(new CakeLayerInfo(STRAWBERRY, 950));
cakeBakingService.saveNewTopping(new CakeToppingInfo("candies", 350));
cakeBakingService.saveNewTopping(new CakeToppingInfo("cherry", 350));
var cake1 = new CakeInfo(new CakeToppingInfo("candies", 0),
List.of(new CakeLayerInfo("chocolate", 0), new CakeLayerInfo("banana", 0),
new CakeLayerInfo(STRAWBERRY, 0)));
try {
cakeBakingService.bakeNewCake(cake1);
} catch (CakeBakingException e) {
LOGGER.error("Cake baking exception", e);
}
var cake2 = new CakeInfo(new CakeToppingInfo("cherry", 0),
List.of(new CakeLayerInfo("vanilla", 0), new CakeLayerInfo("lemon", 0),
new CakeLayerInfo(STRAWBERRY, 0)));
try {
cakeBakingService.bakeNewCake(cake2);
} catch (CakeBakingException e) {
LOGGER.error("Cake baking exception", e);
}
| 184
| 462
| 646
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/layers/src/main/java/dto/CakeInfo.java
|
CakeInfo
|
calculateTotalCalories
|
class CakeInfo {
public final Optional<Long> id;
public final CakeToppingInfo cakeToppingInfo;
public final List<CakeLayerInfo> cakeLayerInfos;
/**
* Constructor.
*/
public CakeInfo(Long id, CakeToppingInfo cakeToppingInfo, List<CakeLayerInfo> cakeLayerInfos) {
this.id = Optional.of(id);
this.cakeToppingInfo = cakeToppingInfo;
this.cakeLayerInfos = cakeLayerInfos;
}
/**
* Constructor.
*/
public CakeInfo(CakeToppingInfo cakeToppingInfo, List<CakeLayerInfo> cakeLayerInfos) {
this.id = Optional.empty();
this.cakeToppingInfo = cakeToppingInfo;
this.cakeLayerInfos = cakeLayerInfos;
}
/**
* Calculate calories.
*/
public int calculateTotalCalories() {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return String.format("CakeInfo id=%d topping=%s layers=%s totalCalories=%d", id.orElse(-1L),
cakeToppingInfo, cakeLayerInfos, calculateTotalCalories());
}
}
|
var total = cakeToppingInfo != null ? cakeToppingInfo.calories : 0;
total += cakeLayerInfos.stream().mapToInt(c -> c.calories).sum();
return total;
| 334
| 57
| 391
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/layers/src/main/java/service/CakeBakingServiceImpl.java
|
CakeBakingServiceImpl
|
bakeNewCake
|
class CakeBakingServiceImpl implements CakeBakingService {
private final CakeDao cakeDao;
private final CakeLayerDao cakeLayerDao;
private final CakeToppingDao cakeToppingDao;
/**
* Constructs a new instance of CakeBakingServiceImpl.
*
* @param cakeDao the DAO for cake-related operations
* @param cakeLayerDao the DAO for cake layer-related operations
* @param cakeToppingDao the DAO for cake topping-related operations
*/
@Autowired
public CakeBakingServiceImpl(CakeDao cakeDao, CakeLayerDao cakeLayerDao,
CakeToppingDao cakeToppingDao) {
this.cakeDao = cakeDao;
this.cakeLayerDao = cakeLayerDao;
this.cakeToppingDao = cakeToppingDao;
}
@Override
public void bakeNewCake(CakeInfo cakeInfo) throws CakeBakingException {<FILL_FUNCTION_BODY>}
@Override
public void saveNewTopping(CakeToppingInfo toppingInfo) {
cakeToppingDao.save(new CakeTopping(toppingInfo.name, toppingInfo.calories));
}
@Override
public void saveNewLayer(CakeLayerInfo layerInfo) {
cakeLayerDao.save(new CakeLayer(layerInfo.name, layerInfo.calories));
}
private List<CakeTopping> getAvailableToppingEntities() {
List<CakeTopping> result = new ArrayList<>();
for (CakeTopping topping : cakeToppingDao.findAll()) {
if (topping.getCake() == null) {
result.add(topping);
}
}
return result;
}
@Override
public List<CakeToppingInfo> getAvailableToppings() {
List<CakeToppingInfo> result = new ArrayList<>();
for (CakeTopping next : cakeToppingDao.findAll()) {
if (next.getCake() == null) {
result.add(new CakeToppingInfo(next.getId(), next.getName(), next.getCalories()));
}
}
return result;
}
private List<CakeLayer> getAvailableLayerEntities() {
List<CakeLayer> result = new ArrayList<>();
for (CakeLayer next : cakeLayerDao.findAll()) {
if (next.getCake() == null) {
result.add(next);
}
}
return result;
}
@Override
public List<CakeLayerInfo> getAvailableLayers() {
List<CakeLayerInfo> result = new ArrayList<>();
for (CakeLayer next : cakeLayerDao.findAll()) {
if (next.getCake() == null) {
result.add(new CakeLayerInfo(next.getId(), next.getName(), next.getCalories()));
}
}
return result;
}
@Override
public void deleteAllCakes() {
cakeDao.deleteAll();
}
@Override
public void deleteAllLayers() {
cakeLayerDao.deleteAll();
}
@Override
public void deleteAllToppings() {
cakeToppingDao.deleteAll();
}
@Override
public List<CakeInfo> getAllCakes() {
List<CakeInfo> result = new ArrayList<>();
for (Cake cake : cakeDao.findAll()) {
var cakeToppingInfo =
new CakeToppingInfo(cake.getTopping().getId(), cake.getTopping().getName(),
cake.getTopping().getCalories());
List<CakeLayerInfo> cakeLayerInfos = new ArrayList<>();
for (var layer : cake.getLayers()) {
cakeLayerInfos.add(new CakeLayerInfo(layer.getId(), layer.getName(), layer.getCalories()));
}
var cakeInfo = new CakeInfo(cake.getId(), cakeToppingInfo, cakeLayerInfos);
result.add(cakeInfo);
}
return result;
}
}
|
var allToppings = getAvailableToppingEntities();
var matchingToppings =
allToppings.stream().filter(t -> t.getName().equals(cakeInfo.cakeToppingInfo.name))
.toList();
if (matchingToppings.isEmpty()) {
throw new CakeBakingException(
String.format("Topping %s is not available", cakeInfo.cakeToppingInfo.name));
}
var allLayers = getAvailableLayerEntities();
Set<CakeLayer> foundLayers = new HashSet<>();
for (var info : cakeInfo.cakeLayerInfos) {
var found = allLayers.stream().filter(layer -> layer.getName().equals(info.name)).findFirst();
if (found.isEmpty()) {
throw new CakeBakingException(String.format("Layer %s is not available", info.name));
} else {
foundLayers.add(found.get());
}
}
var topping = cakeToppingDao.findById(matchingToppings.iterator().next().getId());
if (topping.isPresent()) {
var cake = new Cake();
cake.setTopping(topping.get());
cake.setLayers(foundLayers);
cakeDao.save(cake);
topping.get().setCake(cake);
cakeToppingDao.save(topping.get());
Set<CakeLayer> foundLayersToUpdate =
new HashSet<>(foundLayers); // copy set to avoid a ConcurrentModificationException
for (var layer : foundLayersToUpdate) {
layer.setCake(cake);
cakeLayerDao.save(layer);
}
} else {
throw new CakeBakingException(
String.format("Topping %s is not available", cakeInfo.cakeToppingInfo.name));
}
| 1,074
| 472
| 1,546
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lazy-loading/src/main/java/com/iluwatar/lazy/loading/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// Simple lazy loader - not thread safe
var holderNaive = new HolderNaive();
var heavy = holderNaive.getHeavy();
LOGGER.info("heavy={}", heavy);
// Thread safe lazy loader, but with heavy synchronization on each access
var holderThreadSafe = new HolderThreadSafe();
var another = holderThreadSafe.getHeavy();
LOGGER.info("another={}", another);
// The most efficient lazy loader utilizing Java 8 features
var java8Holder = new Java8Holder();
var next = java8Holder.getHeavy();
LOGGER.info("next={}", next);
| 56
| 162
| 218
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lazy-loading/src/main/java/com/iluwatar/lazy/loading/HolderNaive.java
|
HolderNaive
|
getHeavy
|
class HolderNaive {
private Heavy heavy;
/**
* Constructor.
*/
public HolderNaive() {
LOGGER.info("HolderNaive created");
}
/**
* Get heavy object.
*/
public Heavy getHeavy() {<FILL_FUNCTION_BODY>}
}
|
if (heavy == null) {
heavy = new Heavy();
}
return heavy;
| 90
| 29
| 119
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lazy-loading/src/main/java/com/iluwatar/lazy/loading/HolderThreadSafe.java
|
HolderThreadSafe
|
getHeavy
|
class HolderThreadSafe {
private Heavy heavy;
/**
* Constructor.
*/
public HolderThreadSafe() {
LOGGER.info("HolderThreadSafe created");
}
/**
* Get heavy object.
*/
public synchronized Heavy getHeavy() {<FILL_FUNCTION_BODY>}
}
|
if (heavy == null) {
heavy = new Heavy();
}
return heavy;
| 92
| 29
| 121
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lazy-loading/src/main/java/com/iluwatar/lazy/loading/Java8Holder.java
|
Java8Holder
|
createAndCacheHeavy
|
class Java8Holder {
private Supplier<Heavy> heavy = this::createAndCacheHeavy;
public Java8Holder() {
LOGGER.info("Java8Holder created");
}
public Heavy getHeavy() {
return heavy.get();
}
private synchronized Heavy createAndCacheHeavy() {<FILL_FUNCTION_BODY>}
}
|
class HeavyFactory implements Supplier<Heavy> {
private final Heavy heavyInstance = new Heavy();
@Override
public Heavy get() {
return heavyInstance;
}
}
if (!(heavy instanceof HeavyFactory)) {
heavy = new HeavyFactory();
}
return heavy.get();
| 100
| 89
| 189
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/AbstractInstance.java
|
AbstractInstance
|
processMessage
|
class AbstractInstance implements Instance, Runnable {
protected static final int HEARTBEAT_INTERVAL = 5000;
private static final String INSTANCE = "Instance ";
protected MessageManager messageManager;
protected Queue<Message> messageQueue;
protected final int localId;
protected int leaderId;
protected boolean alive;
/**
* Constructor of BullyInstance.
*/
public AbstractInstance(MessageManager messageManager, int localId, int leaderId) {
this.messageManager = messageManager;
this.messageQueue = new ConcurrentLinkedQueue<>();
this.localId = localId;
this.leaderId = leaderId;
this.alive = true;
}
/**
* The instance will execute the message in its message queue periodically once it is alive.
*/
@Override
@SuppressWarnings("squid:S2189")
public void run() {
while (true) {
if (!this.messageQueue.isEmpty()) {
this.processMessage(this.messageQueue.remove());
}
}
}
/**
* Once messages are sent to the certain instance, it will firstly be added to the queue and wait
* to be executed.
*
* @param message Message sent by other instances
*/
@Override
public void onMessage(Message message) {
messageQueue.offer(message);
}
/**
* Check if the instance is alive or not.
*
* @return {@code true} if the instance is alive.
*/
@Override
public boolean isAlive() {
return alive;
}
/**
* Set the health status of the certain instance.
*
* @param alive {@code true} for alive.
*/
@Override
public void setAlive(boolean alive) {
this.alive = alive;
}
/**
* Process the message according to its type.
*
* @param message Message polled from queue.
*/
private void processMessage(Message message) {<FILL_FUNCTION_BODY>}
/**
* Abstract methods to handle different types of message. These methods need to be implemented in
* concrete instance class to implement corresponding leader-selection pattern.
*/
protected abstract void handleElectionMessage(Message message);
protected abstract void handleElectionInvokeMessage();
protected abstract void handleLeaderMessage(Message message);
protected abstract void handleLeaderInvokeMessage();
protected abstract void handleHeartbeatMessage(Message message);
protected abstract void handleHeartbeatInvokeMessage();
}
|
switch (message.getType()) {
case ELECTION -> {
LOGGER.info(INSTANCE + localId + " - Election Message handling...");
handleElectionMessage(message);
}
case LEADER -> {
LOGGER.info(INSTANCE + localId + " - Leader Message handling...");
handleLeaderMessage(message);
}
case HEARTBEAT -> {
LOGGER.info(INSTANCE + localId + " - Heartbeat Message handling...");
handleHeartbeatMessage(message);
}
case ELECTION_INVOKE -> {
LOGGER.info(INSTANCE + localId + " - Election Invoke Message handling...");
handleElectionInvokeMessage();
}
case LEADER_INVOKE -> {
LOGGER.info(INSTANCE + localId + " - Leader Invoke Message handling...");
handleLeaderInvokeMessage();
}
case HEARTBEAT_INVOKE -> {
LOGGER.info(INSTANCE + localId + " - Heartbeat Invoke Message handling...");
handleHeartbeatInvokeMessage();
}
default -> {
}
}
| 660
| 299
| 959
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/AbstractMessageManager.java
|
AbstractMessageManager
|
findNextInstance
|
class AbstractMessageManager implements MessageManager {
/**
* Contain all the instances in the system. Key is its ID, and value is the instance itself.
*/
protected Map<Integer, Instance> instanceMap;
/**
* Constructor of AbstractMessageManager.
*/
public AbstractMessageManager(Map<Integer, Instance> instanceMap) {
this.instanceMap = instanceMap;
}
/**
* Find the next instance with smallest ID.
*
* @return The next instance.
*/
protected Instance findNextInstance(int currentId) {<FILL_FUNCTION_BODY>}
}
|
Instance result = null;
var candidateList = instanceMap.keySet()
.stream()
.filter((i) -> i > currentId && instanceMap.get(i).isAlive())
.sorted()
.toList();
if (candidateList.isEmpty()) {
var index = instanceMap.keySet()
.stream()
.filter((i) -> instanceMap.get(i).isAlive())
.sorted()
.toList()
.get(0);
result = instanceMap.get(index);
} else {
var index = candidateList.get(0);
result = instanceMap.get(index);
}
return result;
| 160
| 178
| 338
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/bully/BullyApp.java
|
BullyApp
|
main
|
class BullyApp {
/**
* Program entry point.
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
Map<Integer, Instance> instanceMap = new HashMap<>();
var messageManager = new BullyMessageManager(instanceMap);
var instance1 = new BullyInstance(messageManager, 1, 1);
var instance2 = new BullyInstance(messageManager, 2, 1);
var instance3 = new BullyInstance(messageManager, 3, 1);
var instance4 = new BullyInstance(messageManager, 4, 1);
var instance5 = new BullyInstance(messageManager, 5, 1);
instanceMap.put(1, instance1);
instanceMap.put(2, instance2);
instanceMap.put(3, instance3);
instanceMap.put(4, instance4);
instanceMap.put(5, instance5);
instance4.onMessage(new Message(MessageType.HEARTBEAT_INVOKE, ""));
final var thread1 = new Thread(instance1);
final var thread2 = new Thread(instance2);
final var thread3 = new Thread(instance3);
final var thread4 = new Thread(instance4);
final var thread5 = new Thread(instance5);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
instance1.setAlive(false);
| 46
| 338
| 384
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/bully/BullyInstance.java
|
BullyInstance
|
handleHeartbeatInvokeMessage
|
class BullyInstance extends AbstractInstance {
private static final String INSTANCE = "Instance ";
/**
* Constructor of BullyInstance.
*/
public BullyInstance(MessageManager messageManager, int localId, int leaderId) {
super(messageManager, localId, leaderId);
}
/**
* Process the heartbeat invoke message. After receiving the message, the instance will send a
* heartbeat to leader to check its health. If alive, it will inform the next instance to do the
* heartbeat. If not, it will start the election process.
*/
@Override
protected void handleHeartbeatInvokeMessage() {<FILL_FUNCTION_BODY>}
/**
* Process election invoke message. Send election message to all the instances with smaller ID. If
* any one of them is alive, do nothing. If no instance alive, send leader message to all the
* alive instance and restart heartbeat.
*/
@Override
protected void handleElectionInvokeMessage() {
if (!isLeader()) {
LOGGER.info(INSTANCE + localId + "- Start election.");
boolean electionResult = messageManager.sendElectionMessage(localId, String.valueOf(localId));
if (electionResult) {
LOGGER.info(INSTANCE + localId + "- Succeed in election. Start leader notification.");
leaderId = localId;
messageManager.sendLeaderMessage(localId, localId);
messageManager.sendHeartbeatInvokeMessage(localId);
}
}
}
/**
* Process leader message. Update local leader information.
*/
@Override
protected void handleLeaderMessage(Message message) {
leaderId = Integer.valueOf(message.getContent());
LOGGER.info(INSTANCE + localId + " - Leader update done.");
}
private boolean isLeader() {
return localId == leaderId;
}
@Override
protected void handleLeaderInvokeMessage() {
// Not used in Bully Instance
}
@Override
protected void handleHeartbeatMessage(Message message) {
// Not used in Bully Instance
}
@Override
protected void handleElectionMessage(Message message) {
// Not used in Bully Instance
}
}
|
try {
boolean isLeaderAlive = messageManager.sendHeartbeatMessage(leaderId);
if (isLeaderAlive) {
LOGGER.info(INSTANCE + localId + "- Leader is alive.");
Thread.sleep(HEARTBEAT_INTERVAL);
messageManager.sendHeartbeatInvokeMessage(localId);
} else {
LOGGER.info(INSTANCE + localId + "- Leader is not alive. Start election.");
boolean electionResult =
messageManager.sendElectionMessage(localId, String.valueOf(localId));
if (electionResult) {
LOGGER.info(INSTANCE + localId + "- Succeed in election. Start leader notification.");
messageManager.sendLeaderMessage(localId, localId);
}
}
} catch (InterruptedException e) {
LOGGER.info(INSTANCE + localId + "- Interrupted.");
}
| 573
| 230
| 803
|
<methods>public void <init>(com.iluwatar.leaderelection.MessageManager, int, int) ,public boolean isAlive() ,public void onMessage(com.iluwatar.leaderelection.Message) ,public void run() ,public void setAlive(boolean) <variables>protected static final int HEARTBEAT_INTERVAL,private static final java.lang.String INSTANCE,protected boolean alive,protected int leaderId,protected final non-sealed int localId,protected com.iluwatar.leaderelection.MessageManager messageManager,protected Queue<com.iluwatar.leaderelection.Message> messageQueue
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/bully/BullyMessageManager.java
|
BullyMessageManager
|
sendElectionMessage
|
class BullyMessageManager extends AbstractMessageManager {
/**
* Constructor of BullyMessageManager.
*/
public BullyMessageManager(Map<Integer, Instance> instanceMap) {
super(instanceMap);
}
/**
* Send heartbeat message to current leader instance to check the health.
*
* @param leaderId leaderID
* @return {@code true} if the leader is alive.
*/
@Override
public boolean sendHeartbeatMessage(int leaderId) {
var leaderInstance = instanceMap.get(leaderId);
var alive = leaderInstance.isAlive();
return alive;
}
/**
* Send election message to all the instances with smaller ID.
*
* @param currentId Instance ID of which sends this message.
* @param content Election message content.
* @return {@code true} if no alive instance has smaller ID, so that the election is accepted.
*/
@Override
public boolean sendElectionMessage(int currentId, String content) {<FILL_FUNCTION_BODY>}
/**
* Send leader message to all the instances to notify the new leader.
*
* @param currentId Instance ID of which sends this message.
* @param leaderId Leader message content.
* @return {@code true} if the message is accepted.
*/
@Override
public boolean sendLeaderMessage(int currentId, int leaderId) {
var leaderMessage = new Message(MessageType.LEADER, String.valueOf(leaderId));
instanceMap.keySet()
.stream()
.filter((i) -> i != currentId)
.forEach((i) -> instanceMap.get(i).onMessage(leaderMessage));
return false;
}
/**
* Send heartbeat invoke message to the next instance.
*
* @param currentId Instance ID of which sends this message.
*/
@Override
public void sendHeartbeatInvokeMessage(int currentId) {
var nextInstance = this.findNextInstance(currentId);
var heartbeatInvokeMessage = new Message(MessageType.HEARTBEAT_INVOKE, "");
nextInstance.onMessage(heartbeatInvokeMessage);
}
/**
* Find all the alive instances with smaller ID than current instance.
*
* @param currentId ID of current instance.
* @return ID list of all the candidate instance.
*/
private List<Integer> findElectionCandidateInstanceList(int currentId) {
return instanceMap.keySet()
.stream()
.filter((i) -> i < currentId && instanceMap.get(i).isAlive())
.toList();
}
}
|
var candidateList = findElectionCandidateInstanceList(currentId);
if (candidateList.isEmpty()) {
return true;
} else {
var electionMessage = new Message(MessageType.ELECTION_INVOKE, "");
candidateList.stream().forEach((i) -> instanceMap.get(i).onMessage(electionMessage));
return false;
}
| 686
| 98
| 784
|
<methods>public void <init>(Map<java.lang.Integer,com.iluwatar.leaderelection.Instance>) <variables>protected Map<java.lang.Integer,com.iluwatar.leaderelection.Instance> instanceMap
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/ring/RingApp.java
|
RingApp
|
main
|
class RingApp {
/**
* Program entry point.
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
Map<Integer, Instance> instanceMap = new HashMap<>();
var messageManager = new RingMessageManager(instanceMap);
var instance1 = new RingInstance(messageManager, 1, 1);
var instance2 = new RingInstance(messageManager, 2, 1);
var instance3 = new RingInstance(messageManager, 3, 1);
var instance4 = new RingInstance(messageManager, 4, 1);
var instance5 = new RingInstance(messageManager, 5, 1);
instanceMap.put(1, instance1);
instanceMap.put(2, instance2);
instanceMap.put(3, instance3);
instanceMap.put(4, instance4);
instanceMap.put(5, instance5);
instance2.onMessage(new Message(MessageType.HEARTBEAT_INVOKE, ""));
final var thread1 = new Thread(instance1);
final var thread2 = new Thread(instance2);
final var thread3 = new Thread(instance3);
final var thread4 = new Thread(instance4);
final var thread5 = new Thread(instance5);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
instance1.setAlive(false);
| 45
| 332
| 377
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/ring/RingInstance.java
|
RingInstance
|
handleElectionMessage
|
class RingInstance extends AbstractInstance {
private static final String INSTANCE = "Instance ";
/**
* Constructor of RingInstance.
*/
public RingInstance(MessageManager messageManager, int localId, int leaderId) {
super(messageManager, localId, leaderId);
}
/**
* Process the heartbeat invoke message. After receiving the message, the instance will send a
* heartbeat to leader to check its health. If alive, it will inform the next instance to do the
* heartbeat. If not, it will start the election process.
*/
@Override
protected void handleHeartbeatInvokeMessage() {
try {
var isLeaderAlive = messageManager.sendHeartbeatMessage(this.leaderId);
if (isLeaderAlive) {
LOGGER.info(INSTANCE + localId + "- Leader is alive. Start next heartbeat in 5 second.");
Thread.sleep(HEARTBEAT_INTERVAL);
messageManager.sendHeartbeatInvokeMessage(this.localId);
} else {
LOGGER.info(INSTANCE + localId + "- Leader is not alive. Start election.");
messageManager.sendElectionMessage(this.localId, String.valueOf(this.localId));
}
} catch (InterruptedException e) {
LOGGER.info(INSTANCE + localId + "- Interrupted.");
}
}
/**
* Process election message. If the local ID is contained in the ID list, the instance will select
* the alive instance with smallest ID to be the new leader, and send the leader inform message.
* If not, it will add its local ID to the list and send the message to the next instance in the
* ring.
*/
@Override
protected void handleElectionMessage(Message message) {<FILL_FUNCTION_BODY>}
/**
* Process leader Message. The instance will set the leader ID to be the new one and send the
* message to the next instance until all the alive instance in the ring is informed.
*/
@Override
protected void handleLeaderMessage(Message message) {
var newLeaderId = Integer.valueOf(message.getContent());
if (this.leaderId != newLeaderId) {
LOGGER.info(INSTANCE + localId + " - Update leaderID");
this.leaderId = newLeaderId;
messageManager.sendLeaderMessage(localId, newLeaderId);
} else {
LOGGER.info(INSTANCE + localId + " - Leader update done. Start heartbeat.");
messageManager.sendHeartbeatInvokeMessage(localId);
}
}
/**
* Not used in Ring instance.
*/
@Override
protected void handleLeaderInvokeMessage() {
// Not used in Ring instance.
}
@Override
protected void handleHeartbeatMessage(Message message) {
// Not used in Ring instance.
}
@Override
protected void handleElectionInvokeMessage() {
// Not used in Ring instance.
}
}
|
var content = message.getContent();
LOGGER.info(INSTANCE + localId + " - Election Message: " + content);
var candidateList = Arrays.stream(content.trim().split(","))
.map(Integer::valueOf)
.sorted()
.toList();
if (candidateList.contains(localId)) {
var newLeaderId = candidateList.get(0);
LOGGER.info(INSTANCE + localId + " - New leader should be " + newLeaderId + ".");
messageManager.sendLeaderMessage(localId, newLeaderId);
} else {
content += "," + localId;
messageManager.sendElectionMessage(localId, content);
}
| 764
| 185
| 949
|
<methods>public void <init>(com.iluwatar.leaderelection.MessageManager, int, int) ,public boolean isAlive() ,public void onMessage(com.iluwatar.leaderelection.Message) ,public void run() ,public void setAlive(boolean) <variables>protected static final int HEARTBEAT_INTERVAL,private static final java.lang.String INSTANCE,protected boolean alive,protected int leaderId,protected final non-sealed int localId,protected com.iluwatar.leaderelection.MessageManager messageManager,protected Queue<com.iluwatar.leaderelection.Message> messageQueue
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-election/src/main/java/com/iluwatar/leaderelection/ring/RingMessageManager.java
|
RingMessageManager
|
sendLeaderMessage
|
class RingMessageManager extends AbstractMessageManager {
/**
* Constructor of RingMessageManager.
*/
public RingMessageManager(Map<Integer, Instance> instanceMap) {
super(instanceMap);
}
/**
* Send heartbeat message to current leader instance to check the health.
*
* @param leaderId leaderID
* @return {@code true} if the leader is alive.
*/
@Override
public boolean sendHeartbeatMessage(int leaderId) {
var leaderInstance = instanceMap.get(leaderId);
var alive = leaderInstance.isAlive();
return alive;
}
/**
* Send election message to the next instance.
*
* @param currentId currentID
* @param content list contains all the IDs of instances which have received this election
* message.
* @return {@code true} if the election message is accepted by the target instance.
*/
@Override
public boolean sendElectionMessage(int currentId, String content) {
var nextInstance = this.findNextInstance(currentId);
var electionMessage = new Message(MessageType.ELECTION, content);
nextInstance.onMessage(electionMessage);
return true;
}
/**
* Send leader message to the next instance.
*
* @param currentId Instance ID of which sends this message.
* @param leaderId Leader message content.
* @return {@code true} if the leader message is accepted by the target instance.
*/
@Override
public boolean sendLeaderMessage(int currentId, int leaderId) {<FILL_FUNCTION_BODY>}
/**
* Send heartbeat invoke message to the next instance.
*
* @param currentId Instance ID of which sends this message.
*/
@Override
public void sendHeartbeatInvokeMessage(int currentId) {
var nextInstance = this.findNextInstance(currentId);
var heartbeatInvokeMessage = new Message(MessageType.HEARTBEAT_INVOKE, "");
nextInstance.onMessage(heartbeatInvokeMessage);
}
}
|
var nextInstance = this.findNextInstance(currentId);
var leaderMessage = new Message(MessageType.LEADER, String.valueOf(leaderId));
nextInstance.onMessage(leaderMessage);
return true;
| 534
| 60
| 594
|
<methods>public void <init>(Map<java.lang.Integer,com.iluwatar.leaderelection.Instance>) <variables>protected Map<java.lang.Integer,com.iluwatar.leaderelection.Instance> instanceMap
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-followers/src/main/java/com/iluwatar/leaderfollowers/App.java
|
App
|
execute
|
class App {
/**
* The main method for the leader followers pattern.
*/
public static void main(String[] args) throws InterruptedException {
var taskSet = new TaskSet();
var taskHandler = new TaskHandler();
var workCenter = new WorkCenter();
workCenter.createWorkers(4, taskSet, taskHandler);
execute(workCenter, taskSet);
}
/**
* Start the work, dispatch tasks and stop the thread pool at last.
*/
private static void execute(WorkCenter workCenter, TaskSet taskSet) throws InterruptedException {<FILL_FUNCTION_BODY>}
/**
* Add tasks.
*/
private static void addTasks(TaskSet taskSet) throws InterruptedException {
var rand = new SecureRandom();
for (var i = 0; i < 5; i++) {
var time = Math.abs(rand.nextInt(1000));
taskSet.addTask(new Task(time));
}
}
}
|
var workers = workCenter.getWorkers();
var exec = Executors.newFixedThreadPool(workers.size());
workers.forEach(exec::submit);
Thread.sleep(1000);
addTasks(taskSet);
exec.awaitTermination(2, TimeUnit.SECONDS);
exec.shutdownNow();
| 256
| 88
| 344
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-followers/src/main/java/com/iluwatar/leaderfollowers/TaskHandler.java
|
TaskHandler
|
handleTask
|
class TaskHandler {
/**
* This interface handles one task at a time.
*/
public void handleTask(Task task) throws InterruptedException {<FILL_FUNCTION_BODY>}
}
|
var time = task.getTime();
Thread.sleep(time);
LOGGER.info("It takes " + time + " milliseconds to finish the task");
task.setFinished();
| 54
| 51
| 105
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-followers/src/main/java/com/iluwatar/leaderfollowers/WorkCenter.java
|
WorkCenter
|
createWorkers
|
class WorkCenter {
private Worker leader;
private final List<Worker> workers = new CopyOnWriteArrayList<>();
/**
* Create workers and set leader.
*/
public void createWorkers(int numberOfWorkers, TaskSet taskSet, TaskHandler taskHandler) {<FILL_FUNCTION_BODY>}
public void addWorker(Worker worker) {
workers.add(worker);
}
public void removeWorker(Worker worker) {
workers.remove(worker);
}
public Worker getLeader() {
return leader;
}
/**
* Promote a leader.
*/
public void promoteLeader() {
Worker leader = null;
if (workers.size() > 0) {
leader = workers.get(0);
}
this.leader = leader;
}
public List<Worker> getWorkers() {
return workers;
}
}
|
for (var id = 1; id <= numberOfWorkers; id++) {
var worker = new Worker(id, this, taskSet, taskHandler);
workers.add(worker);
}
promoteLeader();
| 247
| 59
| 306
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/leader-followers/src/main/java/com/iluwatar/leaderfollowers/Worker.java
|
Worker
|
run
|
class Worker implements Runnable {
@EqualsAndHashCode.Include
private final long id;
private final WorkCenter workCenter;
private final TaskSet taskSet;
private final TaskHandler taskHandler;
/**
* Constructor to create a worker which will take work from the work center.
*/
public Worker(long id, WorkCenter workCenter, TaskSet taskSet, TaskHandler taskHandler) {
super();
this.id = id;
this.workCenter = workCenter;
this.taskSet = taskSet;
this.taskHandler = taskHandler;
}
/**
* The leader thread listens for task. When task arrives, it promotes one of the followers to be
* the new leader. Then it handles the task and add himself back to work center.
*/
@Override
public void run() {<FILL_FUNCTION_BODY>}
}
|
while (!Thread.interrupted()) {
try {
if (workCenter.getLeader() != null && !workCenter.getLeader().equals(this)) {
synchronized (workCenter) {
if (workCenter.getLeader() != null && !workCenter.getLeader().equals(this)) {
workCenter.wait();
continue;
}
}
}
final Task task = taskSet.getTask();
synchronized (workCenter) {
workCenter.removeWorker(this);
workCenter.promoteLeader();
workCenter.notifyAll();
}
taskHandler.handleTask(task);
LOGGER.info("The Worker with the ID " + id + " completed the task");
workCenter.addWorker(this);
} catch (InterruptedException e) {
LOGGER.warn("Worker interrupted");
Thread.currentThread().interrupt();
return;
}
}
| 226
| 240
| 466
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lockable-object/src/main/java/com/iluwatar/lockableobject/App.java
|
App
|
run
|
class App implements Runnable {
private static final int WAIT_TIME = 3;
private static final int WORKERS = 2;
private static final int MULTIPLICATION_FACTOR = 3;
/**
* main method.
*
* @param args as arguments for the main method.
*/
public static void main(String[] args) {
var app = new App();
app.run();
}
@Override
public void run() {<FILL_FUNCTION_BODY>}
}
|
// The target object for this example.
var sword = new SwordOfAragorn();
// Creation of creatures.
List<Creature> creatures = new ArrayList<>();
for (var i = 0; i < WORKERS; i++) {
creatures.add(new Elf(String.format("Elf %s", i)));
creatures.add(new Orc(String.format("Orc %s", i)));
creatures.add(new Human(String.format("Human %s", i)));
}
int totalFiends = WORKERS * MULTIPLICATION_FACTOR;
ExecutorService service = Executors.newFixedThreadPool(totalFiends);
// Attach every creature and the sword is a Fiend to fight for the sword.
for (var i = 0; i < totalFiends; i = i + MULTIPLICATION_FACTOR) {
service.submit(new Feind(creatures.get(i), sword));
service.submit(new Feind(creatures.get(i + 1), sword));
service.submit(new Feind(creatures.get(i + 2), sword));
}
// Wait for program to terminate.
try {
if (!service.awaitTermination(WAIT_TIME, TimeUnit.SECONDS)) {
LOGGER.info("The master of the sword is now {}.", sword.getLocker().getName());
}
} catch (InterruptedException e) {
LOGGER.error(e.getMessage());
Thread.currentThread().interrupt();
} finally {
service.shutdown();
}
| 136
| 397
| 533
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lockable-object/src/main/java/com/iluwatar/lockableobject/SwordOfAragorn.java
|
SwordOfAragorn
|
unlock
|
class SwordOfAragorn implements Lockable {
private Creature locker;
private final Object synchronizer;
private static final String NAME = "The Sword of Aragorn";
public SwordOfAragorn() {
this.locker = null;
this.synchronizer = new Object();
}
@Override
public boolean isLocked() {
return this.locker != null;
}
@Override
public boolean lock(@NonNull Creature creature) {
synchronized (synchronizer) {
LOGGER.info("{} is now trying to acquire {}!", creature.getName(), this.getName());
if (!isLocked()) {
locker = creature;
return true;
} else {
if (!locker.getName().equals(creature.getName())) {
return false;
}
}
}
return false;
}
@Override
public void unlock(@NonNull Creature creature) {<FILL_FUNCTION_BODY>}
@Override
public Creature getLocker() {
return this.locker;
}
@Override
public String getName() {
return NAME;
}
}
|
synchronized (synchronizer) {
if (locker != null && locker.getName().equals(creature.getName())) {
locker = null;
LOGGER.info("{} is now free!", this.getName());
}
if (locker != null) {
throw new LockingException("You cannot unlock an object you are not the owner of.");
}
}
| 305
| 100
| 405
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lockable-object/src/main/java/com/iluwatar/lockableobject/domain/Creature.java
|
Creature
|
hit
|
class Creature {
private String name;
private CreatureType type;
private int health;
private int damage;
Set<Lockable> instruments;
protected Creature(@NonNull String name) {
this.name = name;
this.instruments = new HashSet<>();
}
/**
* Reaches for the Lockable and tried to hold it.
*
* @param lockable as the Lockable to lock.
* @return true of Lockable was locked by this creature.
*/
public boolean acquire(@NonNull Lockable lockable) {
if (lockable.lock(this)) {
instruments.add(lockable);
return true;
}
return false;
}
/** Terminates the Creature and unlocks all of the Lockable that it posses. */
public synchronized void kill() {
LOGGER.info("{} {} has been slayed!", type, name);
for (Lockable lockable : instruments) {
lockable.unlock(this);
}
this.instruments.clear();
}
/**
* Attacks a foe.
*
* @param creature as the foe to be attacked.
*/
public synchronized void attack(@NonNull Creature creature) {
creature.hit(getDamage());
}
/**
* When a creature gets hit it removed the amount of damage from the creature's life.
*
* @param damage as the damage that was taken.
*/
public synchronized void hit(int damage) {<FILL_FUNCTION_BODY>}
/**
* Checks if the creature is still alive.
*
* @return true of creature is alive.
*/
public synchronized boolean isAlive() {
return getHealth() > 0;
}
}
|
if (damage < 0) {
throw new IllegalArgumentException("Damage cannot be a negative number");
}
if (isAlive()) {
setHealth(getHealth() - damage);
if (!isAlive()) {
kill();
}
}
| 463
| 71
| 534
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/lockable-object/src/main/java/com/iluwatar/lockableobject/domain/Feind.java
|
Feind
|
fightForTheSword
|
class Feind implements Runnable {
private final Creature creature;
private final Lockable target;
private final SecureRandom random;
private static final Logger LOGGER = LoggerFactory.getLogger(Feind.class.getName());
/**
* public constructor.
*
* @param feind as the creature to lock to he lockable.
* @param target as the target object.
*/
public Feind(@NonNull Creature feind, @NonNull Lockable target) {
this.creature = feind;
this.target = target;
this.random = new SecureRandom();
}
@Override
public void run() {
if (!creature.acquire(target)) {
try {
fightForTheSword(creature, target.getLocker(), target);
} catch (InterruptedException e) {
LOGGER.error(e.getMessage());
Thread.currentThread().interrupt();
}
} else {
LOGGER.info("{} has acquired the sword!", target.getLocker().getName());
}
}
/**
* Keeps on fighting until the Lockable is possessed.
*
* @param reacher as the source creature.
* @param holder as the foe.
* @param sword as the Lockable to posses.
* @throws InterruptedException in case of interruption.
*/
private void fightForTheSword(Creature reacher, @NonNull Creature holder, Lockable sword)
throws InterruptedException {<FILL_FUNCTION_BODY>}
}
|
LOGGER.info("A duel between {} and {} has been started!", reacher.getName(), holder.getName());
boolean randBool;
while (this.target.isLocked() && reacher.isAlive() && holder.isAlive()) {
randBool = random.nextBoolean();
if (randBool) {
reacher.attack(holder);
} else {
holder.attack(reacher);
}
}
if (reacher.isAlive()) {
if (!reacher.acquire(sword)) {
fightForTheSword(reacher, sword.getLocker(), sword);
} else {
LOGGER.info("{} has acquired the sword!", reacher.getName());
}
}
| 394
| 191
| 585
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/log-aggregation/src/main/java/com/iluwatar/logaggregation/App.java
|
App
|
main
|
class App {
/**
* The entry point of the application.
*
* @param args Command line arguments.
* @throws InterruptedException If any thread has interrupted the current thread.
*/
public static void main(String[] args) throws InterruptedException {<FILL_FUNCTION_BODY>}
}
|
final CentralLogStore centralLogStore = new CentralLogStore();
final LogAggregator aggregator = new LogAggregator(centralLogStore, LogLevel.INFO);
final LogProducer serviceA = new LogProducer("ServiceA", aggregator);
final LogProducer serviceB = new LogProducer("ServiceB", aggregator);
serviceA.generateLog(LogLevel.INFO, "This is an INFO log from ServiceA");
serviceB.generateLog(LogLevel.ERROR, "This is an ERROR log from ServiceB");
serviceA.generateLog(LogLevel.DEBUG, "This is a DEBUG log from ServiceA");
aggregator.stop();
centralLogStore.displayLogs();
| 81
| 172
| 253
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/log-aggregation/src/main/java/com/iluwatar/logaggregation/CentralLogStore.java
|
CentralLogStore
|
storeLog
|
class CentralLogStore {
private final ConcurrentLinkedQueue<LogEntry> logs = new ConcurrentLinkedQueue<>();
/**
* Stores the given log entry into the central log store.
*
* @param logEntry The log entry to store.
*/
public void storeLog(LogEntry logEntry) {<FILL_FUNCTION_BODY>}
/**
* Displays all logs currently stored in the central log store.
*/
public void displayLogs() {
LOGGER.info("----- Centralized Logs -----");
for (LogEntry logEntry : logs) {
LOGGER.info(
logEntry.getTimestamp() + " [" + logEntry.getLevel() + "] " + logEntry.getMessage());
}
}
}
|
if (logEntry == null) {
LOGGER.error("Received null log entry. Skipping.");
return;
}
logs.offer(logEntry);
| 195
| 46
| 241
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/log-aggregation/src/main/java/com/iluwatar/logaggregation/LogAggregator.java
|
LogAggregator
|
flushBuffer
|
class LogAggregator {
private static final int BUFFER_THRESHOLD = 3;
private final CentralLogStore centralLogStore;
private final ConcurrentLinkedQueue<LogEntry> buffer = new ConcurrentLinkedQueue<>();
private final LogLevel minLogLevel;
private final ExecutorService executorService = Executors.newSingleThreadExecutor();
private final AtomicInteger logCount = new AtomicInteger(0);
/**
* constructor of LogAggregator.
*
* @param centralLogStore central log store implement
* @param minLogLevel min log level to store log
*/
public LogAggregator(CentralLogStore centralLogStore, LogLevel minLogLevel) {
this.centralLogStore = centralLogStore;
this.minLogLevel = minLogLevel;
startBufferFlusher();
}
/**
* Collects a given log entry, and filters it by the defined log level.
*
* @param logEntry The log entry to collect.
*/
public void collectLog(LogEntry logEntry) {
if (logEntry.getLevel() == null || minLogLevel == null) {
LOGGER.warn("Log level or threshold level is null. Skipping.");
return;
}
if (logEntry.getLevel().compareTo(minLogLevel) < 0) {
LOGGER.debug("Log level below threshold. Skipping.");
return;
}
buffer.offer(logEntry);
if (logCount.incrementAndGet() >= BUFFER_THRESHOLD) {
flushBuffer();
}
}
/**
* Stops the log aggregator service and flushes any remaining logs to
* the central log store.
*
* @throws InterruptedException If any thread has interrupted the current thread.
*/
public void stop() throws InterruptedException {
executorService.shutdownNow();
if (!executorService.awaitTermination(10, TimeUnit.SECONDS)) {
LOGGER.error("Log aggregator did not terminate.");
}
flushBuffer();
}
private void flushBuffer() {<FILL_FUNCTION_BODY>}
private void startBufferFlusher() {
executorService.execute(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
Thread.sleep(5000); // Flush every 5 seconds.
flushBuffer();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
}
}
|
LogEntry logEntry;
while ((logEntry = buffer.poll()) != null) {
centralLogStore.storeLog(logEntry);
logCount.decrementAndGet();
}
| 637
| 53
| 690
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/log-aggregation/src/main/java/com/iluwatar/logaggregation/LogProducer.java
|
LogProducer
|
generateLog
|
class LogProducer {
private String serviceName;
private LogAggregator aggregator;
/**
* Generates a log entry with the given log level and message.
*
* @param level The level of the log.
* @param message The message of the log.
*/
public void generateLog(LogLevel level, String message) {<FILL_FUNCTION_BODY>}
}
|
final LogEntry logEntry = new LogEntry(serviceName, level, message, LocalDateTime.now());
LOGGER.info("Producing log: " + logEntry.getMessage());
aggregator.collectLog(logEntry);
| 102
| 56
| 158
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/marker/src/main/java/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
final var logger = LoggerFactory.getLogger(App.class);
var guard = new Guard();
var thief = new Thief();
//noinspection ConstantConditions
if (guard instanceof Permission) {
guard.enter();
} else {
logger.info("You have no permission to enter, please leave this area");
}
//noinspection ConstantConditions
if (thief instanceof Permission) {
thief.steal();
} else {
thief.doNothing();
}
| 56
| 135
| 191
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/master-worker-pattern/src/main/java/com/iluwatar/masterworker/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var mw = new ArrayTransposeMasterWorker();
var rows = 10;
var columns = 20;
var inputMatrix = ArrayUtilityMethods.createRandomIntMatrix(rows, columns);
var input = new ArrayInput(inputMatrix);
var result = (ArrayResult) mw.getResult(input);
if (result != null) {
ArrayUtilityMethods.printMatrix(inputMatrix);
ArrayUtilityMethods.printMatrix(result.data);
} else {
LOGGER.info("Please enter non-zero input");
}
| 58
| 144
| 202
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayInput.java
|
ArrayInput
|
divideData
|
class ArrayInput extends Input<int[][]> {
public ArrayInput(int[][] data) {
super(data);
}
static int[] makeDivisions(int[][] data, int num) {
var initialDivision = data.length / num; //equally dividing
var divisions = new int[num];
Arrays.fill(divisions, initialDivision);
if (initialDivision * num != data.length) {
var extra = data.length - initialDivision * num;
var l = 0;
//equally dividing extra among all parts
while (extra > 0) {
divisions[l] = divisions[l] + 1;
extra--;
if (l == num - 1) {
l = 0;
} else {
l++;
}
}
}
return divisions;
}
@Override
public List<Input<int[][]>> divideData(int num) {<FILL_FUNCTION_BODY>}
}
|
if (this.data == null) {
return null;
} else {
var divisions = makeDivisions(this.data, num);
var result = new ArrayList<Input<int[][]>>(num);
var rowsDone = 0; //number of rows divided so far
for (var i = 0; i < num; i++) {
var rows = divisions[i];
if (rows != 0) {
var divided = new int[rows][this.data[0].length];
System.arraycopy(this.data, rowsDone, divided, 0, rows);
rowsDone += rows;
var dividedInput = new ArrayInput(divided);
result.add(dividedInput);
} else {
break; //rest of divisions will also be 0
}
}
return result;
}
| 254
| 208
| 462
|
<methods>public void <init>(int[][]) ,public abstract List<Input<int[][]>> divideData(int) <variables>public final non-sealed int[][] data
|
iluwatar_java-design-patterns
|
java-design-patterns/master-worker-pattern/src/main/java/com/iluwatar/masterworker/ArrayUtilityMethods.java
|
ArrayUtilityMethods
|
createRandomIntMatrix
|
class ArrayUtilityMethods {
private static final SecureRandom RANDOM = new SecureRandom();
/**
* Method arraysSame compares 2 arrays @param a1 and @param a2 and @return whether their values
* are equal (boolean).
*/
public static boolean arraysSame(int[] a1, int[] a2) {
//compares if 2 arrays have the same value
if (a1.length != a2.length) {
return false;
} else {
var answer = false;
for (var i = 0; i < a1.length; i++) {
if (a1[i] == a2[i]) {
answer = true;
} else {
answer = false;
break;
}
}
return answer;
}
}
/**
* Method matricesSame compares 2 matrices @param m1 and @param m2 and @return whether their
* values are equal (boolean).
*/
public static boolean matricesSame(int[][] m1, int[][] m2) {
if (m1.length != m2.length) {
return false;
} else {
var answer = false;
for (var i = 0; i < m1.length; i++) {
if (arraysSame(m1[i], m2[i])) {
answer = true;
} else {
answer = false;
break;
}
}
return answer;
}
}
/**
* Method createRandomIntMatrix creates a random matrix of size @param rows and @param columns.
*
* @return it (int[][]).
*/
public static int[][] createRandomIntMatrix(int rows, int columns) {<FILL_FUNCTION_BODY>}
/**
* Method printMatrix prints input matrix @param matrix.
*/
public static void printMatrix(int[][] matrix) {
//prints out int[][]
for (var ints : matrix) {
for (var j = 0; j < matrix[0].length; j++) {
LOGGER.info(ints[j] + " ");
}
LOGGER.info("");
}
}
}
|
var matrix = new int[rows][columns];
for (var i = 0; i < rows; i++) {
for (var j = 0; j < columns; j++) {
//filling cells in matrix
matrix[i][j] = RANDOM.nextInt(10);
}
}
return matrix;
| 564
| 87
| 651
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/master-worker-pattern/src/main/java/com/iluwatar/masterworker/system/systemmaster/ArrayTransposeMaster.java
|
ArrayTransposeMaster
|
aggregateData
|
class ArrayTransposeMaster extends Master {
public ArrayTransposeMaster(int numOfWorkers) {
super(numOfWorkers);
}
@Override
ArrayList<Worker> setWorkers(int num) {
//i+1 will be id
return IntStream.range(0, num)
.mapToObj(i -> new ArrayTransposeWorker(this, i + 1))
.collect(Collectors.toCollection(() -> new ArrayList<>(num)));
}
@Override
ArrayResult aggregateData() {<FILL_FUNCTION_BODY>}
}
|
// number of rows in final result is number of rows in any of obtained results from workers
var allResultData = this.getAllResultData();
var rows = ((ArrayResult) allResultData.elements().nextElement()).data.length;
var elements = allResultData.elements();
var columns = 0; // columns = sum of number of columns in all results obtained from workers
while (elements.hasMoreElements()) {
columns += ((ArrayResult) elements.nextElement()).data[0].length;
}
var resultData = new int[rows][columns];
var columnsDone = 0; //columns aggregated so far
var workers = this.getWorkers();
for (var i = 0; i < this.getExpectedNumResults(); i++) {
//result obtained from ith worker
var worker = workers.get(i);
var workerId = worker.getWorkerId();
var work = ((ArrayResult) allResultData.get(workerId)).data;
for (var m = 0; m < work.length; m++) {
//m = row number, n = columns number
System.arraycopy(work[m], 0, resultData[m], columnsDone, work[0].length);
}
columnsDone += work[0].length;
}
return new ArrayResult(resultData);
| 150
| 323
| 473
|
<methods>public void doWork(Input<?>) ,public Result<?> getFinalResult() ,public void receiveData(Result<?>, com.iluwatar.masterworker.system.systemworkers.Worker) <variables>private final non-sealed Hashtable<java.lang.Integer,Result<?>> allResultData,private int expectedNumResults,private Result<?> finalResult,private final non-sealed int numOfWorkers,private final non-sealed List<com.iluwatar.masterworker.system.systemworkers.Worker> workers
|
iluwatar_java-design-patterns
|
java-design-patterns/master-worker-pattern/src/main/java/com/iluwatar/masterworker/system/systemmaster/Master.java
|
Master
|
divideWork
|
class Master {
private final int numOfWorkers;
private final List<Worker> workers;
private final Hashtable<Integer, Result<?>> allResultData;
private int expectedNumResults;
private Result<?> finalResult;
Master(int numOfWorkers) {
this.numOfWorkers = numOfWorkers;
this.workers = setWorkers(numOfWorkers);
this.expectedNumResults = 0;
this.allResultData = new Hashtable<>(numOfWorkers);
this.finalResult = null;
}
public Result<?> getFinalResult() {
return this.finalResult;
}
Hashtable<Integer, Result<?>> getAllResultData() {
return this.allResultData;
}
int getExpectedNumResults() {
return this.expectedNumResults;
}
List<Worker> getWorkers() {
return this.workers;
}
abstract List<Worker> setWorkers(int num);
public void doWork(Input<?> input) {
divideWork(input);
}
private void divideWork(Input<?> input) {<FILL_FUNCTION_BODY>}
public void receiveData(Result<?> data, Worker w) {
//check if can receive..if yes:
collectResult(data, w.getWorkerId());
}
private void collectResult(Result<?> data, int workerId) {
this.allResultData.put(workerId, data);
if (this.allResultData.size() == this.expectedNumResults) {
//all data received
this.finalResult = aggregateData();
}
}
abstract Result<?> aggregateData();
}
|
var dividedInput = input.divideData(numOfWorkers);
if (dividedInput != null) {
this.expectedNumResults = dividedInput.size();
for (var i = 0; i < this.expectedNumResults; i++) {
//ith division given to ith worker in this.workers
this.workers.get(i).setReceivedData(this, dividedInput.get(i));
this.workers.get(i).start();
}
for (var i = 0; i < this.expectedNumResults; i++) {
try {
this.workers.get(i).join();
} catch (InterruptedException e) {
System.err.println("Error while executing thread");
}
}
}
| 449
| 193
| 642
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/master-worker-pattern/src/main/java/com/iluwatar/masterworker/system/systemworkers/ArrayTransposeWorker.java
|
ArrayTransposeWorker
|
executeOperation
|
class ArrayTransposeWorker extends Worker {
public ArrayTransposeWorker(Master master, int id) {
super(master, id);
}
@Override
ArrayResult executeOperation() {<FILL_FUNCTION_BODY>}
}
|
//number of rows in result matrix is equal to number of columns in input matrix and vice versa
var arrayInput = (ArrayInput) this.getReceivedData();
final var rows = arrayInput.data[0].length;
final var cols = arrayInput.data.length;
var resultData = new int[rows][cols];
for (var i = 0; i < cols; i++) {
for (var j = 0; j < rows; j++) {
//flipping element positions along diagonal
resultData[j][i] = arrayInput.data[i][j];
}
}
return new ArrayResult(resultData);
| 66
| 164
| 230
|
<methods>public int getWorkerId() ,public void run() ,public void setReceivedData(com.iluwatar.masterworker.system.systemmaster.Master, Input<?>) <variables>private final non-sealed com.iluwatar.masterworker.system.systemmaster.Master master,private Input<?> receivedData,private final non-sealed int workerId
|
iluwatar_java-design-patterns
|
java-design-patterns/mediator/src/main/java/com/iluwatar/mediator/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// create party and members
Party party = new PartyImpl();
var hobbit = new Hobbit();
var wizard = new Wizard();
var rogue = new Rogue();
var hunter = new Hunter();
// add party members
party.addMember(hobbit);
party.addMember(wizard);
party.addMember(rogue);
party.addMember(hunter);
// perform actions -> the other party members
// are notified by the party
hobbit.act(Action.ENEMY);
wizard.act(Action.TALE);
rogue.act(Action.GOLD);
hunter.act(Action.HUNT);
| 56
| 179
| 235
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/mediator/src/main/java/com/iluwatar/mediator/PartyImpl.java
|
PartyImpl
|
act
|
class PartyImpl implements Party {
private final List<PartyMember> members;
public PartyImpl() {
members = new ArrayList<>();
}
@Override
public void act(PartyMember actor, Action action) {<FILL_FUNCTION_BODY>}
@Override
public void addMember(PartyMember member) {
members.add(member);
member.joinedParty(this);
}
}
|
for (var member : members) {
if (!member.equals(actor)) {
member.partyAction(action);
}
}
| 129
| 45
| 174
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/mediator/src/main/java/com/iluwatar/mediator/PartyMemberBase.java
|
PartyMemberBase
|
act
|
class PartyMemberBase implements PartyMember {
protected Party party;
@Override
public void joinedParty(Party party) {
LOGGER.info("{} joins the party", this);
this.party = party;
}
@Override
public void partyAction(Action action) {
LOGGER.info("{} {}", this, action.getDescription());
}
@Override
public void act(Action action) {<FILL_FUNCTION_BODY>}
@Override
public abstract String toString();
}
|
if (party != null) {
LOGGER.info("{} {}", this, action);
party.act(this, action);
}
| 159
| 45
| 204
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/memento/src/main/java/com/iluwatar/memento/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var states = new Stack<StarMemento>();
var star = new Star(StarType.SUN, 10000000, 500000);
LOGGER.info(star.toString());
states.add(star.getMemento());
star.timePasses();
LOGGER.info(star.toString());
states.add(star.getMemento());
star.timePasses();
LOGGER.info(star.toString());
states.add(star.getMemento());
star.timePasses();
LOGGER.info(star.toString());
states.add(star.getMemento());
star.timePasses();
LOGGER.info(star.toString());
while (states.size() > 0) {
star.setMemento(states.pop());
LOGGER.info(star.toString());
}
| 44
| 228
| 272
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/memento/src/main/java/com/iluwatar/memento/Star.java
|
Star
|
getMemento
|
class Star {
private StarType type;
private int ageYears;
private int massTons;
/**
* Constructor.
*/
public Star(StarType startType, int startAge, int startMass) {
this.type = startType;
this.ageYears = startAge;
this.massTons = startMass;
}
/**
* Makes time pass for the star.
*/
public void timePasses() {
ageYears *= 2;
massTons *= 8;
switch (type) {
case RED_GIANT -> type = StarType.WHITE_DWARF;
case SUN -> type = StarType.RED_GIANT;
case SUPERNOVA -> type = StarType.DEAD;
case WHITE_DWARF -> type = StarType.SUPERNOVA;
case DEAD -> {
ageYears *= 2;
massTons = 0;
}
default -> {
}
}
}
StarMemento getMemento() {<FILL_FUNCTION_BODY>}
void setMemento(StarMemento memento) {
var state = (StarMementoInternal) memento;
this.type = state.getType();
this.ageYears = state.getAgeYears();
this.massTons = state.getMassTons();
}
@Override
public String toString() {
return String.format("%s age: %d years mass: %d tons", type.toString(), ageYears, massTons);
}
/**
* StarMemento implementation.
*/
private static class StarMementoInternal implements StarMemento {
private StarType type;
private int ageYears;
private int massTons;
public StarType getType() {
return type;
}
public void setType(StarType type) {
this.type = type;
}
public int getAgeYears() {
return ageYears;
}
public void setAgeYears(int ageYears) {
this.ageYears = ageYears;
}
public int getMassTons() {
return massTons;
}
public void setMassTons(int massTons) {
this.massTons = massTons;
}
}
}
|
var state = new StarMementoInternal();
state.setAgeYears(ageYears);
state.setMassTons(massTons);
state.setType(type);
return state;
| 632
| 56
| 688
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/metadata-mapping/src/main/java/com/iluwatar/metamapping/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args.
* @throws Exception if any error occurs.
*/
public static void main(String[] args) throws Exception {<FILL_FUNCTION_BODY>}
/**
* Generate users.
*
* @return list of users.
*/
public static List<User> generateSampleUsers() {
final var user1 = new User("ZhangSan", "zhs123");
final var user2 = new User("LiSi", "ls123");
final var user3 = new User("WangWu", "ww123");
return List.of(user1, user2, user3);
}
}
|
// get service
var userService = new UserService();
// use create service to add users
for (var user : generateSampleUsers()) {
var id = userService.createUser(user);
LOGGER.info("Add user" + user + "at" + id + ".");
}
// use list service to get users
var users = userService.listUser();
LOGGER.info(String.valueOf(users));
// use get service to get a user
var user = userService.getUser(1);
LOGGER.info(String.valueOf(user));
// change password of user 1
user.setPassword("new123");
// use update service to update user 1
userService.updateUser(1, user);
// use delete service to delete user 2
userService.deleteUser(2);
// close service
userService.close();
| 189
| 224
| 413
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/metadata-mapping/src/main/java/com/iluwatar/metamapping/service/UserService.java
|
UserService
|
createUser
|
class UserService {
private static final SessionFactory factory = HibernateUtil.getSessionFactory();
/**
* List all users.
* @return list of users
*/
public List<User> listUser() {
LOGGER.info("list all users.");
List<User> users = new ArrayList<>();
try (var session = factory.openSession()) {
var tx = session.beginTransaction();
List<User> userIter = session.createQuery("FROM User").list();
for (var iterator = userIter.iterator(); iterator.hasNext();) {
users.add(iterator.next());
}
tx.commit();
} catch (HibernateException e) {
LOGGER.debug("fail to get users", e);
}
return users;
}
/**
* Add a user.
* @param user user entity
* @return user id
*/
public int createUser(User user) {<FILL_FUNCTION_BODY>}
/**
* Update user.
* @param id user id
* @param user new user entity
*/
public void updateUser(Integer id, User user) {
LOGGER.info("update user at " + id);
try (var session = factory.openSession()) {
var tx = session.beginTransaction();
user.setId(id);
session.update(user);
tx.commit();
} catch (HibernateException e) {
LOGGER.debug("fail to update user", e);
}
}
/**
* Delete user.
* @param id user id
*/
public void deleteUser(Integer id) {
LOGGER.info("delete user at: " + id);
try (var session = factory.openSession()) {
var tx = session.beginTransaction();
var user = session.get(User.class, id);
session.delete(user);
tx.commit();
} catch (HibernateException e) {
LOGGER.debug("fail to delete user", e);
}
}
/**
* Get user.
* @param id user id
* @return deleted user
*/
public User getUser(Integer id) {
LOGGER.info("get user at: " + id);
User user = null;
try (var session = factory.openSession()) {
var tx = session.beginTransaction();
user = session.get(User.class, id);
tx.commit();
} catch (HibernateException e) {
LOGGER.debug("fail to get user", e);
}
return user;
}
/**
* Close hibernate.
*/
public void close() {
HibernateUtil.shutdown();
}
}
|
LOGGER.info("create user: " + user.getUsername());
var id = -1;
try (var session = factory.openSession()) {
var tx = session.beginTransaction();
id = (Integer) session.save(user);
tx.commit();
} catch (HibernateException e) {
LOGGER.debug("fail to create user", e);
}
LOGGER.info("create user " + user.getUsername() + " at " + id);
return id;
| 695
| 129
| 824
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/metadata-mapping/src/main/java/com/iluwatar/metamapping/utils/HibernateUtil.java
|
HibernateUtil
|
buildSessionFactory
|
class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();
/**
* Hide constructor.
*/
private HibernateUtil() {}
/**
* Build session factory.
* @return session factory
*/
private static SessionFactory buildSessionFactory() {<FILL_FUNCTION_BODY>}
/**
* Get session factory.
* @return session factory
*/
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* Close session factory.
*/
public static void shutdown() {
// Close caches and connection pools
getSessionFactory().close();
}
}
|
// Create the SessionFactory from hibernate.cfg.xml
return new Configuration().configure().buildSessionFactory();
| 175
| 30
| 205
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-controller/src/main/java/com/iluwatar/model/view/controller/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// create model, view and controller
var giant = new GiantModel(Health.HEALTHY, Fatigue.ALERT, Nourishment.SATURATED);
var view = new GiantView();
var controller = new GiantController(giant, view);
// initial display
controller.updateView();
// controller receives some interactions that affect the giant
controller.setHealth(Health.WOUNDED);
controller.setNourishment(Nourishment.HUNGRY);
controller.setFatigue(Fatigue.TIRED);
// redisplay
controller.updateView();
| 56
| 152
| 208
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-controller/src/main/java/com/iluwatar/model/view/controller/GiantModel.java
|
GiantModel
|
toString
|
class GiantModel {
private Health health;
private Fatigue fatigue;
private Nourishment nourishment;
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return String.format("The giant looks %s, %s and %s.", health, fatigue, nourishment);
| 58
| 30
| 88
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-intent/src/main/java/com/iluwatar/model/view/intent/App.java
|
App
|
main
|
class App {
/**
* To avoid magic value lint error.
*/
private static final double RANDOM_VARIABLE = 10.0;
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(final String[] args) {<FILL_FUNCTION_BODY>}
/**
* Avoid default constructor lint error.
*/
private App() {
}
}
|
// create model, view and controller
// initialize calculator view, output and variable = 0
var view = new CalculatorView(new CalculatorViewModel());
var variable1 = RANDOM_VARIABLE;
// calculator variable = RANDOM_VARIABLE -> 10.0
view.setVariable(variable1);
// add calculator variable to output -> calculator output = 10.0
view.add();
view.displayTotal(); // display output
variable1 = 2.0;
view.setVariable(variable1); // calculator variable = 2.0
// subtract calculator variable from output -> calculator output = 8
view.subtract();
// divide calculator output by variable -> calculator output = 4.0
view.divide();
// multiply calculator output by variable -> calculator output = 8.0
view.multiply();
view.displayTotal();
| 122
| 240
| 362
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-intent/src/main/java/com/iluwatar/model/view/intent/CalculatorViewModel.java
|
CalculatorViewModel
|
handleAction
|
class CalculatorViewModel {
/**
* Current calculator model (can be changed).
*/
private CalculatorModel model =
new CalculatorModel(0.0, 0.0);
/**
* Handle calculator action.
*
* @param action -> transforms calculator model.
*/
void handleAction(final CalculatorAction action) {<FILL_FUNCTION_BODY>}
/**
* Getter.
*
* @return current calculator model.
*/
public CalculatorModel getCalculatorModel() {
return model;
}
/**
* Set new calculator model variable.
*
* @param variable -> value of new calculator model variable.
*/
private void setVariable(final Double variable) {
model = new CalculatorModel(
variable,
model.getOutput()
);
}
/**
* Add variable to model output.
*/
private void add() {
model = new CalculatorModel(
model.getVariable(),
model.getOutput() + model.getVariable()
);
}
/**
* Subtract variable from model output.
*/
private void subtract() {
model = new CalculatorModel(
model.getVariable(),
model.getOutput() - model.getVariable()
);
}
/**
* Multiply model output by variable.
*/
private void multiply() {
model = new CalculatorModel(
model.getVariable(),
model.getOutput() * model.getVariable()
);
}
/**
* Divide model output by variable.
*/
private void divide() {
model = new CalculatorModel(
model.getVariable(),
model.getOutput() / model.getVariable()
);
}
}
|
switch (action.tag()) {
case AdditionCalculatorAction.TAG -> add();
case SubtractionCalculatorAction.TAG -> subtract();
case MultiplicationCalculatorAction.TAG -> multiply();
case DivisionCalculatorAction.TAG -> divide();
case SetVariableCalculatorAction.TAG -> {
SetVariableCalculatorAction setVariableAction =
(SetVariableCalculatorAction) action;
setVariable(setVariableAction.getVariable());
}
default -> {
}
}
| 468
| 132
| 600
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-presenter/src/main/java/com/iluwatar/model/view/presenter/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var loader = new FileLoader();
var frame = new FileSelectorJframe();
var presenter = new FileSelectorPresenter(frame);
presenter.setLoader(loader);
presenter.start();
| 56
| 54
| 110
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-presenter/src/main/java/com/iluwatar/model/view/presenter/FileLoader.java
|
FileLoader
|
loadData
|
class FileLoader implements Serializable {
/**
* Generated serial version UID.
*/
private static final long serialVersionUID = -4745803872902019069L;
private static final Logger LOGGER = LoggerFactory.getLogger(FileLoader.class);
/**
* Indicates if the file is loaded or not.
*/
private boolean loaded;
/**
* The name of the file that we want to load.
*/
private String fileName;
/**
* Loads the data of the file specified.
*/
public String loadData() {<FILL_FUNCTION_BODY>}
/**
* Sets the path of the file to be loaded, to the given value.
*
* @param fileName The path of the file to be loaded.
*/
public void setFileName(String fileName) {
this.fileName = fileName;
}
/**
* Gets the path of the file to be loaded.
*
* @return fileName The path of the file to be loaded.
*/
public String getFileName() {
return this.fileName;
}
/**
* Returns true if the given file exists.
*
* @return True, if the file given exists, false otherwise.
*/
public boolean fileExists() {
return new File(this.fileName).exists();
}
/**
* Returns true if the given file is loaded.
*
* @return True, if the file is loaded, false otherwise.
*/
public boolean isLoaded() {
return this.loaded;
}
}
|
var dataFileName = this.fileName;
try (var br = new BufferedReader(new FileReader(new File(dataFileName)))) {
var result = br.lines().collect(Collectors.joining("\n"));
this.loaded = true;
return result;
} catch (Exception e) {
LOGGER.error("File {} does not exist", dataFileName);
}
return null;
| 421
| 104
| 525
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-presenter/src/main/java/com/iluwatar/model/view/presenter/FileSelectorJframe.java
|
FileSelectorJframe
|
actionPerformed
|
class FileSelectorJframe extends JFrame implements FileSelectorView, ActionListener {
/**
* Default serial version ID.
*/
private static final long serialVersionUID = 1L;
/**
* The "OK" button for loading the file.
*/
private final JButton ok;
/**
* The cancel button.
*/
private final JButton cancel;
/**
* The text field for giving the name of the file that we want to open.
*/
private final JTextField input;
/**
* A text area that will keep the contents of the file opened.
*/
private final JTextArea area;
/**
* The Presenter component that the frame will interact with.
*/
private FileSelectorPresenter presenter;
/**
* The name of the file that we want to read it's contents.
*/
private String fileName;
/**
* Constructor.
*/
public FileSelectorJframe() {
super("File Loader");
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setLayout(null);
this.setBounds(100, 100, 500, 200);
/*
* Add the panel.
*/
var panel = new JPanel();
panel.setLayout(null);
this.add(panel);
panel.setBounds(0, 0, 500, 200);
panel.setBackground(Color.LIGHT_GRAY);
/*
* Add the info label.
*/
var info = new JLabel("File Name :");
panel.add(info);
info.setBounds(30, 10, 100, 30);
/*
* Add the contents label.
*/
var contents = new JLabel("File contents :");
panel.add(contents);
contents.setBounds(30, 100, 120, 30);
/*
* Add the text field.
*/
this.input = new JTextField(100);
panel.add(input);
this.input.setBounds(150, 15, 200, 20);
/*
* Add the text area.
*/
this.area = new JTextArea(100, 100);
var pane = new JScrollPane(area);
pane.setHorizontalScrollBarPolicy(HORIZONTAL_SCROLLBAR_AS_NEEDED);
pane.setVerticalScrollBarPolicy(VERTICAL_SCROLLBAR_AS_NEEDED);
panel.add(pane);
this.area.setEditable(false);
pane.setBounds(150, 100, 250, 80);
/*
* Add the OK button.
*/
this.ok = new JButton("OK");
panel.add(ok);
this.ok.setBounds(250, 50, 100, 25);
this.ok.addActionListener(this);
/*
* Add the cancel button.
*/
this.cancel = new JButton("Cancel");
panel.add(this.cancel);
this.cancel.setBounds(380, 50, 100, 25);
this.cancel.addActionListener(this);
this.presenter = null;
this.fileName = null;
}
@Override
public void actionPerformed(ActionEvent e) {<FILL_FUNCTION_BODY>}
@Override
public void open() {
this.setVisible(true);
}
@Override
public void close() {
this.dispose();
}
@Override
public boolean isOpened() {
return this.isVisible();
}
@Override
public void setPresenter(FileSelectorPresenter presenter) {
this.presenter = presenter;
}
@Override
public FileSelectorPresenter getPresenter() {
return this.presenter;
}
@Override
public void setFileName(String name) {
this.fileName = name;
}
@Override
public String getFileName() {
return this.fileName;
}
@Override
public void showMessage(String message) {
JOptionPane.showMessageDialog(null, message);
}
@Override
public void displayData(String data) {
this.area.setText(data);
}
}
|
if (this.ok.equals(e.getSource())) {
this.fileName = this.input.getText();
presenter.fileNameChanged();
presenter.confirmed();
} else if (this.cancel.equals(e.getSource())) {
presenter.cancelled();
}
| 1,168
| 79
| 1,247
|
<methods>public void <init>() throws java.awt.HeadlessException,public void <init>(java.awt.GraphicsConfiguration) ,public void <init>(java.lang.String) throws java.awt.HeadlessException,public void <init>(java.lang.String, java.awt.GraphicsConfiguration) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public java.awt.Container getContentPane() ,public int getDefaultCloseOperation() ,public java.awt.Component getGlassPane() ,public java.awt.Graphics getGraphics() ,public javax.swing.JMenuBar getJMenuBar() ,public javax.swing.JLayeredPane getLayeredPane() ,public javax.swing.JRootPane getRootPane() ,public javax.swing.TransferHandler getTransferHandler() ,public static boolean isDefaultLookAndFeelDecorated() ,public void remove(java.awt.Component) ,public void repaint(long, int, int, int, int) ,public void setContentPane(java.awt.Container) ,public void setDefaultCloseOperation(int) ,public static void setDefaultLookAndFeelDecorated(boolean) ,public void setGlassPane(java.awt.Component) ,public void setIconImage(java.awt.Image) ,public void setJMenuBar(javax.swing.JMenuBar) ,public void setLayeredPane(javax.swing.JLayeredPane) ,public void setLayout(java.awt.LayoutManager) ,public void setTransferHandler(javax.swing.TransferHandler) ,public void update(java.awt.Graphics) <variables>protected javax.accessibility.AccessibleContext accessibleContext,private int defaultCloseOperation,private static final java.lang.Object defaultLookAndFeelDecoratedKey,protected javax.swing.JRootPane rootPane,protected boolean rootPaneCheckingEnabled,private javax.swing.TransferHandler transferHandler
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-presenter/src/main/java/com/iluwatar/model/view/presenter/FileSelectorPresenter.java
|
FileSelectorPresenter
|
confirmed
|
class FileSelectorPresenter implements Serializable {
/**
* Generated serial version UID.
*/
private static final long serialVersionUID = 1210314339075855074L;
/**
* The View component that the presenter interacts with.
*/
private final FileSelectorView view;
/**
* The Model component that the presenter interacts with.
*/
private FileLoader loader;
/**
* Constructor.
*
* @param view The view component that the presenter will interact with.
*/
public FileSelectorPresenter(FileSelectorView view) {
this.view = view;
}
/**
* Sets the {@link FileLoader} object, to the value given as parameter.
*
* @param loader The new {@link FileLoader} object(the Model component).
*/
public void setLoader(FileLoader loader) {
this.loader = loader;
}
/**
* Starts the presenter.
*/
public void start() {
view.setPresenter(this);
view.open();
}
/**
* An "event" that fires when the name of the file to be loaded changes.
*/
public void fileNameChanged() {
loader.setFileName(view.getFileName());
}
/**
* Ok button handler.
*/
public void confirmed() {<FILL_FUNCTION_BODY>}
/**
* Cancels the file loading process.
*/
public void cancelled() {
view.close();
}
}
|
if (loader.getFileName() == null || loader.getFileName().equals("")) {
view.showMessage("Please give the name of the file first!");
return;
}
if (loader.fileExists()) {
var data = loader.loadData();
view.displayData(data);
} else {
view.showMessage("The file specified does not exist.");
}
| 408
| 100
| 508
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/model-view-viewmodel/src/main/java/com/iluwatar/model/view/viewmodel/BookViewModel.java
|
BookViewModel
|
deleteBook
|
class BookViewModel {
@WireVariable
private List<Book> bookList;
private Book selectedBook;
private BookService bookService = new BookServiceImpl();
public Book getSelectedBook() {
return selectedBook;
}
@NotifyChange("selectedBook")
public void setSelectedBook(Book selectedBook) {
this.selectedBook = selectedBook;
}
public List<Book> getBookList() {
return bookService.load();
}
/** Deleting a book.
* When event is triggered on click of Delete button,
* this method will be notified with the selected entry that will be referenced
* and used to delete the selected book from the list of books.
*/
@Command
@NotifyChange({"selectedBook", "bookList"})
public void deleteBook() {<FILL_FUNCTION_BODY>}
}
|
if (selectedBook != null) {
getBookList().remove(selectedBook);
selectedBook = null;
}
| 230
| 35
| 265
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/module/src/main/java/com/iluwatar/module/App.java
|
App
|
execute
|
class App {
private static final String ERROR = "Error";
private static final String MESSAGE = "Message";
public static FileLoggerModule fileLoggerModule;
public static ConsoleLoggerModule consoleLoggerModule;
/**
* Following method performs the initialization.
*
* @throws FileNotFoundException if program is not able to find log files (output.txt and
* error.txt)
*/
public static void prepare() throws FileNotFoundException {
/* Create new singleton objects and prepare their modules */
fileLoggerModule = FileLoggerModule.getSingleton().prepare();
consoleLoggerModule = ConsoleLoggerModule.getSingleton().prepare();
}
/**
* Following method performs the finalization.
*/
public static void unprepare() {
/* Close all resources */
fileLoggerModule.unprepare();
consoleLoggerModule.unprepare();
}
/**
* Following method is main executor.
*/
public static void execute() {<FILL_FUNCTION_BODY>}
/**
* Program entry point.
*
* @param args command line args.
* @throws FileNotFoundException if program is not able to find log files (output.txt and
* error.txt)
*/
public static void main(final String... args) throws FileNotFoundException {
prepare();
execute();
unprepare();
}
}
|
/* Send logs on file system */
fileLoggerModule.printString(MESSAGE);
fileLoggerModule.printErrorString(ERROR);
/* Send logs on console */
consoleLoggerModule.printString(MESSAGE);
consoleLoggerModule.printErrorString(ERROR);
| 392
| 81
| 473
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/module/src/main/java/com/iluwatar/module/ConsoleLoggerModule.java
|
ConsoleLoggerModule
|
unprepare
|
class ConsoleLoggerModule {
private static ConsoleLoggerModule singleton = null;
public PrintStream output = null;
public PrintStream error = null;
private ConsoleLoggerModule() {
}
/**
* Static method to get single instance of class.
*
* @return singleton instance of ConsoleLoggerModule
*/
public static ConsoleLoggerModule getSingleton() {
if (ConsoleLoggerModule.singleton == null) {
ConsoleLoggerModule.singleton = new ConsoleLoggerModule();
}
return ConsoleLoggerModule.singleton;
}
/**
* Following method performs the initialization.
*/
public ConsoleLoggerModule prepare() {
LOGGER.debug("ConsoleLoggerModule::prepare();");
this.output = new PrintStream(System.out);
this.error = new PrintStream(System.err);
return this;
}
/**
* Following method performs the finalization.
*/
public void unprepare() {<FILL_FUNCTION_BODY>}
/**
* Used to print a message.
*
* @param value will be printed on console
*/
public void printString(final String value) {
this.output.println(value);
}
/**
* Used to print a error message.
*
* @param value will be printed on error console
*/
public void printErrorString(final String value) {
this.error.println(value);
}
}
|
if (this.output != null) {
this.output.flush();
this.output.close();
}
if (this.error != null) {
this.error.flush();
this.error.close();
}
LOGGER.debug("ConsoleLoggerModule::unprepare();");
| 432
| 100
| 532
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/module/src/main/java/com/iluwatar/module/FileLoggerModule.java
|
FileLoggerModule
|
getSingleton
|
class FileLoggerModule {
private static FileLoggerModule singleton = null;
private static final String OUTPUT_FILE = "output.txt";
private static final String ERROR_FILE = "error.txt";
public PrintStream output = null;
public PrintStream error = null;
private FileLoggerModule() {
}
/**
* Static method to get single instance of class.
*
* @return singleton instance of FileLoggerModule
*/
public static FileLoggerModule getSingleton() {<FILL_FUNCTION_BODY>}
/**
* Following method performs the initialization.
*
* @throws FileNotFoundException if program is not able to find log files (output.txt and
* error.txt)
*/
public FileLoggerModule prepare() throws FileNotFoundException {
LOGGER.debug("FileLoggerModule::prepare();");
this.output = new PrintStream(new FileOutputStream(OUTPUT_FILE));
this.error = new PrintStream(new FileOutputStream(ERROR_FILE));
return this;
}
/**
* Following method performs the finalization.
*/
public void unprepare() {
if (this.output != null) {
this.output.flush();
this.output.close();
}
if (this.error != null) {
this.error.flush();
this.error.close();
}
LOGGER.debug("FileLoggerModule::unprepare();");
}
/**
* Used to print a message.
*
* @param value will be printed in file
*/
public void printString(final String value) {
this.output.println(value);
}
/**
* Used to print a error message.
*
* @param value will be printed on error file
*/
public void printErrorString(final String value) {
this.error.println(value);
}
}
|
if (FileLoggerModule.singleton == null) {
FileLoggerModule.singleton = new FileLoggerModule();
}
return FileLoggerModule.singleton;
| 563
| 53
| 616
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monad/src/main/java/com/iluwatar/monad/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var user = new User("user", 24, Sex.FEMALE, "foobar.com");
LOGGER.info(Validator.of(user).validate(User::name, Objects::nonNull, "name is null")
.validate(User::name, name -> !name.isEmpty(), "name is empty")
.validate(User::email, email -> !email.contains("@"), "email doesn't contains '@'")
.validate(User::age, age -> age > 20 && age < 30, "age isn't between...").get()
.toString());
| 64
| 155
| 219
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monad/src/main/java/com/iluwatar/monad/Validator.java
|
Validator
|
get
|
class Validator<T> {
/**
* Object that is validated.
*/
private final T obj;
/**
* List of exception thrown during validation.
*/
private final List<Throwable> exceptions = new ArrayList<>();
/**
* Creates a monadic value of given object.
*
* @param obj object to be validated
*/
private Validator(T obj) {
this.obj = obj;
}
/**
* Creates validator against given object.
*
* @param t object to be validated
* @param <T> object's type
* @return new instance of a validator
*/
public static <T> Validator<T> of(T t) {
return new Validator<>(Objects.requireNonNull(t));
}
/**
* Checks if the validation is successful.
*
* @param validation one argument boolean-valued function that represents one step of validation.
* Adds exception to main validation exception list when single step validation
* ends with failure.
* @param message error message when object is invalid
* @return this
*/
public Validator<T> validate(Predicate<? super T> validation, String message) {
if (!validation.test(obj)) {
exceptions.add(new IllegalStateException(message));
}
return this;
}
/**
* Extension for the {@link Validator#validate(Predicate, String)} method, dedicated for objects,
* that need to be projected before requested validation.
*
* @param projection function that gets an objects, and returns projection representing element to
* be validated.
* @param validation see {@link Validator#validate(Predicate, String)}
* @param message see {@link Validator#validate(Predicate, String)}
* @param <U> see {@link Validator#validate(Predicate, String)}
* @return this
*/
public <U> Validator<T> validate(
Function<? super T, ? extends U> projection,
Predicate<? super U> validation,
String message
) {
return validate(projection.andThen(validation::test)::apply, message);
}
/**
* Receives validated object or throws exception when invalid.
*
* @return object that was validated
* @throws IllegalStateException when any validation step results with failure
*/
public T get() throws IllegalStateException {<FILL_FUNCTION_BODY>}
}
|
if (exceptions.isEmpty()) {
return obj;
}
var e = new IllegalStateException();
exceptions.forEach(e::addSuppressed);
throw e;
| 707
| 55
| 762
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monitor/src/main/java/com/iluwatar/monitor/Bank.java
|
Bank
|
transfer
|
class Bank {
private final int[] accounts;
/**
* Constructor.
*
* @param accountNum - account number
* @param baseAmount - base amount
*/
public Bank(int accountNum, int baseAmount) {
accounts = new int[accountNum];
Arrays.fill(accounts, baseAmount);
}
/**
* Transfer amounts from one account to another.
*
* @param accountA - source account
* @param accountB - destination account
* @param amount - amount to be transferred
*/
public synchronized void transfer(int accountA, int accountB, int amount) {<FILL_FUNCTION_BODY>}
/**
* Calculates the total balance.
*
* @return balance
*/
public synchronized int getBalance() {
int balance = 0;
for (int account : accounts) {
balance += account;
}
return balance;
}
/**
* Get the accountNumber balance.
*
* @param accountNumber - accountNumber number
* @return accounts[accountNumber]
*/
public synchronized int getBalance(int accountNumber) {
return accounts[accountNumber];
}
/**
* Get all accounts.
*
* @return accounts
*/
public int[] getAccounts() {
return accounts;
}
}
|
if (accounts[accountA] >= amount && accountA != accountB) {
accounts[accountB] += amount;
accounts[accountA] -= amount;
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"Transferred from account: {} to account: {} , amount: {} , bank balance at: {}, source account balance: {}, destination account balance: {}",
accountA,
accountB,
amount,
getBalance(),
getBalance(accountA),
getBalance(accountB));
}
}
| 353
| 143
| 496
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monitor/src/main/java/com/iluwatar/monitor/Main.java
|
Main
|
main
|
class Main {
private static final int NUMBER_OF_THREADS = 5;
private static final int BASE_AMOUNT = 1000;
private static final int ACCOUNT_NUM = 4;
/**
* Runner to perform a bunch of transfers and handle exception.
*
* @param bank bank object
* @param latch signal finished execution
*/
public static void runner(Bank bank, CountDownLatch latch) {
try {
SecureRandom random = new SecureRandom();
Thread.sleep(random.nextInt(1000));
LOGGER.info("Start transferring...");
for (int i = 0; i < 1000000; i++) {
bank.transfer(random.nextInt(4), random.nextInt(4), random.nextInt(0, BASE_AMOUNT));
}
LOGGER.info("Finished transferring.");
latch.countDown();
} catch (InterruptedException e) {
LOGGER.error(e.getMessage());
Thread.currentThread().interrupt();
}
}
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) throws InterruptedException {<FILL_FUNCTION_BODY>}
}
|
var bank = new Bank(ACCOUNT_NUM, BASE_AMOUNT);
var latch = new CountDownLatch(NUMBER_OF_THREADS);
var executorService = Executors.newFixedThreadPool(NUMBER_OF_THREADS);
for (int i = 0; i < NUMBER_OF_THREADS; i++) {
executorService.execute(() -> runner(bank, latch));
}
latch.await();
| 337
| 123
| 460
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monostate/src/main/java/com/iluwatar/monostate/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var loadBalancer1 = new LoadBalancer();
var loadBalancer2 = new LoadBalancer();
loadBalancer1.serverRequest(new Request("Hello"));
loadBalancer2.serverRequest(new Request("Hello World"));
| 56
| 60
| 116
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monostate/src/main/java/com/iluwatar/monostate/LoadBalancer.java
|
LoadBalancer
|
serverRequest
|
class LoadBalancer {
private static final List<Server> SERVERS = new ArrayList<>();
private static int lastServedId;
static {
var id = 0;
for (var port : new int[]{8080, 8081, 8082, 8083, 8084}) {
SERVERS.add(new Server("localhost", port, ++id));
}
}
/**
* Add new server.
*/
public final void addServer(Server server) {
synchronized (SERVERS) {
SERVERS.add(server);
}
}
public final int getNoOfServers() {
return SERVERS.size();
}
public int getLastServedId() {
return lastServedId;
}
/**
* Handle request.
*/
public synchronized void serverRequest(Request request) {<FILL_FUNCTION_BODY>}
}
|
if (lastServedId >= SERVERS.size()) {
lastServedId = 0;
}
var server = SERVERS.get(lastServedId++);
server.serve(request);
| 250
| 56
| 306
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/monostate/src/main/java/com/iluwatar/monostate/Server.java
|
Server
|
serve
|
class Server {
public final String host;
public final int port;
public final int id;
/**
* Constructor.
*/
public Server(String host, int port, int id) {
this.host = host;
this.port = port;
this.id = id;
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
public void serve(Request request) {<FILL_FUNCTION_BODY>}
}
|
LOGGER.info("Server ID {} associated to host : {} and port {}. Processed request with value {}",
id, host, port, request.value);
| 140
| 41
| 181
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/multiton/src/main/java/com/iluwatar/multiton/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// eagerly initialized multiton
LOGGER.info("Printing out eagerly initialized multiton contents");
LOGGER.info("KHAMUL={}", Nazgul.getInstance(NazgulName.KHAMUL));
LOGGER.info("MURAZOR={}", Nazgul.getInstance(NazgulName.MURAZOR));
LOGGER.info("DWAR={}", Nazgul.getInstance(NazgulName.DWAR));
LOGGER.info("JI_INDUR={}", Nazgul.getInstance(NazgulName.JI_INDUR));
LOGGER.info("AKHORAHIL={}", Nazgul.getInstance(NazgulName.AKHORAHIL));
LOGGER.info("HOARMURATH={}", Nazgul.getInstance(NazgulName.HOARMURATH));
LOGGER.info("ADUNAPHEL={}", Nazgul.getInstance(NazgulName.ADUNAPHEL));
LOGGER.info("REN={}", Nazgul.getInstance(NazgulName.REN));
LOGGER.info("UVATHA={}", Nazgul.getInstance(NazgulName.UVATHA));
// enum multiton
LOGGER.info("Printing out enum-based multiton contents");
LOGGER.info("KHAMUL={}", NazgulEnum.KHAMUL);
LOGGER.info("MURAZOR={}", NazgulEnum.MURAZOR);
LOGGER.info("DWAR={}", NazgulEnum.DWAR);
LOGGER.info("JI_INDUR={}", NazgulEnum.JI_INDUR);
LOGGER.info("AKHORAHIL={}", NazgulEnum.AKHORAHIL);
LOGGER.info("HOARMURATH={}", NazgulEnum.HOARMURATH);
LOGGER.info("ADUNAPHEL={}", NazgulEnum.ADUNAPHEL);
LOGGER.info("REN={}", NazgulEnum.REN);
LOGGER.info("UVATHA={}", NazgulEnum.UVATHA);
| 56
| 567
| 623
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/mute-idiom/src/main/java/com/iluwatar/mute/App.java
|
App
|
useOfLoggedMute
|
class App {
/**
* Program entry point.
*
* @param args command line args.
*/
public static void main(String[] args) {
useOfLoggedMute();
useOfMute();
}
/*
* Typically used when the API declares some exception but cannot do so. Usually a
* signature mistake.In this example out is not supposed to throw exception as it is a
* ByteArrayOutputStream. So we utilize mute, which will throw AssertionError if unexpected
* exception occurs.
*/
private static void useOfMute() {
var out = new ByteArrayOutputStream();
Mute.mute(() -> out.write("Hello".getBytes()));
}
private static void useOfLoggedMute() {<FILL_FUNCTION_BODY>}
/*
* All we can do while failed close of a resource is to log it.
*/
private static void closeResource(Resource resource) {
Mute.loggedMute(resource::close);
}
private static void utilizeResource(Resource resource) {
LOGGER.info("Utilizing acquired resource: {}", resource);
}
private static Resource acquireResource() {
return new Resource() {
@Override
public void close() throws IOException {
throw new IOException("Error in closing resource: " + this);
}
};
}
}
|
Optional<Resource> resource = Optional.empty();
try {
resource = Optional.of(acquireResource());
utilizeResource(resource.get());
} finally {
resource.ifPresent(App::closeResource);
}
| 350
| 60
| 410
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/mute-idiom/src/main/java/com/iluwatar/mute/Mute.java
|
Mute
|
mute
|
class Mute {
// The constructor is never meant to be called.
private Mute() {
}
/**
* Executes the <code>runnable</code> and throws the exception occurred within a {@link
* AssertionError}. This method should be utilized to mute the operations that are guaranteed not
* to throw an exception. For instance {@link ByteArrayOutputStream#write(byte[])} declares in
* it's signature that it can throw an {@link IOException}, but in reality it cannot. This is
* because the bulk write method is not overridden in {@link ByteArrayOutputStream}.
*
* @param runnable a runnable that should never throw an exception on execution.
*/
public static void mute(CheckedRunnable runnable) {<FILL_FUNCTION_BODY>}
/**
* Executes the <code>runnable</code> and logs the exception occurred on {@link System#err}. This
* method should be utilized to mute the operations about which most you can do is log. For
* instance while closing a connection to database, or cleaning up a resource, all you can do is
* log the exception occurred.
*
* @param runnable a runnable that may throw an exception on execution.
*/
public static void loggedMute(CheckedRunnable runnable) {
try {
runnable.run();
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
try {
runnable.run();
} catch (Exception e) {
throw new AssertionError(e);
}
| 370
| 37
| 407
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/notification/src/main/java/com/iluwatar/NotificationError.java
|
NotificationError
|
toString
|
class NotificationError {
private int errorId;
private String errorMessage;
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "Error " + errorId + ": " + errorMessage;
| 47
| 20
| 67
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/notification/src/main/java/com/iluwatar/RegisterWorker.java
|
RegisterWorker
|
validate
|
class RegisterWorker extends ServerCommand {
static final int LEGAL_AGE = 18;
protected RegisterWorker(RegisterWorkerDto worker) {
super(worker);
}
/**
* Validates the data provided and adds it to the database in the backend.
*/
public void run() {
validate();
if (!super.getNotification().hasErrors()) {
LOGGER.info("Register worker in backend system");
}
}
/**
* Validates our data. Checks for any errors and if found, adds to notification.
*/
private void validate() {<FILL_FUNCTION_BODY>}
/**
* Validates for null/empty value.
*
* @param obj any object
* @return boolean
*/
protected boolean isNullOrBlank(Object obj) {
if (obj == null) {
return true;
}
if (obj instanceof String) {
return ((String) obj).trim().isEmpty();
}
return false;
}
/**
* If a condition is met, adds the error to our notification.
*
* @param condition condition to check for.
* @param error error to add if condition met.
*/
protected void fail(boolean condition, NotificationError error) {
if (condition) {
super.getNotification().addError(error);
}
}
}
|
var ourData = ((RegisterWorkerDto) this.data);
//check if any of submitted data is not given
// passing for empty value validation
fail(isNullOrBlank(ourData.getName()), RegisterWorkerDto.MISSING_NAME);
fail(isNullOrBlank(ourData.getOccupation()), RegisterWorkerDto.MISSING_OCCUPATION);
fail(isNullOrBlank(ourData.getDateOfBirth()), RegisterWorkerDto.MISSING_DOB);
if (isNullOrBlank(ourData.getDateOfBirth())) {
// If DOB is null or empty
fail(true, RegisterWorkerDto.MISSING_DOB);
} else {
// Validating age ( should be greater than or equal to 18 )
Period age = Period.between(ourData.getDateOfBirth(), LocalDate.now());
fail(age.getYears() < LEGAL_AGE, RegisterWorkerDto.DOB_TOO_SOON);
}
| 356
| 263
| 619
|
<methods>public non-sealed void <init>() ,public com.iluwatar.Notification getNotification() <variables>protected com.iluwatar.DataTransferObject data
|
iluwatar_java-design-patterns
|
java-design-patterns/notification/src/main/java/com/iluwatar/RegisterWorkerDto.java
|
RegisterWorkerDto
|
setupWorkerDto
|
class RegisterWorkerDto extends DataTransferObject {
private String name;
private String occupation;
private LocalDate dateOfBirth;
/**
* Error for when name field is blank or missing.
*/
public static final NotificationError MISSING_NAME =
new NotificationError(1, "Name is missing");
/**
* Error for when occupation field is blank or missing.
*/
public static final NotificationError MISSING_OCCUPATION =
new NotificationError(2, "Occupation is missing");
/**
* Error for when date of birth field is blank or missing.
*/
public static final NotificationError MISSING_DOB =
new NotificationError(3, "Date of birth is missing");
/**
* Error for when date of birth is less than 18 years ago.
*/
public static final NotificationError DOB_TOO_SOON =
new NotificationError(4, "Worker registered must be over 18");
protected RegisterWorkerDto() {
super();
}
/**
* Simple set up function for capturing our worker information.
*
* @param name Name of the worker
* @param occupation occupation of the worker
* @param dateOfBirth Date of Birth of the worker
*/
public void setupWorkerDto(String name, String occupation, LocalDate dateOfBirth) {<FILL_FUNCTION_BODY>}
}
|
this.name = name;
this.occupation = occupation;
this.dateOfBirth = dateOfBirth;
| 369
| 34
| 403
|
<methods>public non-sealed void <init>() <variables>private final com.iluwatar.Notification notification
|
iluwatar_java-design-patterns
|
java-design-patterns/notification/src/main/java/com/iluwatar/RegisterWorkerForm.java
|
RegisterWorkerForm
|
submit
|
class RegisterWorkerForm {
String name;
String occupation;
LocalDate dateOfBirth;
RegisterWorkerDto worker;
RegisterWorkerService service = new RegisterWorkerService();
/**
* Constructor.
*
* @param name Name of the worker
* @param occupation occupation of the worker
* @param dateOfBirth Date of Birth of the worker
*/
public RegisterWorkerForm(String name, String occupation, LocalDate dateOfBirth) {
this.name = name;
this.occupation = occupation;
this.dateOfBirth = dateOfBirth;
}
/**
* Attempts to submit the form for registering a worker.
*/
public void submit() {<FILL_FUNCTION_BODY>}
/**
* Saves worker information to the data transfer object.
*/
private void saveToWorker() {
worker = new RegisterWorkerDto();
worker.setName(name);
worker.setOccupation(occupation);
worker.setDateOfBirth(dateOfBirth);
}
/**
* Check for any errors with form submission and show them to the user.
*/
public void indicateErrors() {
worker.getNotification().getErrors().forEach(error -> LOGGER.error(error.toString()));
}
}
|
//Transmit information to our transfer object to communicate between layers
saveToWorker();
//call the service layer to register our worker
service.registerWorker(worker);
//check for any errors
if (worker.getNotification().hasErrors()) {
indicateErrors();
LOGGER.info("Not registered, see errors");
} else {
LOGGER.info("Registration Succeeded");
}
| 342
| 106
| 448
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/null-object/src/main/java/com/iluwatar/nullobject/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var root = new NodeImpl("1",
new NodeImpl("11",
new NodeImpl("111", NullNode.getInstance(), NullNode.getInstance()),
NullNode.getInstance()
),
new NodeImpl("12",
NullNode.getInstance(),
new NodeImpl("122", NullNode.getInstance(), NullNode.getInstance())
)
);
root.walk();
| 55
| 102
| 157
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/object-mother/src/main/java/com/iluwatar/objectmother/King.java
|
King
|
flirt
|
class King implements Royalty {
boolean isDrunk = false;
boolean isHappy = false;
@Override
public void makeDrunk() {
isDrunk = true;
}
@Override
public void makeSober() {
isDrunk = false;
}
@Override
public void makeHappy() {
isHappy = true;
}
@Override
public void makeUnhappy() {
isHappy = false;
}
public boolean isHappy() {
return isHappy;
}
/**
* Method to flirt to a queen.
*
* @param queen Queen which should be flirted.
*/
public void flirt(Queen queen) {<FILL_FUNCTION_BODY>}
}
|
var flirtStatus = queen.getFlirted(this);
if (!flirtStatus) {
this.makeUnhappy();
} else {
this.makeHappy();
}
| 200
| 52
| 252
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/object-mother/src/main/java/com/iluwatar/objectmother/RoyaltyObjectMother.java
|
RoyaltyObjectMother
|
createHappyDrunkKing
|
class RoyaltyObjectMother {
/**
* Method to create a sober and unhappy king. The standard parameters are set.
*
* @return An instance of {@link com.iluwatar.objectmother.King} with the standard properties.
*/
public static King createSoberUnhappyKing() {
return new King();
}
/**
* Method of the object mother to create a drunk king.
*
* @return A drunk {@link com.iluwatar.objectmother.King}.
*/
public static King createDrunkKing() {
var king = new King();
king.makeDrunk();
return king;
}
/**
* Method to create a happy king.
*
* @return A happy {@link com.iluwatar.objectmother.King}.
*/
public static King createHappyKing() {
var king = new King();
king.makeHappy();
return king;
}
/**
* Method to create a happy and drunk king.
*
* @return A drunk and happy {@link com.iluwatar.objectmother.King}.
*/
public static King createHappyDrunkKing() {<FILL_FUNCTION_BODY>}
/**
* Method to create a flirty queen.
*
* @return A flirty {@link com.iluwatar.objectmother.Queen}.
*/
public static Queen createFlirtyQueen() {
var queen = new Queen();
queen.setFlirtiness(true);
return queen;
}
/**
* Method to create a not flirty queen.
*
* @return A not flirty {@link com.iluwatar.objectmother.Queen}.
*/
public static Queen createNotFlirtyQueen() {
return new Queen();
}
}
|
var king = new King();
king.makeHappy();
king.makeDrunk();
return king;
| 462
| 31
| 493
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/object-pool/src/main/java/com/iluwatar/object/pool/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var pool = new OliphauntPool();
LOGGER.info(pool.toString());
var oliphaunt1 = pool.checkOut();
String checkedOut = "Checked out {}";
LOGGER.info(checkedOut, oliphaunt1);
LOGGER.info(pool.toString());
var oliphaunt2 = pool.checkOut();
LOGGER.info(checkedOut, oliphaunt2);
var oliphaunt3 = pool.checkOut();
LOGGER.info(checkedOut, oliphaunt3);
LOGGER.info(pool.toString());
LOGGER.info("Checking in {}", oliphaunt1);
pool.checkIn(oliphaunt1);
LOGGER.info("Checking in {}", oliphaunt2);
pool.checkIn(oliphaunt2);
LOGGER.info(pool.toString());
var oliphaunt4 = pool.checkOut();
LOGGER.info(checkedOut, oliphaunt4);
var oliphaunt5 = pool.checkOut();
LOGGER.info(checkedOut, oliphaunt5);
LOGGER.info(pool.toString());
| 56
| 295
| 351
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/object-pool/src/main/java/com/iluwatar/object/pool/ObjectPool.java
|
ObjectPool
|
checkOut
|
class ObjectPool<T> {
private final Set<T> available = new HashSet<>();
private final Set<T> inUse = new HashSet<>();
protected abstract T create();
/**
* Checkout object from pool.
*/
public synchronized T checkOut() {<FILL_FUNCTION_BODY>}
public synchronized void checkIn(T instance) {
inUse.remove(instance);
available.add(instance);
}
@Override
public synchronized String toString() {
return String.format("Pool available=%d inUse=%d", available.size(), inUse.size());
}
}
|
if (available.isEmpty()) {
available.add(create());
}
var instance = available.iterator().next();
available.remove(instance);
inUse.add(instance);
return instance;
| 167
| 56
| 223
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/App.java
|
App
|
main
|
class App {
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
var weather = new Weather();
weather.addObserver(new Orcs());
weather.addObserver(new Hobbits());
weather.timePasses();
weather.timePasses();
weather.timePasses();
weather.timePasses();
// Generic observer inspired by Java Generics and Collections by Naftalin & Wadler
LOGGER.info("--Running generic version--");
var genericWeather = new GenWeather();
genericWeather.addObserver(new GenOrcs());
genericWeather.addObserver(new GenHobbits());
genericWeather.timePasses();
genericWeather.timePasses();
genericWeather.timePasses();
genericWeather.timePasses();
| 56
| 188
| 244
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/Orcs.java
|
Orcs
|
update
|
class Orcs implements WeatherObserver {
@Override
public void update(WeatherType currentWeather) {<FILL_FUNCTION_BODY>}
}
|
LOGGER.info("The orcs are facing " + currentWeather.getDescription() + " weather now");
| 42
| 29
| 71
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/Weather.java
|
Weather
|
timePasses
|
class Weather {
private WeatherType currentWeather;
private final List<WeatherObserver> observers;
public Weather() {
observers = new ArrayList<>();
currentWeather = WeatherType.SUNNY;
}
public void addObserver(WeatherObserver obs) {
observers.add(obs);
}
public void removeObserver(WeatherObserver obs) {
observers.remove(obs);
}
/**
* Makes time pass for weather.
*/
public void timePasses() {<FILL_FUNCTION_BODY>}
private void notifyObservers() {
for (var obs : observers) {
obs.update(currentWeather);
}
}
}
|
var enumValues = WeatherType.values();
currentWeather = enumValues[(currentWeather.ordinal() + 1) % enumValues.length];
LOGGER.info("The weather changed to {}.", currentWeather);
notifyObservers();
| 192
| 63
| 255
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/generic/GenHobbits.java
|
GenHobbits
|
update
|
class GenHobbits implements Race {
@Override
public void update(GenWeather weather, WeatherType weatherType) {<FILL_FUNCTION_BODY>}
}
|
LOGGER.info("The hobbits are facing " + weatherType.getDescription() + " weather now");
| 46
| 29
| 75
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/generic/GenOrcs.java
|
GenOrcs
|
update
|
class GenOrcs implements Race {
@Override
public void update(GenWeather weather, WeatherType weatherType) {<FILL_FUNCTION_BODY>}
}
|
LOGGER.info("The orcs are facing " + weatherType.getDescription() + " weather now");
| 46
| 28
| 74
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/generic/GenWeather.java
|
GenWeather
|
timePasses
|
class GenWeather extends Observable<GenWeather, Race, WeatherType> {
private WeatherType currentWeather;
public GenWeather() {
currentWeather = WeatherType.SUNNY;
}
/**
* Makes time pass for weather.
*/
public void timePasses() {<FILL_FUNCTION_BODY>}
}
|
var enumValues = WeatherType.values();
currentWeather = enumValues[(currentWeather.ordinal() + 1) % enumValues.length];
LOGGER.info("The weather changed to {}.", currentWeather);
notifyObservers(currentWeather);
| 97
| 67
| 164
|
<methods>public void <init>() ,public void addObserver(com.iluwatar.observer.generic.Race) ,public void notifyObservers(com.iluwatar.observer.WeatherType) ,public void removeObserver(com.iluwatar.observer.generic.Race) <variables>protected final non-sealed List<com.iluwatar.observer.generic.Race> observers
|
iluwatar_java-design-patterns
|
java-design-patterns/observer/src/main/java/com/iluwatar/observer/generic/Observable.java
|
Observable
|
notifyObservers
|
class Observable<S extends Observable<S, O, A>, O extends Observer<S, O, A>, A> {
protected final List<O> observers;
public Observable() {
this.observers = new CopyOnWriteArrayList<>();
}
public void addObserver(O observer) {
this.observers.add(observer);
}
public void removeObserver(O observer) {
this.observers.remove(observer);
}
/**
* Notify observers.
*/
@SuppressWarnings("unchecked")
public void notifyObservers(A argument) {<FILL_FUNCTION_BODY>}
}
|
for (var observer : observers) {
observer.update((S) this, argument);
}
| 176
| 29
| 205
|
<no_super_class>
|
iluwatar_java-design-patterns
|
java-design-patterns/optimistic-offline-lock/src/main/java/com/iluwatar/service/CardUpdateService.java
|
CardUpdateService
|
doUpdate
|
class CardUpdateService implements UpdateService<Card> {
private final JpaRepository<Card> cardJpaRepository;
@Override
public Card doUpdate(Card obj, long id) {<FILL_FUNCTION_BODY>}
}
|
float additionalSum = obj.getSum();
Card cardToUpdate = cardJpaRepository.findById(id);
int initialVersion = cardToUpdate.getVersion();
float resultSum = cardToUpdate.getSum() + additionalSum;
cardToUpdate.setSum(resultSum);
//Maybe more complex business-logic e.g. HTTP-requests and so on
if (initialVersion != cardJpaRepository.getEntityVersionById(id)) {
String exMessage =
String.format("Entity with id %s were updated in another transaction", id);
throw new ApplicationException(exMessage);
}
cardJpaRepository.update(cardToUpdate);
return cardToUpdate;
| 61
| 174
| 235
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.