Decompresses the list of entries and returns the list of composition times.

@param entries composition time to sample entries in compressed form
@return decoding time per sample
769161
public static int[] blowupCompositionTimes(List<CompositionTimeToSample.Entry> entries) {
        long numOfSamples = 0;
        for (CompositionTimeToSample.Entry entry : entries) {
            numOfSamples += entry.getCount();
        }
        assert numOfSamples <= Integer.MAX_VALUE;
        int[] decodingTime = new int[(int) numOfSamples];

        int current = 0;


        for (CompositionTimeToSample.Entry entry : entries) {
            for (int i = 0; i < entry.getCount(); i++) {
                decodingTime[current++] = entry.getOffset();
            }
        }

        return decodingTime;
    }
363714
public void setEntries(java.util.Collection<ChangeMessageVisibilityBatchRequestEntry> entries) {
        if (entries == null) {
            this.entries = null;
            return;
        }

        this.entries = new com.amazonaws.internal.SdkInternalList<ChangeMessageVisibilityBatchRequestEntry>(entries);
    }
1075004
public <T extends IEntity> List<T> upload(List<UploadEntry> entries) throws FMSException {


        List<IntuitMessage> intuitMessages = prepareUpload(entries);

        //execute interceptors
        if(!intuitMessages.isEmpty()) {
            executeInterceptors(intuitMessages);
        }

        return getResultEntities(intuitMessages);

    }
1000894
public AbstractDoubleList times(int times) {
	AbstractDoubleList newList = new DoubleArrayList(times*size());
	for (int i=times; --i >= 0; ) {
		newList.addAllOfFromTo(this,0,size()-1);
	}
	return newList;
}
95294
public static void pack(ZipEntrySource[] entries, File zip) {
    if (log.isDebugEnabled()) {
      log.debug("Creating '{}' from {}.", zip, Arrays.asList(entries));
    }

    OutputStream out = null;
    try {
      out = new BufferedOutputStream(new FileOutputStream(zip));
      pack(entries, out, true);
    }
    catch (IOException e) {
      throw ZipExceptionUtil.rethrow(e);
    }
    finally {
      IOUtils.closeQuietly(out);
    }
  }
754272
private static List<ManifestEntry> asManifestEntryList( final Map<String, String> entries )
    {
        final List<ManifestEntry> manifestEntries = new ArrayList<ManifestEntry>();
        if( entries != null && !entries.isEmpty() )
        {
            for( Map.Entry<String, String> entry : entries.entrySet() )
            {
                manifestEntries.add( new ManifestEntry( entry.getKey(), entry.getValue() ) );
            }
        }
        return manifestEntries;
    }
796119
public void setEntries(List<E> entries) {
        if (entries == null) {
            this.entries = new ArrayList<>();
        } else {
            this.entries = entries;
        }
    }
724101
public Map<Integer, List<Row>> createTimeEntryMap(List<Row> rows)
   {
      Map<Integer, List<Row>> map = new HashMap<Integer, List<Row>>();
      for (Row row : rows)
      {
         Integer workPatternID = row.getInteger("TIME_ENTRYID");
         List<Row> list = map.get(workPatternID);
         if (list == null)
         {
            list = new LinkedList<Row>();
            map.put(workPatternID, list);
         }
         list.add(row);
      }
      return map;
   }
1206323
public final void addEntries(Entry<?>... entries) {
        if (entries != null) {
            for (Entry<?> entry : entries) {
                entry.setCalendar(this);
            }
        }
    }
228106
public static String decompress(final byte[] strBytes) {

        if (strBytes[0] == UNCOMPRESSED_FLAG) {
            return new String(strBytes, 1, strBytes.length, Charsets.UTF_8);
        }

        final StringBuilder out = new StringBuilder();

        for (int i = 0; i < strBytes.length; i++) {
            final char b = (char) (0xFF & strBytes[i]);
            if (b == 254) {
                out.append((char) strBytes[++i]);
            } else if (b == 255) {
                final int length = 0xFF & strBytes[++i];
                for (int j = 1; j <= length; j++) {
                    out.append((char) strBytes[i + j]);
                }
                i += length;
            } else {
                final int loc = 0xFF & b;
                out.append(REVERSE_CODEBOOK[loc]);
            }
        }
        return out.toString();
    }
242451
public AbstractByteList times(int times) {
	AbstractByteList newList = new ByteArrayList(times*size());
	for (int i=times; --i >= 0; ) {
		newList.addAllOfFromTo(this,0,size()-1);
	}
	return newList;
}
1172801
protected static final List<Entry> copy (final List<Entry> entries) {
        if (entries == null) return null;
        final ArrayList<Entry> copy = new ArrayList<>();
        for (Entry e : entries)
            copy.add(e.copy());
        return copy;
    }

    /**
     * The abstract constructor.
     * <p>
     * Calls {@link #initializeEntries()}.
     */
    public SettingsNegotiator () {
        initializeEntries();
    }

    /**
     * Stores an exact copy of {@link #entries} in {@link #backUpEntries}.
     */
    protected final void backUpEntries () {
        backUpEntries = copy(entries);
    }

    /**
     * This method must be called at the end of a parameter negotiation task, either to roll back any changes that must
     * not take effect, or in order to ensure that consecutive negotiations are carried out correctly.
     * 
     * @param commitChanges <code>true</code> if and only if the negotiated changes to the elements in {@link #entries}
     *            are to be remembered.
     */
    protected final void commitOrRollBackChanges (final boolean commitChanges) {
        if (commitChanges)
            for (Entry e : entries)
                // allow renegotiation where allowed
                e.resetAlreadyNegotiated();
        else
            entries = backUpEntries;// roll back
        backUpEntries = null;// won't be needed anymore
    }

    /**
     * Adds a properly initialized {@link Entry} object to {@link #entries} for every parameter managed by this
     * {@link SettingsNegotiator}.
     */
    protected abstract void initializeEntries ();

    /**
     * Checks constraints that cannot be checked at the {@link Entry} level, e.g. because they depend on the values of
     * multiple parameters.
     * 
     * @return <code>true</code> if everything is fine, <code>false</code> if that is not the case
     */
    public abstract boolean checkConstraints ();
}
1253549
@Override
    public final byte[] decompress(byte[] compressed) {
        Assert.notNull(compressed, "compressed bytes cannot be null.");

        try {
            return doDecompress(compressed);
        } catch (IOException e) {
            throw new CompressionException("Unable to decompress bytes.", e);
        }
    }
1053510
protected void writeEntry(final GZIPArchive.Entry entry) throws IOException {

		// ID1 ID2 CM FLG

		this.output.write(GZIPArchive.GZIP_START);

		// MTIME

		writeLEInt(this.output, entry.mtime);

		// XFL OS

		this.output.write(GZIPArchive.XFL_OS);

		/* EXTRA begin */

		// XLEN

		writeLEShort(this.output, GZIPArchive.XLEN);

		// SI1 SI2 (as in warc spec)

		this.output.write(GZIPArchive.SKIP_LEN);

		// LEN

		writeLEShort(this.output, GZIPArchive.SUB_LEN);

		// compressed-skip-length (as in warc spec)

		writeLEInt(this.output, entry.compressedSkipLength);

		// uncompressed length (as in warc spec)

		writeLEInt(this.output, entry.uncompressedSkipLength);

		/* EXTRA end */

		// NAME

		this.output.write(entry.name);
		this.output.write(0);

		// COMMENT

		this.output.write(entry.comment);
		this.output.write(0);

		// compressed blocks

		this.output.write(deflaterStream.array, 0, deflaterStream.length);

		// CRC32

		writeLEInt(this.output, entry.crc32);

		// ISIZE

		writeLEInt(this.output, entry.uncompressedSkipLength);

	}
47086
public void fillDefault(List<CmsSitemapEntryBean> entries) {

        if (!m_disableFillDefault) {
            fill(entries);
            selectSite(m_handler.getDefaultSelectedSiteRoot());
        }
    }
872829
public List<Entry> getEntries() {
		if(_sortedEntries == null) {
			this._sortedEntries = Lists.newArrayListWithCapacity(entries.size());
			for(Map.Entry<Term, Entry> e:entries.entrySet())
				this._sortedEntries.add(e.getValue());
			Collections.sort(this._sortedEntries);
		}
		return _sortedEntries;
	}
1292325
@JsonProperty(value = "entries")
    public void setEntries(List<Object> entries) {
        if (entries == null) {
            this.entries = new ArrayList<>();
        } else {
            this.entries = entries;
        }
    }