Renamed => getMoreMptr in OpCursor to getMoreTokens, Removed default Parameter

LES-TODOS

@@ -14,10 +14,13 @@ done
 - remove ReadCache
 - Index API
 - Indexes always return std::vector<TOKEN>
+- Rename OperationCursor->getMoreMptr => getMoreTokens, "returns" std::vector<TOKEN>&
 
 in progress
 -----------
-- Rename OperationCursor->getMoreMptr => getMoreTokens, "returns" std::vector<TOKEN>&
+- GeoIndex hands out TRI_revision instead of Tokens
+- FulltextIndex hands out TRI_revision instead of Tokens
+- trx::InvokeOnAllElements : uses SimpleIndexLookupElements => Has to use Tokens instead?
 - move engine-specific parts of transaction.cpp into engine
 - transaction API
 
@@ -37,6 +40,3 @@ to do
   - slice() => looksup the value in the Database
   - We need to keep in mind the cluster. If a DBServer creates this token-type it has to be translated BEFORE the register is teleported to coordinator
 - Remove temporary wrapper LogCol::readDocument()
-- GeoIndex hands out TRI_revision instead of Tokens
-- FulltextIndex hands out TRI_revision instead of Tokens
-- trx::InvokeOnAllElements : uses SimpleIndexLookupElements => Has to use Tokens instead?

arangod/Aql/CollectionScanner.cpp

@@ -49,7 +49,7 @@ void CollectionScanner::scan(std::vector<arangodb::DocumentIdentifierToken>& res
     return;
   }
 
-  _cursor->getMoreMptr(result, batchSize); 
+  _cursor->getMoreTokens(result, batchSize); 
 }
 
 int CollectionScanner::forward(size_t batchSize, uint64_t& skipped) {

arangod/Aql/IndexBlock.cpp

@@ -412,7 +412,7 @@ bool IndexBlock::readIndex(size_t atMost) {
     }
 
     LogicalCollection* collection = _cursor->collection();
-    _cursor->getMoreMptr(_result, atMost);
+    _cursor->getMoreTokens(_result, atMost);
 
     size_t length = _result.size();
 

arangod/Aql/ShortestPathBlock.cpp

@@ -96,7 +96,7 @@ struct ConstDistanceExpanderLocal {
       _cursor.clear();
       LogicalCollection* collection = edgeCursor->collection();
       while (edgeCursor->hasMore()) {
-        edgeCursor->getMoreMptr(_cursor, 1000);
+        edgeCursor->getMoreTokens(_cursor, 1000);
         for (auto const& element : _cursor) {
           if (collection->readDocument(_block->transaction(), *mmdr, element)) {
             VPackSlice edge(mmdr->vpack());
@@ -239,7 +239,7 @@ struct EdgeWeightExpanderLocal {
       cursor.clear();
       LogicalCollection* collection = edgeCursor->collection();
       while (edgeCursor->hasMore()) {
-        edgeCursor->getMoreMptr(cursor, 1000);
+        edgeCursor->getMoreTokens(cursor, 1000);
         for (auto const& element : cursor) {
           if (collection->readDocument(_block->transaction(), *mmdr, element)) {
             VPackSlice edge(mmdr->vpack());

arangod/RestHandler/RestEdgesHandler.cpp

@@ -95,7 +95,7 @@ bool RestEdgesHandler::getEdgesForVertexList(
   ManagedDocumentResult mmdr;
   auto collection = trx.documentCollection();
   while (cursor->hasMore()) {
-    cursor->getMoreMptr(batch);
+    cursor->getMoreTokens(batch, 1000);
     scannedIndex += batch.size();
 
     for (auto const& it : batch) {
@@ -132,7 +132,7 @@ bool RestEdgesHandler::getEdgesForVertex(
   ManagedDocumentResult mmdr;
   auto collection = trx.documentCollection();
   while (cursor->hasMore()) {
-    cursor->getMoreMptr(batch);
+    cursor->getMoreTokens(batch, 1000);
     scannedIndex += batch.size();
 
     for (auto const& it : batch) {

arangod/Utils/OperationCursor.cpp

@@ -41,20 +41,20 @@ void OperationCursor::reset() {
 }
 
 //////////////////////////////////////////////////////////////////////////////
-/// @brief Get next batchSize many elements. mptr variant
+/// @brief Get next batchSize many DocumentTokens.
 ///        Defaults to _batchSize
 ///        Check hasMore()==true before using this
 ///        NOTE: This will throw on OUT_OF_MEMORY
 //////////////////////////////////////////////////////////////////////////////
 
-std::vector<DocumentIdentifierToken> OperationCursor::getMoreMptr(uint64_t batchSize) {
+std::vector<DocumentIdentifierToken> OperationCursor::getMoreTokens(uint64_t batchSize) {
   std::vector<DocumentIdentifierToken> res;
-  getMoreMptr(res, batchSize);
+  getMoreTokens(res, batchSize);
   return res;
 }
 
 //////////////////////////////////////////////////////////////////////////////
-/// @brief Get next batchSize many elements. mptr variant
+/// @brief Get next batchSize many DocumentTokens.
 ///        Defaults to _batchSize
 ///        Check hasMore()==true before using this
 ///        NOTE: This will throw on OUT_OF_MEMORY
@@ -62,7 +62,7 @@ std::vector<DocumentIdentifierToken> OperationCursor::getMoreMptr(uint64_t batch
 ///              The caller shall NOT modify it.
 //////////////////////////////////////////////////////////////////////////////
 
-void OperationCursor::getMoreMptr(std::vector<DocumentIdentifierToken>& result,
+void OperationCursor::getMoreTokens(std::vector<DocumentIdentifierToken>& result,
                                   uint64_t batchSize) {
   if (!hasMore()) {
     TRI_ASSERT(false);

arangod/Utils/OperationCursor.h

@@ -108,7 +108,7 @@ struct OperationCursor {
 ///        NOTE: This will throw on OUT_OF_MEMORY
 //////////////////////////////////////////////////////////////////////////////
   
-  std::vector<DocumentIdentifierToken> getMoreMptr(uint64_t batchSize = 1000);
+  std::vector<DocumentIdentifierToken> getMoreTokens(uint64_t batchSize);
 
 //////////////////////////////////////////////////////////////////////////////
 /// @brief Get next batchSize many elements. mptr variant
@@ -118,7 +118,7 @@ struct OperationCursor {
 ///        NOTE: The result vector handed in will be cleared.
 //////////////////////////////////////////////////////////////////////////////
 
-  void getMoreMptr(std::vector<DocumentIdentifierToken>& result, uint64_t batchSize = 1000);
+  void getMoreTokens(std::vector<DocumentIdentifierToken>& result, uint64_t batchSize);
 
 //////////////////////////////////////////////////////////////////////////////
 /// @brief Skip the next toSkip many elements.

arangod/Utils/Transaction.cpp

@@ -1290,7 +1290,7 @@ OperationResult Transaction::anyLocal(std::string const& collectionName,
   
   while (cursor->hasMore()) {
     result.clear();
-    cursor->getMoreMptr(result);
+    cursor->getMoreTokens(result, 1000);
     for (auto const& element : result) {
       if (collection->readDocument(this, mmdr, element)) {
         uint8_t const* vpack = mmdr.vpack();
@@ -2679,7 +2679,7 @@ OperationResult Transaction::allLocal(std::string const& collectionName,
   result.reserve(1000);
   
   while (cursor->hasMore()) {
-    cursor->getMoreMptr(result, 1000);
+    cursor->getMoreTokens(result, 1000);
     for (auto const& element : result) {
       if (collection->readDocument(this, mmdr, element)) {
         uint8_t const* vpack = mmdr.vpack();

arangod/V8Server/v8-query.cpp

@@ -259,8 +259,7 @@ static void JS_AllQuery(v8::FunctionCallbackInfo<v8::Value> const& args) {
   VPackBuilder resultBuilder;
   resultBuilder.openArray();
   while (opCursor->hasMore()) {
-    opCursor->getMoreMptr(batch);
+    opCursor->getMoreTokens(batch, 1000);
-    // We only need this one call, limit == batchsize
     for (auto const& it : batch) {
       if (collection->readDocument(&trx, mmdr, it)) {
         resultBuilder.add(VPackSlice(mmdr.vpack()));

arangod/VocBase/SingleServerTraverser.cpp

@@ -121,7 +121,7 @@ bool SingleServerEdgeCursor::next(std::vector<VPackSlice>& result,
       // If we switch the cursor. We have to clear the cache.
       _cache.clear();
     } else {
-      cursor->getMoreMptr(_cache);
+      cursor->getMoreTokens(_cache, 1000);
     }
   } while (_cache.empty());
 
@@ -158,7 +158,7 @@ bool SingleServerEdgeCursor::readAll(std::unordered_set<VPackSlice>& result,
     while (cursor->hasMore()) {
       // NOTE: We cannot clear the cache,
       // because the cursor expect's it to be filled.
-      cursor->getMoreMptr(_cache);
+      cursor->getMoreTokens(_cache, 1000);
       for (auto const& element : _cache) {
         if (collection->readDocument(_trx, *_mmdr, element)) {
           result.emplace(_mmdr->vpack());