Added Spliterator methods to OclIterator

Author: kevinlano

libraries/MathLib.cpp

@@ -43,10 +43,19 @@ MathLib::setix(( MathLib::getix() * 171 ) % 30269);
     return result;
   }
 
+  bool MathLib::nextBoolean()
+  { double r = MathLib::random(); 
+    if (r > 0.5) 
+    { return true; } 
+    return false;
+  }
 
   long MathLib::combinatorial(int n,int m)
   { long result = 0;
-    if (n < m || m < 0) { return result; } 
+
+    if (n < m || m < 0) 
+    { return result; } 
+
     if (n - m < m) 
     { result = UmlRsdsLib<int>::prd(UmlRsdsLib<int>::integerSubrange(m + 1,n)) / UmlRsdsLib<int>::prd(UmlRsdsLib<int>::integerSubrange(1,n - m)); 
     }  

libraries/MathLib.cs

@@ -184,6 +184,12 @@ public static double random()
             return result;
         }
 
+  public static boolean nextBoolean()
+  { double r = MathLib.random(); 
+    if (r > 0.5) 
+    { return true; } 
+    return false;
+  }
 
         public static long combinatorial(int n, int m)
         {

libraries/MathLib.hpp

@@ -47,6 +47,8 @@ class MathLib
 
   static double random();
 
+  static bool nextBoolean(); 
+
   static long combinatorial(int n,int m);
 
   static long factorial(int x);

libraries/Ocl.class

@@ -1010,8 +1010,13 @@ public static String subrange(String s, int i, int j)
 
   public static <T> ArrayList<T> subrange(List<T> l, int i, int j)
   { ArrayList<T> tmp = new ArrayList<T>();
-    if (i < 0) { i = l.size() + i; } 
-    if (j < 0) { j = l.size() + j; }
+    if (i < 0) 
+    { i = l.size() + i; }
+    else if (i == 0)
+    { i = 1; }  
+    if (j < 0) 
+    { j = l.size() + j; }
+
 
     for (int k = i-1; k < j; k++)
     { tmp.add(l.get(k)); } 
@@ -1029,7 +1034,11 @@ public static String subrange(String s, int i)
 
   public static <T> ArrayList<T> subrange(List<T> l, int i)
   { ArrayList<T> tmp = new ArrayList<T>(); 
-    if (i < 0) { i = l.size() + i; } 
+    if (i < 0) 
+    { i = l.size() + i; }
+    else if (i == 0)
+    { i = 1; } 
+ 
     for (int k = i-1; k < l.size(); k++)
     { tmp.add(l.get(k)); } 
     return tmp; 

libraries/Ocl.java

@@ -194,6 +194,15 @@ public static OclIterator newOclIterator_Function(Func<int,object> f)
             return ot;
         }
 
+        public OclIterator trySplit()
+        {
+            ArrayList firstpart = SystemTypes.subrange(elements, 1, position - 1);
+            elements = SystemTypes.subrange(elements, position, elements.Count);
+            position = 0;
+            markedPosition = 0;
+            return OclIterator.newOclIterator_Sequence(firstpart);
+        }
+
         public object getCurrent()
         {
             object result = null;
@@ -246,6 +255,24 @@ public OclIteratorResult nextResult()
             return OclIteratorResult.newOclIteratorResult(res);
         }
 
+        public bool tryAdvance(Func<Object, Object> f)
+        {
+            if (position + 1 <= elements.Count)
+            {
+                Object x = this.next();
+                f(x);
+                return true;
+            }
+            return false;
+        }
+
+        public void forEachRemaining(Func<Object, Object> f)
+        {
+            ArrayList remainingElements = SystemTypes.subrange(elements, position, elements.Count);
+            foreach (Object x in remainingElements)
+            { f(x); }
+        }
+
 
         public object next()
         {

libraries/OclIterator.class

@@ -96,7 +96,7 @@ public boolean isBeforeFirst()
     return result; 
   } 
 
-  public  boolean hasPrevious()
+  public boolean hasPrevious()
   {
      boolean result = false;
     if (position > 1 && position <= elements.size() + 1)
@@ -110,35 +110,35 @@ public  boolean hasPrevious()
   }
 
 
-  public  int nextIndex()
+  public int nextIndex()
   {
     int result = 0;
     result = position + 1;
     return result;
   }
 
 
-  public  int previousIndex()
+  public int previousIndex()
   {
     int result = 0;
     result = position - 1;
     return result;
   }
 
 
-  public  void moveForward()
+  public void moveForward()
   {
     position = position + 1;
   }
 
 
-  public  void moveBackward()
+  public void moveBackward()
   {
     position = position - 1;
   }
 
 
-  public  void moveTo( int i)
+  public void moveTo( int i)
   {
     position = i;
   }
@@ -158,29 +158,29 @@ public void movePosition(int i)
     position = i + position;
   }
 
-  public  void moveToMarkedPosition()
+  public void moveToMarkedPosition()
   {
     position = markedPosition;
   }
 
-  public  void moveToFirst()
+  public void moveToFirst()
   {
     position = 1;
   }
 
-  public  void moveToLast()
+  public void moveToLast()
   {
     position = elements.size();
   }
 
 
-  public  void moveToStart()
+  public void moveToStart()
   {
     position = 0;
   }
 
 
-  public  void moveToEnd()
+  public void moveToEnd()
   {
     position = elements.size() + 1;
   }
@@ -230,6 +230,13 @@ public static OclIterator newOclIterator_Function(Function<Integer,Object> f)
     return ot; 
   }
 
+  public OclIterator trySplit()  
+  { ArrayList firstpart = Ocl.subrange(elements,1,position-1); 
+    elements = Ocl.subrange(elements, position); 
+    position = 0;
+	markedPosition = 0; 
+    return OclIterator.newOclIterator_Sequence(firstpart); 
+  } 
 
   public Object getCurrent()
   {
@@ -240,19 +247,35 @@ public Object getCurrent()
   }
 
 
-  public  void set(Object x)
+  public void set(Object x)
   {
     elements.set(position - 1,x);
   }
 
 
-  public  void insert(Object x)
+  public void insert(Object x)
   { elements.add(position-1,x); }
 
 
-  public  void remove()
+  public void remove()
   { elements.remove(position - 1); }
 
+  public boolean tryAdvance(Function<Object,Object> f) 
+  { if (position + 1 <= elements.size())  
+    { Object x = this.next();   
+      f.apply(x);  
+      return true; 
+    } 
+    return false; 
+  }  
+  
+  public void forEachRemaining(Function<Object,Object> f)  
+  { ArrayList remainingElements = Ocl.subrange(elements, position); 
+    for (Object x : remainingElements)
+    { f.apply(x); } 
+  }  
+
+
   public OclIteratorResult nextResult()
   { if (generatorFunction == null) 
     { Object v = next();
@@ -331,6 +354,21 @@ public void close()
     elements = (new ArrayList());
     columnNames = new ArrayList<String>(); 
   } 
+  
+  /*
+  public static void main(String[] args)
+  { ArrayList lst = new ArrayList(); 
+    lst.add(1); lst.add(2); lst.add(3); lst.add(4); lst.add(5); 
+    OclIterator iter1 = OclIterator.newOclIterator_Sequence(lst); 
+	System.out.println(iter1.elements); 
+	iter1.setPosition(3); 
+	OclIterator iter2 = iter1.trySplit(); 
+	System.out.println(iter1.elements); 
+	System.out.println(iter2.elements); 
+	
+	Function<Object,Object> ff = (y)->{ System.out.println(y); return y; }; 
+	iter1.forEachRemaining(ff); 
+  } */ 
 
 }
 

libraries/OclIterator.cs

@@ -102,6 +102,10 @@ class OclIteratorResult
     pre: true 
     post: OclIterator->exists( ot | ot.elements = sq & ot.position = 0 & ot.columns = Sequence{} & result = ot); 
 
+    operation trySplit() : OclIterator
+    pre: true 
+    post: OclIterator->exists( ot | ot.elements = elements.subrange(1,position) & ot.position = 0 & ot.columns = Sequence{} & markedPosition = 0 & elements = elements.subrange(position+1) & position = 0 & result = ot); 
+
     static operation newOclIterator_Set(st : Set) : OclIterator
     pre: true 
     post: OclIterator->exists( ot | ot.elements = Sequence{}->union(st->sort()) & ot.position = 0 & ot.columns = Sequence{} & result = ot ); 
@@ -136,13 +140,31 @@ class OclIteratorResult
     pre: true
     post: elements[position] = null & elements[position]->isDeleted();
 
+    operation tryAdvance(f : Function) : boolean
+    pre: true 
+    post: true
+    activity: 
+      if position + 1 <= elements->size() 
+      then 
+       (var x : OclAny := next() ; 
+        execute f->apply(x); 
+        return true)
+      else return false; 
 
     operation next() : OclAny
     pre: true
     post: true
     activity: 
       ( moveForward() ; return getCurrent() ); 
 
+    operation forEachRemaining(f : Function) : void
+    pre: true 
+    post: true
+    activity: 
+      for x : elements.subrange(position)
+      do 
+        execute f->apply(x); 
+
     operation nextResult() : OclIteratorResult
     pre: true
     post: true

libraries/OclIterator.java

@@ -186,6 +186,13 @@ def newOclIterator_Function(f) :
     result = ot
     return result
 
+  def trySplit(self) : 
+    firstpart = self.elements[0:self.position]
+    self.elements = self.elements[self.position:]
+    self.position = 0
+    self.markedPosition = 0
+    return OclIterator.newOclIterator_Sequence(firstpart)
+
   def getCurrent(self) :
     result = None
     if self.position <= len(self.elements) and self.position >= 1 : 
@@ -202,6 +209,13 @@ def remove(self) :
     self.elements[self.position -1] = None
     del self.elements[self.position -1]
 
+  def tryAdvance(self, f) : 
+    if self.position + 1 <= len(self.elements) : 
+      x = self.next()  
+      f(x) 
+      return True
+    return False 
+
   def next(self) :
     result = None
     self.moveForward()
@@ -222,6 +236,9 @@ def nextResult(self) :
         self.elements.append(r)
       return OclIteratorResult.newOclIteratorResult(r)
 
+  def forEachRemaining(self, f) : 
+    for x in self.elements[self.position:] :
+      f(x) 
 
   def previous(self) :
     result = None