import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * {@link <a href=
 * "https://[Log in to view URL]"
 * target= "_blank">Primitive HashSet<E></a>}
 * 
 * @author itammb ( Italia Massimiliano Buscati )
 * @version JDK 1.15
 *
 */
class Main {
	public static class UniTestHashSet {
		/**
		 * @see Set#contains(Object)
		 * 
		 */
		public void applayContains(Set<Integer> buffer, Integer contains) {
			System.out.println(buffer.contains(contains));  
		}
				
		/**
		 * @see Set#copyOf(java.util.Collection)
		 *
		 */
		public void applayCopyOf(Set<Integer> source) {
			// vista immutabile
			Set<Integer> view = Set.copyOf(source);

			Set<Integer> copyBuf = new HashSet<Integer>(view);
			copyBuf.remove(1);
			applayIterator(copyBuf);
			applayIterator(source);
			applayIterator(view);
		}
		
		/**
		 * @see Set#stream()
		 * @see Stream#collect(java.util.stream.Collector)
		 * @see Collectors#toSet()
		 *
		 */
		public void applayStream(Set<Integer> source) {
			Stream<Integer> stream = source.stream();		
			Set<Integer> copyBuf = stream.collect(Collectors.toSet());

			copyBuf.remove(1);
			applayIterator(copyBuf);
			applayIterator(source);
		}
		
		/**
		 * @see Stream#sorted()
		 * @see Stream#collect(java.util.stream.Collector)
		 * @see Collectors#toList()
		 *
		 */
		public void applaySort(Set<Integer> buffer) {
			List<Integer> sort = buffer.stream().sorted().collect(Collectors.toList());
			
			for (int i = 0; i < sort.size(); i++)
				System.out.print("[i=" + i + ", e=" + sort.get(i) + "] ");
			
			System.out.println();
		}
		
		/**
		 * @see Collections#emptySet()
		 *
		 */
		public void applayEmptySet() {
			System.out.println(Collections.emptySet());
		}
		
		/**
		 * @see Collections#unmodifiableSet(Set)
		 * 
		 */
		public void applayUnmodifiableSet(Set<Integer> buffer) {		
			// view a sola lettura
			Set<Integer> view = Collections.unmodifiableSet( buffer );
			
			try
			{
				view.add( 1 );
			} catch(Exception ex)
			{
				ex.printStackTrace();
			}			
		}

		/**
		 * @see Set#iterator()
		 * @see Iterator
		 * 
		 */
		public void applayIterator(Set<Integer> buffer) {
			if (buffer.isEmpty())
				System.out.print("[]");
			else
				for (Iterator<Integer> itr = buffer.iterator(); itr.hasNext();)
					System.out.print("e=" + itr.next() + " ");

			println();
		}

		private static void println() {
			System.out.println();
		}

		/**
		 * @see EnumSet#allOf(Class)
		 *
		 */
		public static HashSet<Integer> createTest() {
			// insieme NON ordinato di elementi NON duplicati
			return new HashSet<Integer>() {
				private static final long serialVersionUID = -69L;

				{
					add((Integer) 1);
					add((Integer) 5);
					add((Integer) 3);
					add((Integer) 6);
					add((Integer) 4);
					add((Integer) 1);
					add((Integer) 2);
				}
			};
		}
	}
	
	public static void main(String args[]) throws Exception {
		// Unit test - verifica l'esistenza di un elemento nella struttura
		new UniTestHashSet().applayContains(UniTestHashSet.createTest(), 1);
		
		// Unit test - copia di una struttura ( da una sua view immutabile )
		new UniTestHashSet().applayCopyOf(UniTestHashSet.createTest());		
		
		// Unit test - copia di una struttura ( da uno stream )
		new UniTestHashSet().applayStream(UniTestHashSet.createTest());
		
		// Unit test - ordina una struttura e restituisce una lista
		new UniTestHashSet().applaySort(UniTestHashSet.createTest());
		
		// Unit test - restituisce una struttura vuota
		new UniTestHashSet().applayEmptySet();
		
		// Unit test - view a sola lettura di una struttura 
		new UniTestHashSet().applayUnmodifiableSet(UniTestHashSet.createTest());		
		
		// Unit test - attraversa una struttura con l'ausilio di un'interfaccia
		// Iteretor<E>
		new UniTestHashSet().applayIterator(UniTestHashSet.createTest());	
	}
}