Sorted collection types for Java,C++

libraries/OCLC++11.h

@@ -1,4 +1,4 @@
-// C++ OCL library for Visual Studio C++11
+// C++ OCL library for Visual Studio C++19
 
 #undef max
 #undef min

libraries/SortedOrderedSet.java

@@ -9,23 +9,23 @@
 import java.util.Spliterator;
 
 
-class SortedOrderedSet implements Set, List 
-{ private HashSet elementSet = new HashSet(); 
-  private SortedSequence elementSeq = new SortedSequence(); 
+class SortedOrderedSet<T extends Comparable<T>> implements Set<T>, List<T> 
+{ private HashSet<T> elementSet = new HashSet<T>(); 
+  private SortedSequence<T> elementSeq = new SortedSequence<T>(); 
 
   // invariant elementSet = elementSeq.uniqueSet(); 
 
   public SortedOrderedSet() { } 
 
   public SortedOrderedSet(Set col)
-  { elementSet = new HashSet(col); 
-    elementSeq = new SortedSequence(col); 
+  { elementSet = new HashSet<T>(col); 
+    elementSeq = new SortedSequence<T>(col); 
   } 
 
-  public SortedOrderedSet clone()
-  { HashSet elems = (HashSet) elementSet.clone(); 
-    SortedSequence ss = (SortedSequence) elementSeq.clone();
-    SortedOrderedSet sos = new SortedOrderedSet();
+  public SortedOrderedSet<T> clone()
+  { HashSet<T> elems = (HashSet<T>) elementSet.clone(); 
+    SortedSequence<T> ss = (SortedSequence<T>) elementSeq.clone();
+    SortedOrderedSet<T> sos = new SortedOrderedSet<T>();
     sos.elementSet = elems;
     sos.elementSeq = ss; 
     return sos;
@@ -58,10 +58,10 @@ public boolean retainAll(Collection col)
   public boolean addAll(Collection col)
   { boolean changed = false; 
     for (Object obj : col)
-    { boolean added = elementSet.add(obj); 
+    { boolean added = elementSet.add((T) obj); 
       if (added) 
       { changed = true; 
-        elementSeq.add(obj);
+        elementSeq.add((T) obj);
       } 
     } 
     return changed;  
@@ -74,13 +74,13 @@ public boolean containsAll(Collection col)
   { return elementSet.containsAll(col); }
 
   public boolean remove(Object x)
-  { boolean removed = elementSet.remove(x); 
+  { boolean removed = elementSet.remove((T) x); 
     if (removed)
-    { elementSeq.remove(x); }
+    { elementSeq.remove((T) x); }
     return removed; 
   } 
 
-  public boolean add(Object x)
+  public boolean add(T x)
   { boolean added = elementSet.add(x); 
     if (added) 
     { elementSeq.add(x); } 
@@ -93,7 +93,7 @@ public Object[] toArray()
   public Object[] toArray(Object[] arr)
   { return elementSeq.toArray(arr); }
 
-  public Set asSet()
+  public Set<T> asSet()
   { return elementSet; } 
 
   public Iterator iterator()
@@ -108,45 +108,46 @@ public ListIterator listIterator()
   public Spliterator spliterator()
   { return elementSeq.spliterator(); } 
 
-  public Object get(int i) 
+  public T get(int i) 
   { return elementSeq.get(i); } 
 
-  public List subList(int i, int j)
+  public List<T> subList(int i, int j)
   { return elementSeq.subList(i,j); } 
 
   public int lastIndexOf(Object x)
-  { return elementSeq.lastIndexOf(x); } 
+  { return elementSeq.lastIndexOf((T) x); } 
 
   public int indexOf(Object x)
-  { return elementSeq.indexOf(x); } 
+  { return elementSeq.indexOf((T) x); } 
 
-  public Object remove(int x)
-  { return elementSeq.remove(x); }
+  public T remove(int i)
+  { return elementSeq.remove(i); }
 
-  public void add(int i, Object x)
-  { boolean added = elementSet.add(x); 
+  public void add(int i, T x)
+  { boolean added = elementSet.add((T) x); 
     if (added) 
-    { elementSeq.add(x); }
+    { elementSeq.add((T) x); }
   } // ignores i 
 
-  public Object set(int i, Object x)
-  { boolean added = elementSet.add(x); 
+  // @Override
+  public T set(int i, T x)
+  { boolean added = elementSet.add((T) x); 
     if (added) 
-    { return elementSeq.add(x); }
+    { elementSeq.add(x); }
     return null; 
   } // ignores i 
 
   public String toString()
   { return elementSeq.toString(); }   
 
-  public Object min()
+  public T min()
   { return elementSeq.min(); }
 
-  public Object max()
+  public T max()
   { return elementSeq.max(); }
 
   public int getCount(Object x)
-  { if (elementSet.contains(x))
+  { if (elementSet.contains((T) x))
     { return 1; } 
     return 0; 
   } 
@@ -160,16 +161,19 @@ public boolean equals(Object col)
   }    
 
   public static void main(String[] args)
-  { SortedOrderedSet sos = new SortedOrderedSet(); 
+  { SortedOrderedSet<String> sos = new SortedOrderedSet<String>(); 
     sos.add("cc"); sos.add("bb"); 
     sos.add("aa"); sos.add("bb"); sos.add("aa"); 
-    List newelems = new ArrayList(); 
+    System.out.println(sos); 
+
+    List<String> newelems = new ArrayList<String>(); 
     newelems.add("dd"); newelems.add("cc"); 
     newelems.add("bb");
     sos.addAll(newelems);  
     System.out.println(sos); 
-	sos.remove("bb"); 
-	System.out.println(sos); 
+
+    sos.remove("bb"); 
+    System.out.println(sos); 
   } 
 }
 

libraries/SortedSequence.hpp

@@ -0,0 +1,118 @@
+template<class _T>
+class SortedSequence {
+private: 
+    vector<_T>* elements = new vector<_T>(); 
+public:
+    SortedSequence()
+    { }
+
+    SortedSequence(vector<_T>* sq)
+    {
+        std::copy(sq->begin(), sq->end(), elements->begin()); 
+        std::sort(elements->begin(), elements->end()); 
+    }
+
+    bool includes(_T x)
+    {
+       return std::binary_search(elements->begin(), elements->end(), x); 
+    }
+
+    void including(_T x)
+    {
+        auto pos = std::lower_bound(elements->begin(), elements->end(), x);
+        elements->insert(pos, x); 
+    }
+
+    void excluding(_T x)
+    {
+        auto pos = std::equal_range(elements->begin(), elements->end(), x); 
+        elements->erase(pos.first, pos.second); 
+    }
+
+    void subtract(vector<_T>* b)
+    {
+        for (int i = 0; i < b->size(); i++)
+        {
+            this->excluding((*b)[i]); 
+        }
+    }
+
+    void subtract(std::set<_T>* b)
+    {
+        for (auto iter = b->begin(); iter != b->end(); iter++)
+        {
+            this->excluding(*iter); 
+        }
+    }
+
+    void unionSortedSequence(vector<_T>* b)
+    {
+        for (int i = 0; i < b->size(); i++)
+        {
+            this->including((*b)[i]);
+        }
+    }
+
+    void unionSortedSequence(std::set<_T>* b)
+    {
+        for (auto iter = b->begin(); iter != b->end(); iter++)
+        {
+            this->including(*iter);
+        }
+    }
+
+    void intersection(vector<_T>* sq)
+    {
+        std::set<_T>* removed = new std::set<_T>(); 
+
+        for (int i = 0; i < elements->size(); i++)
+        {
+            _T x = (*elements)[i];  
+            if (std::find(sq->begin(), sq->end(), x) != sq->end()) {}
+            else
+            {
+                removed->insert(x);
+            }
+        }
+
+        for (auto iter = removed->begin(); iter != removed->end(); iter++) 
+        {
+            this->excluding(*iter); 
+        }
+    }
+
+        void intersection(std::set<_T>* st)
+        {
+            std::set<_T>* removed = new std::set<_T>(); 
+
+            for (int i = 0; i < elements->size(); i++)
+            {
+                _T x = (*elements)[i]; 
+                if (st->find(x) != st->end()) {}
+                else
+                {
+                    removed->insert(x);
+                }
+            }
+
+            for (auto iter = removed->begin(); iter != removed->end(); iter++)
+            {
+                this->excluding(*iter);
+            }
+        }
+
+    auto begin() { return elements->begin(); }
+
+    auto end() { return elements->end(); }
+
+    int size() { return elements->size(); }
+
+    _T min() { return elements->at(0); }
+
+    _T max() 
+    { int sze = elements->size();
+      if (sze == 0) { return NULL; } 
+      return elements->at(sze-1);
+    }
+};
+