Adding ManuscriptQueue and ReviewedList

contracts/FIFO.sol

@@ -0,0 +1,32 @@
+pragma solidity ^0.4.6;
+
+contract FIFO {
+  bytes32[] fifoQueue;
+  uint cursorPosition;
+
+  function queueDepth()
+      public
+      constant
+      returns(uint queueDepth)
+  {
+      return fifoQueue.length - cursorPosition;
+  }
+
+  function push(bytes32 requestPaperHash)
+        public
+        returns(uint PaperNumber)
+    {
+        if(fifoQueue.length + 1 < fifoQueue.length) throw; // exceeded 2^256 push requests
+        return fifoQueue.push(requestPaperHash) - 1;
+    }
+
+  function pop()
+        public
+        returns(uint, bytes32)
+    {
+        if(fifoQueue.length==0) throw;
+        if(fifoQueue.length - 1 < cursorPosition) throw;
+        cursorPosition += 1;
+        return (cursorPosition -1, fifoQueue[cursorPosition -1]);
+    }
+}

contracts/LinkedList.sol

@@ -0,0 +1,64 @@
+library DoublyLinkedList {
+    struct data {
+        uint80 first;
+        uint80 last;
+        uint80 count;
+        Item[] items;
+    }
+    uint80 constant None = uint80(0);
+    struct Item {
+        uint80 prev;
+        uint80 next;
+        bytes32 data;
+    }
+    /// Appends `_data` to the end of the list `self`.
+    function append(data storage self, bytes32 _data) {
+        var index = uint80(self.items.push(Item({prev: self.last, next: None, data: _data})));
+        if (self.last == None)
+        {
+            if (self.first != None || self.count != 0) throw;
+            self.first = self.last = index;
+            self.count = 1;
+        }
+        else
+        {
+            self.items[self.last - 1].next = index;
+            self.last = index;
+            self.count ++;
+        }
+    }
+    /// Removes the element identified by the iterator
+    /// `_index` from the list `self`.
+    function remove(data storage self, uint80 _index) {
+        Item item = self.items[_index - 1];
+        if (item.prev == None)
+            self.first = item.next;
+        if (item.next == None)
+            self.last = item.prev;
+        if (item.prev != None)
+            self.items[item.prev - 1].next = item.next;
+        if (item.next != None)
+            self.items[item.next - 1].prev = item.prev;
+        delete self.items[_index - 1];
+        self.count--;
+    }
+    /// @return an iterator pointing to the first element whose data
+    /// is `_value` or an invalid iterator otherwise.
+    function find(data storage self, bytes32 _value) returns (uint80) {
+        var it = iterate_start(self);
+        while (iterate_valid(self, it)) {
+            if (iterate_get(self, it) == _value)
+                return it;
+            it = iterate_next(self, it);
+        }
+        return it;
+    }
+    // Iterator interface
+    function iterate_start(data storage self) returns (uint80) { return self.first; }
+    function iterate_end(data storage self) returns (uint80) { return self.last; }
+    function size_list(data storage self) returns (uint80) { return self.count; }
+    function iterate_valid(data storage self, uint80 _index) returns (bool) { return _index - 1 < self.items.length; }
+    function iterate_prev(data storage self, uint80 _index) returns (uint80) { return self.items[_index - 1].prev; }
+    function iterate_next(data storage self, uint80 _index) returns (uint80) { return self.items[_index - 1].next; }
+    function iterate_get(data storage self, uint80 _index) returns (bytes32) { return self.items[_index - 1].data; }
+}

contracts/SubmittedPapersIndex.sol

@@ -1,14 +1,54 @@
 pragma solidity ^0.4.7;
 
+import "./FIFO.sol";
+import "./LinkedList.sol";
+
 contract SubmittedPapersIndex {
-  bytes32[] public store;
 
-  function push(bytes32 _hash) {
+  FIFO public ManuscriptQueue;
+  DoublyLinkedList.data public ReviewedManuscripts;
+
+  function FifoClient(){
+    ManuscriptQueue = new FIFO();
+  }
+  /**
+    Queue(FIFO) Accept Manuscripts and add to queue to be vetted.
+  */
+  function push(bytes32 _hash)
+    public
+    returns(uint ManuscriptNumber)
+  {
     require(_hash != 0x00);
-    store.push(_hash);
+    uint ManuscriptNum = ManuscriptQueue.push(_hash);
+    return ManuscriptNum;
   }
-
-  function getAll() constant returns (bytes32[] hashes) {
-    return store;
+  /**
+    Function called after a Manuscript is vetted
+    Append vetted manuscript to ReviewedManuscriptList.
+  */
+  function pop()
+    public
+    returns(uint, bytes32)
+  {
+    uint ManuscriptNum;
+    bytes32 ManuscriptHash;
+    (ManuscriptNum, ManuscriptHash) = PaperQueue.pop();
+    ReviewedList.append(ManuscriptHash);
+    return(ManuscriptNum, ManuscriptHash);
   }
+  /**
+    Function to get all manuscript indexes.
+  */
+  function getAll()
+    constant returns (bytes32[] hashes)
+    {
+      bytes32[] store;
+      var count = ReviewedList.size_list();
+      var it = ReviewedList.iterate_start();
+      while(it != count){
+        store.push(ReviewedList.iterate_get(it));
+        it = ReviewedList.iterate_next(it);
+      }
+      return store;
+    }
 }