The name of the parameter passed that specifies the total file size in
bytes.

@param sTotalFileSizeName
New value. May neither be <code>null</code> nor empty.
@return this
762219
@Nonnull
  public FineUploader5Request setTotalFileSizeName (@Nonnull @Nonempty final String sTotalFileSizeName)
  {
    ValueEnforcer.notEmpty (sTotalFileSizeName, "TotalFileSizeName");
    m_sRequestTotalFileSizeName = sTotalFileSizeName;
    return this;
  }
830734
@Nonnull
  public FineUploader5Chunking setParamNameChunkSize (@Nonnull @Nonempty final String sParamNameChunkSize)
  {
    ValueEnforcer.notEmpty (sParamNameChunkSize, "ParamNameChunkSize");
    m_sChunkingParamNamesChunkSize = sParamNameChunkSize;
    return this;
  }
433389
public void setSizeRefsByMsgSize(boolean sizeByMsgSize)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setSizeRefsByMsgSize", Boolean.valueOf(sizeByMsgSize));

        this._sizeRefsByMsgSize = sizeByMsgSize;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setSizeRefsByMsgSize");
    }
1238111
public byte[] ensureBufferHasCapacityLeft(int size) throws FileParsingException {
    if (bytesHolder == null) {
      bytesHolder = new ByteArrayHolder(size);
    } else {
      bytesHolder.ensureHasSpace(size);
    }
    return bytesHolder.getUnderlyingBytes();
  }
1008024
public Iterator<StashTableMetadata> listTableMetadata() {
        final String root = getRootPath();
        final String prefix = String.format("%s/", root);
        final int prefixLength = prefix.length();

        return new AbstractIterator<StashTableMetadata>() {
            PeekingIterator<S3ObjectSummary> _listResponse =
                    Iterators.peekingIterator(Iterators.<S3ObjectSummary>emptyIterator());
            String _marker = null;
            boolean _truncated = true;

            @Override
            protected StashTableMetadata computeNext() {
                String tableDir = null;
                List<StashFileMetadata> files = Lists.newArrayListWithCapacity(16);
                boolean allFilesRead = false;

                while (!allFilesRead) {
                    if (_listResponse.hasNext()) {
                        // Peek at the next record but don't consume it until we verify it's part of the same table
                        S3ObjectSummary s3File = _listResponse.peek();
                        String key = s3File.getKey();

                        // Don't include the _SUCCESS file or any other stray files we may find
                        String[] parentDirAndFile = key.substring(prefixLength).split("/");
                        if (parentDirAndFile.length != 2) {
                            // Consume and skip this row
                            _listResponse.next();
                        } else {
                            String parentDir = parentDirAndFile[0];
                            if (tableDir == null) {
                                tableDir = parentDir;
                            }

                            if (!parentDir.equals(tableDir)) {
                                allFilesRead = true;
                            } else {
                                // Record is part of this table; consume it now
                                _listResponse.next();
                                files.add(new StashFileMetadata(_bucket, key, s3File.getSize()));
                            }
                        }
                    } else if (_truncated) {
                        ObjectListing response = _s3.listObjects(new ListObjectsRequest()
                                .withBucketName(_bucket)
                                .withPrefix(prefix)
                                .withMarker(_marker)
                                .withMaxKeys(1000));

                        _listResponse = Iterators.peekingIterator(response.getObjectSummaries().iterator());
                        _marker = response.getNextMarker();
                        _truncated = response.isTruncated();
                    } else {
                        allFilesRead = true;
                    }
                }

                if (tableDir == null) {
                    // No files read this iteration means all files have been read
                    return endOfData();
                }

                String tablePrefix = prefix + tableDir + "/";
                String tableName = StashUtil.decodeStashTable(tableDir);
                return new StashTableMetadata(_bucket, tablePrefix, tableName, files);
            }
        };
    }
603472
private String setCurrentFilename(String relativePathOrPackage, String filename, String domain) throws Exception {
        currentFullFilename = convertToFullFilename(relativePathOrPackage, filename, domain);
        return "";
    }
131111
@Nonnull
  public FineUploader5Validation setImageMinWidth (@Nonnegative final int nImageMinWidth)
  {
    ValueEnforcer.isGE0 (nImageMinWidth, "ImageMinWidth");
    m_nValidationImageMinWidth = nImageMinWidth;
    return this;
  }
915195
@Nonnull
  public FineUploader5Validation setSizeLimit (@Nonnegative final int nSizeLimit)
  {
    ValueEnforcer.isGE0 (nSizeLimit, "SizeLimit");
    m_nValidationSizeLimit = nSizeLimit;
    return this;
  }
441662
public PartitionAwareDataWriterBuilder<S, D> forPartition(GenericRecord partition) {
    this.partition = Optional.fromNullable(partition);
    log.debug("For partition {}", this.partition);
    return this;
  }
531398
@Pure
	@Inline("((($1) == null) ? null : ($1).getName())")
	public static String largeBasename(File filename) {
		if (filename == null) {
			return null;
		}
		return filename.getName();
	}
540755
public void setFileMaxUploadSize(String value) {

        try {
            m_fileMaxUploadSize = Integer.valueOf(value).intValue();
        } catch (NumberFormatException e) {
            // can usually be ignored
            if (LOG.isInfoEnabled()) {
                LOG.info(e.getLocalizedMessage());
            }
            m_fileMaxUploadSize = -1;
        }
        if (CmsLog.INIT.isInfoEnabled()) {
            if (m_fileMaxUploadSize > 0) {
                CmsLog.INIT.info(
                    Messages.get().getBundle().key(
                        Messages.INIT_MAX_FILE_UPLOAD_SIZE_1,
                        new Integer(m_fileMaxUploadSize)));
            } else {
                CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_MAX_FILE_UPLOAD_SIZE_UNLIMITED_0));
            }

        }
    }
1141415
public FileContentFileName inFileNamed(String filenamePattern)
    {
        if (filenamePattern != null && !filenamePattern.isEmpty())
        {
            this.filenamePattern = new RegexParameterizedPatternParser(filenamePattern);
        }
        return this;
    }
61009
@Nonnull
  public final UnifiedResponse setContentDispositionFilename (@Nonnull @Nonempty final String sFilename)
  {
    ValueEnforcer.notEmpty (sFilename, "Filename");

    // Ensure that a valid filename is used
    // -> Strip all paths and replace all invalid characters
    final String sFilenameToUse = FilenameHelper.getWithoutPath (FilenameHelper.getAsSecureValidFilename (sFilename));
    if (!sFilename.equals (sFilenameToUse))
      logWarn ("Content-Dispostion filename was internally modified from '" +
               sFilename +
               "' to '" +
               sFilenameToUse +
               "'");

    // Disabled because of the extended UTF-8 handling (RFC 5987)
    if (false)
    {
      // Check if encoding as ISO-8859-1 is possible
      if (m_aContentDispositionEncoder == null)
        m_aContentDispositionEncoder = StandardCharsets.ISO_8859_1.newEncoder ();
      if (!m_aContentDispositionEncoder.canEncode (sFilenameToUse))
        logError ("Content-Dispostion filename '" + sFilenameToUse + "' cannot be encoded to ISO-8859-1!");
    }

    // Are we overwriting?
    if (m_sContentDispositionFilename != null)
      logInfo ("Overwriting Content-Dispostion filename from '" +
               m_sContentDispositionFilename +
               "' to '" +
               sFilenameToUse +
               "'");

    // No URL encoding necessary.
    // Filename must be in ISO-8859-1
    // See http://greenbytes.de/tech/tc2231/
    m_sContentDispositionFilename = sFilenameToUse;
    return this;
  }
396146
def make_fileitem_sizeinbytes(filesize, condition='is', negate=False):
    
    document = 'FileItem'
    search = 'FileItem/SizeInBytes'
    content_type = 'int'
    content = filesize
    ii_node = ioc_api.make_indicatoritem_node(condition, document, search, content_type, content,
                                              negate=negate)
    return ii_node
23490
public com.google.protobuf.ByteString
      getFilenameTensorNameBytes() {
    java.lang.Object ref = filenameTensorName_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      filenameTensorName_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
983091
public int allocateSpace(final int iSize) throws IOException {
    final int offset = getFilledUpTo();
    final int size = getFileSize();

    if (getFreeSpace() < iSize) {
      if (maxSize > 0 && maxSize - size < iSize)
        throw new IllegalArgumentException("Cannot enlarge file since the configured max size ("
            + OFileUtils.getSizeAsString(maxSize) + ") was reached! " + toString());

      // MAKE ROOM
      int newFileSize = size;

      if (newFileSize == 0)
        // PROBABLY HAS BEEN LOST WITH HARD KILLS
        newFileSize = DEFAULT_SIZE;

      // GET THE STEP SIZE IN BYTES
      int stepSizeInBytes = incrementSize > 0 ? incrementSize : -1 * size / 100 * incrementSize;

      // FIND THE BEST SIZE TO ALLOCATE (BASED ON INCREMENT-SIZE)
      while (newFileSize - offset <= iSize) {
        newFileSize += stepSizeInBytes;

        if (newFileSize == 0)
          // EMPTY FILE: ALLOCATE REQUESTED SIZE ONLY
          newFileSize = iSize;
        if (newFileSize > maxSize && maxSize > 0)
          // TOO BIG: ROUND TO THE MAXIMUM FILE SIZE
          newFileSize = maxSize;
      }

      setSize(newFileSize);
    }

    // THERE IS SPACE IN FILE: RETURN THE UPPER BOUND OFFSET AND UPDATE THE FILLED THRESHOLD
    setFilledUpTo(offset + iSize);

    return offset;
  }
718690
@Nonnull
  public FineUploader5Validation setImageMaxWidth (@Nonnegative final int nImageMaxWidth)
  {
    ValueEnforcer.isGE0 (nImageMaxWidth, "ImageMaxWidth");
    m_nValidationImageMaxWidth = nImageMaxWidth;
    return this;
  }