Returns an immutable list of transactions held in this block, or null if this object represents just a header.
329661
@Nullable
    public List<Transaction> getTransactions() {
        return transactions == null ? null : ImmutableList.copyOf(transactions);
    }
91777
private List<SynchroTable> readTableHeaders(InputStream is) throws IOException
   {
      // Read the headers
      List<SynchroTable> tables = new ArrayList<SynchroTable>();
      byte[] header = new byte[48];
      while (true)
      {
         is.read(header);
         m_offset += 48;
         SynchroTable table = readTableHeader(header);
         if (table == null)
         {
            break;
         }
         tables.add(table);
      }

      // Ensure sorted by offset
      Collections.sort(tables, new Comparator<SynchroTable>()
      {
         @Override public int compare(SynchroTable o1, SynchroTable o2)
         {
            return o1.getOffset() - o2.getOffset();
         }
      });

      // Calculate lengths
      SynchroTable previousTable = null;
      for (SynchroTable table : tables)
      {
         if (previousTable != null)
         {
            previousTable.setLength(table.getOffset() - previousTable.getOffset());
         }

         previousTable = table;
      }

      for (SynchroTable table : tables)
      {
         SynchroLogger.log("TABLE", table);
      }

      return tables;
   }
1020378
public TransactionWrapper getTransactionWrapper(Transaction t) {
    	if (t == null) {
    		return null;
    	}
    	final TransactionWrapperAppData twad = (TransactionWrapperAppData) t.getApplicationData();
    	return twad != null ? twad.getTransactionWrapper(t, this) : null;
	}
778734
@Pure
	public List<Object> getRemovedValues() {
		if (this.oldValues == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.oldValues);
	}
421814
def get_transactions(self):
        
        self.transactions[:] = NetworkAPI.get_transactions(self.address)
        if self.segwit_address:
            self.transactions += NetworkAPI.get_transactions(self.segwit_address)
        return self.transactions
267819
private JSONArray retrievePerPartitionTransactionIds() {
        JSONArray retval = new JSONArray();
        try {
            ByteBuffer values = ByteBuffer.wrap(m_zk.getData(VoltZK.perPartitionTxnIds, false, null));
            int numKeys = values.getInt();
            for (int ii = 0; ii < numKeys; ii++) {
                retval.put(values.getLong());
            }
        } catch (KeeperException.NoNodeException e) {/*doesn't have to exist*/}
        catch (Exception e) {
            VoltDB.crashLocalVoltDB("Failed to retrieve per partition transaction ids for snapshot", false, e);
        }
        return retval;
    }
99334
private void getHeadersFromFrame() {
        byte[] hbf = null;
        if (currentFrame.getFrameType() == FrameTypes.HEADERS || currentFrame.getFrameType() == FrameTypes.PUSHPROMISEHEADERS) {
            hbf = ((FrameHeaders) currentFrame).getHeaderBlockFragment();
        } else if (currentFrame.getFrameType() == FrameTypes.CONTINUATION) {
            hbf = ((FrameContinuation) currentFrame).getHeaderBlockFragment();
        }

        if (hbf != null) {
            if (headerBlock == null) {
                headerBlock = new ArrayList<byte[]>();
            }
            headerBlock.add(hbf);
        }
    }
517148
private List<Entry> getPendingWrites() {
    synchronized (this) {
      List<Entry> save = this.pendingWrites;
      this.pendingWrites = new LinkedList<>();
      return save;
    }
  }
1265057
List<Message> getMutableList() {
        if (mode != StorageMode.LIST) {
            if (mode == StorageMode.MAP) {
                listData = convertMapToList(mapData);
            }
            mapData = null;
            mode = StorageMode.LIST;
        }
        return listData;
    }
1174499
List<Object> getConnections(ConnectionListener cl)
   {
      List<Object> l = null;

      if (clToC != null)
         l = clToC.get(cl);

      if (l == null)
         l = Collections.emptyList();
         
      return Collections.unmodifiableList(l);
   }
1133193
protected List<T> currentResults() {
        return results == null ? Collections.emptyList()
            : Collections.unmodifiableList(results);
    }
587902
def transaction(&block)
			Thread.current[:txids] = []
			ODBA.storage.transaction(&block)
		rescue Exception => excp
			transaction_rollback
			raise excp
		ensure
			Thread.current[:txids] = nil
		end
129093
public ArrayList<String> getRows() {
		ArrayList<String> rows = new ArrayList<String>();
		for (String row : rowLookup.keySet()) {
			HeaderInfo hi = rowLookup.get(row);
			if (!hi.isHide()) {
				rows.add(row);
			}
		}
		return rows;
	}
203067
List<Transaction> getAllTxns() throws IOException {
    Log log = this.persistence.getLog();
    List<Transaction> txns = new ArrayList<Transaction>();
    try(Log.LogIterator iter = log.getIterator(new Zxid(0, 0))) {
      while(iter.hasNext()) {
        txns.add(iter.next());
      }
      return txns;
    }
  }
839330
@Override
	public List<Object> getServices(Class<?> root,Class<?> transactionType){
		Map<Class<?>, List<Object>> map = mapBusinessProvider.get(root);
		if(map != null){
			List<Object> list = map.get(transactionType);
			if(list != null){
				return Collections.unmodifiableList(list);
			}
		}
		return null;
	}
1292220
@Pure
	public Iterable<BusItineraryHalt> getBindedBusHalts() {
		if (this.halts == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableCollection(this.halts);
	}
601603
public <T> List<T> asList() {
		String cacheKey = null;
		
		// is the result of the query cached?
		if (isCacheable() && transaction == null) {
			cacheKey = getCacheKey();
			List<Key> keys = getCacheManager().get(cacheNamespace, cacheKey);
			if (keys != null) {
				if (isKeysOnly()) {
					return (List) keys;
				} else {
					final Map<Key, T> values = entityManager.get(keys);
					return Lists.transform(keys, new Function<Key, T>() {

						@Override
						public T apply(Key key) {
							return values.get(key);
						}
						
					});
				}
			}
		}
		
		// execute the query
		List<T> result = Lists.newArrayList((Iterable<T>) asIterable());
		if (isCacheable()) {
			Collection<Key> keys = isKeysOnly()? result : Collections2.transform(result, new EntityToKeyFunction(classMetadata.getPersistentClass()));
			populateCache(cacheKey, Lists.newArrayList(keys));
		}
		return result;
	}