X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=cadi%2Fcore%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Faaf%2Fcadi%2FCapacitor.java;h=5ca1ce30bcad92a80bff2c580ea033405af3e7f7;hb=refs%2Fchanges%2F75%2F65275%2F1;hp=935e4f149b3b2979fa236039093e8041b4de6175;hpb=824dc7b5fc0e1ccdf7f460479aff344727f0f01e;p=aaf%2Fauthz.git

diff --git a/cadi/core/src/main/java/org/onap/aaf/cadi/Capacitor.java b/cadi/core/src/main/java/org/onap/aaf/cadi/Capacitor.java
index 935e4f14..5ca1ce30 100644
--- a/cadi/core/src/main/java/org/onap/aaf/cadi/Capacitor.java
+++ b/cadi/core/src/main/java/org/onap/aaf/cadi/Capacitor.java
@@ -35,207 +35,207 @@ import java.util.ArrayList;
  *
  */
 public class Capacitor {
-	private static final int DEFAULT_CHUNK = 256;
-	private ArrayList<ByteBuffer> bbs = new ArrayList<>();
-	private ByteBuffer curr = null;
-	private int idx;
-	
-	// Maintain a private RingBuffer for Memory, for efficiency
-	private static ByteBuffer[] ring = new ByteBuffer[16];
-	private static int start, end;
-	
-	
-	public void put(byte b) {
-		if(curr == null || curr.remaining()==0) { // ensure we have a "curr" buffer ready for data
-			curr = ringGet();
-			bbs.add(curr);
-		}
-		curr.put(b); 
-	}
+    private static final int DEFAULT_CHUNK = 256;
+    private ArrayList<ByteBuffer> bbs = new ArrayList<>();
+    private ByteBuffer curr = null;
+    private int idx;
+    
+    // Maintain a private RingBuffer for Memory, for efficiency
+    private static ByteBuffer[] ring = new ByteBuffer[16];
+    private static int start, end;
+    
+    
+    public void put(byte b) {
+        if(curr == null || curr.remaining()==0) { // ensure we have a "curr" buffer ready for data
+            curr = ringGet();
+            bbs.add(curr);
+        }
+        curr.put(b); 
+    }
 
-	public int read() {
-		if(curr!=null) { 
-			if(curr.remaining()>0) { // have a buffer, use it!
-				return curr.get();
-			} else if(idx<bbs.size()){ // Buffer not enough, get next one from array
-				curr=bbs.get(idx++);
-				return curr.get();
-			}
-		} // if no curr buffer, treat as end of stream
-		return -1;
-	}
-	
-	/**
-	 * read into an array like Streams
-	 * 
-	 * @param array
-	 * @param offset
-	 * @param length
-	 * @return
-	 */
-	public int read(byte[] array, int offset, int length) {
-		if(curr==null)return -1;
-		int len;
-		int count=0;
-		while(length>0) { // loop through while there's data needed
-			if((len=curr.remaining())>length) { //  if enough data in curr buffer, use this code
-				curr.get(array,offset,length);
-				count+=length;
-				length=0;
-			} else {  // get data from curr, mark how much is needed to fulfil, and loop for next curr.
-				curr.get(array,offset,len);
-				count+=len;
-				offset+=len;
-				length-=len;
-				if(idx<bbs.size()) {
-					curr=bbs.get(idx++);
-				} else {
-					length=0; // stop, and return the count of how many we were able to load
-				}
-			}
-		}
-		return count;
-	}
+    public int read() {
+        if(curr!=null) { 
+            if(curr.remaining()>0) { // have a buffer, use it!
+                return curr.get();
+            } else if(idx<bbs.size()){ // Buffer not enough, get next one from array
+                curr=bbs.get(idx++);
+                return curr.get();
+            }
+        } // if no curr buffer, treat as end of stream
+        return -1;
+    }
+    
+    /**
+     * read into an array like Streams
+     * 
+     * @param array
+     * @param offset
+     * @param length
+     * @return
+     */
+    public int read(byte[] array, int offset, int length) {
+        if(curr==null)return -1;
+        int len;
+        int count=0;
+        while(length>0) { // loop through while there's data needed
+            if((len=curr.remaining())>length) { //  if enough data in curr buffer, use this code
+                curr.get(array,offset,length);
+                count+=length;
+                length=0;
+            } else {  // get data from curr, mark how much is needed to fulfil, and loop for next curr.
+                curr.get(array,offset,len);
+                count+=len;
+                offset+=len;
+                length-=len;
+                if(idx<bbs.size()) {
+                    curr=bbs.get(idx++);
+                } else {
+                    length=0; // stop, and return the count of how many we were able to load
+                }
+            }
+        }
+        return count;
+    }
 
-	/**
-	 * Put an array of data into Capacitor
-	 * 
-	 * @param array
-	 * @param offset
-	 * @param length
-	 */
-	public void put(byte[] array, int offset, int length) {
-		if(curr == null || curr.remaining()==0) {
-			curr = ringGet();
-			bbs.add(curr);
-		}
-		
-		int len;
-		while(length>0) {
-			if((len=curr.remaining())>length) {
-				curr.put(array,offset,length);
-				length=0;
-			} else {
-//				System.out.println(new String(array));
-				curr.put(array,offset,len);
-				length-=len;
-				offset+=len;
-				curr = ringGet();
-				bbs.add(curr);
-			}
-		}
-	}
-	 
-	/**
-	 * Move state from Storage mode into Read mode, changing all internal buffers to read mode, etc
-	 */
-	public void setForRead() {
-		for(ByteBuffer bb : bbs) {
-			bb.flip();
-		}
-		if(bbs.isEmpty()) {
-			curr = null;
-			idx = 0;
-		} else {
-			curr=bbs.get(0);
-			idx=1;
-		}
-	}
-	
-	/**
-	 * reuse all the buffers
-	 */
-	public void done() {
-		for(ByteBuffer bb : bbs) {
-			ringPut(bb);
-		}
-		bbs.clear();
-		curr = null;
-	}
-	
-	/**
-	 * Declare amount of data available to be read at once.
-	 * 
-	 * @return
-	 */
-	public int available() {
-		int count = 0;
-		for(ByteBuffer bb : bbs) {
-			count+=bb.remaining();
-		}
-		return count;
-	}
-	
-	/**
-	 * Returns how many are left that were not skipped
-	 * @param n
-	 * @return
-	 */
-	public long skip(long n) {
-		long skipped=0L;
-		int skip;
-		if(curr==null) {
-			return 0;
-		}
-		while(n>0) {
-			if(n<(skip=curr.remaining())) {
-				curr.position(curr.position()+(int)n);
-				skipped+=skip;
-				n=0;
-			} else {
-				curr.position(curr.limit());
-				
-				skipped-=skip;
-				if(idx<bbs.size()) {
-					curr=bbs.get(idx++);
-					n-=skip;
-				} else {
-					n=0;
-				}
-			}
-		}
-		return skipped > 0 ? skipped : 0;
-	}
-	/**
-	 * Be able to re-read data that is stored that has already been re-read.  This is not a standard Stream behavior, but can be useful
-	 * in a standalone mode.
-	 */
-	public void reset() {
-		for(ByteBuffer bb : bbs) {
-			bb.position(0);
-		}
-		if(bbs.isEmpty()) {
-			curr = null;
-			idx = 0;
-		} else {
-			curr=bbs.get(0);
-			idx=1;
-		}
-	}
+    /**
+     * Put an array of data into Capacitor
+     * 
+     * @param array
+     * @param offset
+     * @param length
+     */
+    public void put(byte[] array, int offset, int length) {
+        if(curr == null || curr.remaining()==0) {
+            curr = ringGet();
+            bbs.add(curr);
+        }
+        
+        int len;
+        while(length>0) {
+            if((len=curr.remaining())>length) {
+                curr.put(array,offset,length);
+                length=0;
+            } else {
+//                System.out.println(new String(array));
+                curr.put(array,offset,len);
+                length-=len;
+                offset+=len;
+                curr = ringGet();
+                bbs.add(curr);
+            }
+        }
+    }
+     
+    /**
+     * Move state from Storage mode into Read mode, changing all internal buffers to read mode, etc
+     */
+    public void setForRead() {
+        for(ByteBuffer bb : bbs) {
+            bb.flip();
+        }
+        if(bbs.isEmpty()) {
+            curr = null;
+            idx = 0;
+        } else {
+            curr=bbs.get(0);
+            idx=1;
+        }
+    }
+    
+    /**
+     * reuse all the buffers
+     */
+    public void done() {
+        for(ByteBuffer bb : bbs) {
+            ringPut(bb);
+        }
+        bbs.clear();
+        curr = null;
+    }
+    
+    /**
+     * Declare amount of data available to be read at once.
+     * 
+     * @return
+     */
+    public int available() {
+        int count = 0;
+        for(ByteBuffer bb : bbs) {
+            count+=bb.remaining();
+        }
+        return count;
+    }
+    
+    /**
+     * Returns how many are left that were not skipped
+     * @param n
+     * @return
+     */
+    public long skip(long n) {
+        long skipped=0L;
+        int skip;
+        if(curr==null) {
+            return 0;
+        }
+        while(n>0) {
+            if(n<(skip=curr.remaining())) {
+                curr.position(curr.position()+(int)n);
+                skipped+=skip;
+                n=0;
+            } else {
+                curr.position(curr.limit());
+                
+                skipped-=skip;
+                if(idx<bbs.size()) {
+                    curr=bbs.get(idx++);
+                    n-=skip;
+                } else {
+                    n=0;
+                }
+            }
+        }
+        return skipped > 0 ? skipped : 0;
+    }
+    /**
+     * Be able to re-read data that is stored that has already been re-read.  This is not a standard Stream behavior, but can be useful
+     * in a standalone mode.
+     */
+    public void reset() {
+        for(ByteBuffer bb : bbs) {
+            bb.position(0);
+        }
+        if(bbs.isEmpty()) {
+            curr = null;
+            idx = 0;
+        } else {
+            curr=bbs.get(0);
+            idx=1;
+        }
+    }
 
-	/*
-	 * Ring Functions.  Reuse allocated memory 
-	 */
-	private ByteBuffer ringGet() {
-		ByteBuffer bb = null;
-		synchronized(ring) {
-			bb=ring[start];
-			ring[start]=null;
-			if(bb!=null && ++start>15)start=0;
-		}
-		if(bb==null) {
-			bb=ByteBuffer.allocate(DEFAULT_CHUNK);
-		} else {
-			bb.clear();// refresh reused buffer
-		}
-		return bb;
-	}
-	
-	private void ringPut(ByteBuffer bb) {
-		synchronized(ring) {
-			ring[end]=bb; // if null or not, BB will just be Garbage collected
-			if(++end>15)end=0;
-		}
-	}
+    /*
+     * Ring Functions.  Reuse allocated memory 
+     */
+    private ByteBuffer ringGet() {
+        ByteBuffer bb = null;
+        synchronized(ring) {
+            bb=ring[start];
+            ring[start]=null;
+            if(bb!=null && ++start>15)start=0;
+        }
+        if(bb==null) {
+            bb=ByteBuffer.allocate(DEFAULT_CHUNK);
+        } else {
+            bb.clear();// refresh reused buffer
+        }
+        return bb;
+    }
+    
+    private void ringPut(ByteBuffer bb) {
+        synchronized(ring) {
+            ring[end]=bb; // if null or not, BB will just be Garbage collected
+            if(++end>15)end=0;
+        }
+    }
 
 }