Active Object without Prod and Cons models

Author: mwoss

.gitignore

@@ -0,0 +1 @@
+.idea/

src/main/java/ActiveObject/ActivationQueue.java

@@ -0,0 +1,7 @@
+package ActiveObject.App;
+
+public class Main {
+    public static void main(String[] args) {
+
+    }
+}

src/main/java/ActiveObject/App/Main.java

@@ -0,0 +1,27 @@
+package ActiveObject.Future;
+
+public class Future implements IFuture<Integer>{
+
+    private boolean status;
+    private Integer result;
+
+    @Override
+    public Integer getResult() {
+        return this.result;
+    }
+
+    @Override
+    public boolean isFinished() {
+        return status;
+    }
+
+    @Override
+    public void setResult(Integer result) {
+        this.result = result;
+    }
+
+    @Override
+    public void setStatus() {
+        this.status = true;
+    }
+}

src/main/java/ActiveObject/ConsumerMethodRequest.java

@@ -0,0 +1,8 @@
+package ActiveObject.Future;
+
+public interface IFuture<T> {
+    T getResult();
+    boolean isFinished();
+    void setResult(T result);
+    void setStatus();
+}

src/main/java/ActiveObject/Future.java

@@ -1,4 +1,4 @@
-package ActiveObject;
+package ActiveObject.MethodRequest;
 
 public interface IMethodRequest {
     boolean guard();

src/main/java/ActiveObject/Future/Future.java

@@ -0,0 +1,29 @@
+package ActiveObject.MethodRequest;
+
+import ActiveObject.Future.Future;
+import ActiveObject.Servant;
+
+public class PutMethodRequest implements IMethodRequest {
+
+    private Future future;
+    private Servant servant;
+    private int toPut;
+
+    public PutMethodRequest(Future future, Servant buffer, int toPut){
+        this.future = future;
+        this.servant = buffer;
+        this.toPut = toPut;
+    }
+
+    @Override
+    public boolean guard() {
+        return servant.getCurrentSize() + toPut <= servant.getCapacity();
+    }
+
+    @Override
+    public void execute() {
+        servant.produce(toPut);
+        future.setResult(toPut);
+        future.setStatus();
+    }
+}

src/main/java/ActiveObject/Future/IFuture.java

@@ -0,0 +1,29 @@
+package ActiveObject.MethodRequest;
+
+import ActiveObject.Future.Future;
+import ActiveObject.Servant;
+
+public class TakeMethodRequest implements IMethodRequest {
+
+    private Future future;
+    private Servant servant;
+    private int toTake;
+
+    public TakeMethodRequest(Future future, Servant buffer, int toTake){
+        this.future = future;
+        this.servant = buffer;
+        this.toTake = toTake;
+    }
+
+    @Override
+    public boolean guard() {
+        return servant.getCurrentSize() >= toTake;
+    }
+
+    @Override
+    public void execute() {
+        servant.consume(toTake);
+        future.setResult(toTake);
+        future.setStatus();
+    }
+}

src/main/java/ActiveObject/IMethodRequest.java renamed to src/main/java/ActiveObject/MethodRequest/IMethodRequest.java

@@ -1,4 +1,9 @@
 package ActiveObject.Models;
 
-public class Consumer {
+public class Consumer extends Thread {
+
+    @Override
+    public void run() {
+        
+    }
 }

src/main/java/ActiveObject/MethodRequest/PutMethodRequest.java

@@ -1,4 +1,9 @@
 package ActiveObject.Models;
 
-public class Procuder {
+public class Procuder extends Thread {
+
+    @Override
+    public void run() {
+
+    }
 }

src/main/java/ActiveObject/MethodRequest/TakeMethodRequest.java

@@ -1,21 +1,36 @@
 package ActiveObject;
 
-import java.util.concurrent.Future;
+import ActiveObject.Future.Future;
+import ActiveObject.MethodRequest.PutMethodRequest;
+import ActiveObject.MethodRequest.TakeMethodRequest;
+import ActiveObject.Scheduler.Scheduler;
+
+
 
 public class Proxy {
     private Scheduler scheduler;
     private Servant servant;
 
-    public Proxy(){
-        this.servant = new Servant();
+    public Proxy(int capacity){
+        this.servant = new Servant(capacity);
         this.scheduler = new Scheduler();
     }
 
-    public Future method1(){
-        return null;
+    public Future consume(int toConsume){
+        Future consumeFuture = new Future();
+        TakeMethodRequest takeMethodRequest = new TakeMethodRequest(consumeFuture, servant, toConsume);
+        scheduler.enqueue(takeMethodRequest);
+
+        return consumeFuture;
     }
 
-    public Future method2(){
-        return null;
+    public Future produce(int toProcude){
+        Future produceFuture = new Future();
+        PutMethodRequest putMethodRequest = new PutMethodRequest(produceFuture, servant, toProcude);
+        scheduler.enqueue(putMethodRequest);
+
+        return produceFuture;
     }
+
+
 }

src/main/java/ActiveObject/Models/Consumer.java

@@ -0,0 +1,22 @@
+package ActiveObject.Queues;
+
+import ActiveObject.MethodRequest.IMethodRequest;
+
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class ActivationQueue implements IActivationQueue<IMethodRequest> {
+
+    private Queue<IMethodRequest> methodRequestQueue = new ConcurrentLinkedQueue<>();
+
+    @Override
+    public IMethodRequest dequeue() {
+        return methodRequestQueue.poll();
+    }
+
+    @Override
+    public void enqueue(IMethodRequest methodRequest) {
+        methodRequestQueue.offer(methodRequest);
+    }
+}

src/main/java/ActiveObject/Models/Procuder.java

@@ -0,0 +1,6 @@
+package ActiveObject.Queues;
+
+public interface IActivationQueue<T> {
+    T dequeue();
+    void enqueue(T methodRequest);
+}

src/main/java/ActiveObject/ProcuderMethodRequest.java

@@ -0,0 +1,22 @@
+package ActiveObject.Queues;
+
+import ActiveObject.MethodRequest.PutMethodRequest;
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class PutActivationQueueDEPR implements IActivationQueue<PutMethodRequest> {
+
+    private Queue<PutMethodRequest> putMethodRequestQueue = new ConcurrentLinkedQueue<>();
+
+
+    @Override
+    public PutMethodRequest dequeue() {
+        return putMethodRequestQueue.poll();
+    }
+
+    @Override
+    public void enqueue(PutMethodRequest methodRequest) {
+        putMethodRequestQueue.offer(methodRequest);
+    }
+}

src/main/java/ActiveObject/Proxy.java

@@ -0,0 +1,21 @@
+package ActiveObject.Queues;
+
+import ActiveObject.MethodRequest.TakeMethodRequest;
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class TakeActivationQueueDEPR implements IActivationQueue<TakeMethodRequest>{
+
+    private Queue<TakeMethodRequest> takeMethodRequestQueue = new ConcurrentLinkedQueue<>();
+
+    @Override
+    public TakeMethodRequest dequeue() {
+        return takeMethodRequestQueue.poll();
+    }
+
+    @Override
+    public void enqueue(TakeMethodRequest methodRequest) {
+        takeMethodRequestQueue.offer(methodRequest);
+    }
+}

src/main/java/ActiveObject/Queues/ActivationQueue.java

@@ -0,0 +1,73 @@
+package ActiveObject.Scheduler;
+
+import ActiveObject.MethodRequest.IMethodRequest;
+import ActiveObject.MethodRequest.PutMethodRequest;
+import ActiveObject.Queues.ActivationQueue;
+
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class Scheduler implements Runnable {
+
+    private Queue<IMethodRequest> putQueue = new ConcurrentLinkedQueue<>();
+    private Queue<IMethodRequest> takeQueue = new ConcurrentLinkedQueue<>();
+    private ActivationQueue activationQueue = new ActivationQueue();
+    private boolean run = true;
+    private Thread scheduler;
+
+    public void enqueue(IMethodRequest methodRequest) {
+        this.activationQueue.enqueue(methodRequest);
+    }
+
+    private IMethodRequest dequeue() {
+        IMethodRequest methodRequest = null;
+        methodRequest = this.activationQueue.dequeue();
+        return methodRequest;
+    }
+
+
+    @Override
+    public void run() {
+        while (run) {
+            IMethodRequest methodRequest = this.dequeue();
+
+            if (methodRequest instanceof PutMethodRequest) {
+                if (!putQueue.isEmpty()) {
+                    putQueue.offer(methodRequest);
+                    while (putQueue.peek().guard() && !putQueue.isEmpty())
+                        putQueue.poll().execute();
+
+                } else {
+                    if (!methodRequest.guard())
+                        putQueue.offer(methodRequest);
+                    else
+                        methodRequest.execute();
+                }
+            } else {
+                if (!takeQueue.isEmpty()) {
+                    takeQueue.offer(methodRequest);
+                    while (takeQueue.peek().guard() && !takeQueue.isEmpty())
+                        takeQueue.poll().execute();
+                } else {
+                    if (!methodRequest.guard()) {
+                        takeQueue.offer(methodRequest);
+                    } else {
+                        methodRequest.execute();
+                    }
+                }
+            }
+        }
+    }
+
+    public void stopScheduler() {
+        run = false;
+    }
+
+    public void start() {
+        if (this.scheduler == null) {
+            this.scheduler = new Thread();
+            this.scheduler.start();
+        }
+    }
+
+}