Returns an {@link java.util.LinkedList} of the {@link android.database.Cursor} and closes
it.
557241
public static <T> LinkedList<T> consumeToLinkedList(IterableCursor<T> cursor) {
        return consumeToCollection(cursor, new LinkedList<T>());
    }
1095235
@Override
    public void close() throws IOException {
        if (!closed) {
            closed = true;
            nodeCursor = null;
            _currToken = null;
        }
    }
414788
@Override
  public void close() {
    if (isClosed())
      return;

    vertexBaseClass = null;
    edgeBaseClass = null;

    checkOpeness();
    rollback();

    getMetadata().close();
    ((ODatabaseRaw) underlying.getUnderlying()).callOnCloseListeners();
    getLevel1Cache().clear();

    final OGraphDatabasePool pool = ownerPool;
    ownerPool = null;
    pool.release(this);
  }
1269465
@SuppressWarnings("unchecked")
    public CompletableFuture<Void> close() {

        this.closed = true;

        List<CompletableFuture<Void>> futures = new ArrayList<>();

        forEach((connectionKey, closeable) -> {

            futures.add(closeable.closeAsync());
            connections.remove(connectionKey);
        });

        return Futures.allOf(futures);
    }
1186671
def close(self):
        
        if self._closed:
            raise ProgrammingError('the cursor is already closed')
        if self._id is not None:
            self._connection._client.close_statement(self._connection._id, self._id)
            self._id = None
        self._signature = None
        self._column_data_types = []
        self._frame = None
        self._pos = None
        self._closed = True
494711
public static <T> ArrayList<T> consumeToArrayList(IterableCursor<T> cursor) {
        return consumeToCollection(cursor, new ArrayList<T>(cursor.getCount()));
    }
41880
protected T cursorToObject(Cursor cursor) throws SQLException {
		return preparedQuery.mapRow(new AndroidDatabaseResults(cursor, null, true));
	}
415991
public static void close(Iterable<? extends Closeable> closeables)
            throws IOException {
        IOException first = null;
        for (final Closeable c : closeables) {
            if (c == null) {
                LOG.debug("trying to call .close() on null reference");
                continue;
            }
            try {
                c.close();
            } catch (final IOException e) {
                if (first == null) {
                    first = e;
                } else {
                    first.addSuppressed(e);
                }
            }
        }
        if (first != null) {
            throw first;
        }
    }
195132
function LinkedList( ... elements ) {
	this.head = null ;
	this.tail = null ;
	this.length = 0 ;

	if ( elements.length ) {
		this.push( ... elements ) ;
	}
}
677297
private boolean closeStatements() {

      // JDBC API says...
      // Calling the method close on a Statement object that is already closed has no effect.
      // Note: When a Statement object is closed, its current ResultSet object, if one exists, is also closed.

      boolean hasUnclosed = false;

      if(openStatements.size() > 0) {
         for(Statement stmt : openStatements) {
            try {
               if(!stmt.isClosed()) {
                  stmt.close();
                  hasUnclosed = true;
               }
            } catch(SQLException e) {
               hasUnclosed = true;
               setLogicalCloseException(e);
            } catch(Throwable t) {
               hasUnclosed = true;
               if(logicalCloseException == null) {
                  if(Util.isRuntimeError(t)) {
                     setLogicalCloseException(t);
                  } else {
                     setLogicalCloseException(new SQLException(t));
                  }
               }
            }
         }

         openStatements.clear();
      }

      return hasUnclosed;
   }
1247365
public final Link getNextLink() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(this, tc, "getNextLink", _positionString());
        }
        Link nextLink = null;
        LinkedList parent = _parent;
        if (null != parent) {
            nextLink = _parent.getNextLink(this);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(this, tc, "getNextLink", nextLink);
        }
        return nextLink;
    }
1122080
def close(self):
        
        if not self._closed:
            try:
                self._cursor.close()
            except Exception:
                pass
            self._closed = True
72205
public java.util.List<DBClusterEndpoint> getDBClusterEndpoints() {
        if (dBClusterEndpoints == null) {
            dBClusterEndpoints = new com.amazonaws.internal.SdkInternalList<DBClusterEndpoint>();
        }
        return dBClusterEndpoints;
    }
144037
public static <T> List<T> getList(final Cursor cursor, final Class<T> klass) {
        try {
            return getObjectsFromCursor(cursor, klass);
        } catch (final Exception e) {
            Logger.ex(e);
            return null;
        }
    }
622058
public static <T> LinkedList<T> newLinkedList(Iterable<? extends T> elements) {
		return Lists.newLinkedList(elements);
	}
215514
public void close () {
		Connection[] connections = this.connections;
		for (int i = 0; i < connections.length; i++)
			connections[i].removeListener(invokeListener);

		synchronized (instancesLock) {
			ArrayList<ObjectSpace> temp = new ArrayList(Arrays.asList(instances));
			temp.remove(this);
			instances = temp.toArray(new ObjectSpace[temp.size()]);
		}

		if (TRACE) trace("kryonet", "Closed ObjectSpace.");
	}
1214316
@NonNull
    Collection<TObj> getAll() {
        Collection<TObj> result = new LinkedList<>();
        for (int countR = mData.size(), i = 0; i < countR; i++) {
            int rowKey = mData.keyAt(i);
            SparseArrayCompat<TObj> columns = mData.get(rowKey);
            for (int countC = columns.size(), j = 0; j < countC; j++) {
                int key = columns.keyAt(j);
                result.add(columns.get(key));
            }
        }
        return result;
    }