Returns the size of the file.

!! WARNING !!
Calling this loads the entire file into memory,
unless it is on a stream-capable filesystem.
In case of bigger files this could throw exceptions,
and will have heavy performance footprint.
!! ------- !!
970792
public function getSize()
    {
        // This can only work on streamable files, so basically local files,
        // still only perform it once even on local files to avoid bothering the filesystem.php g
        if ($this->filesystem->getAdapter() instanceof StreamFactory && !$this->size) {
            if ($this->streamWrapperPrefix) {
                try {
                    $this->setSize(filesize($this->streamWrapperPrefix.$this->getKey()));
                } catch (\Exception $e) {
                    // Fail gracefully if there was a problem with opening the file and
                    // let gaufrette load the file into memory allowing it to throw exceptions
                    // if that doesn't work either.
                    // Not empty to make the scrutiziner happy.
                    return parent::getSize();
                }
            }
        }

        return parent::getSize();
    }
304123
public int getSize() {
    if (mPooledByteBufferRef != null && mPooledByteBufferRef.get() != null) {
      return mPooledByteBufferRef.get().size();
    }
    return mStreamSize;
  }
545915
def get_size(self):
    
    if not self._is_open:
      raise IOError('Not opened.')

    if self._fsntfs_data_stream:
      return self._fsntfs_data_stream.get_size()
    return self._fsntfs_file_entry.get_size()
253318
public int size() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "size");

    /* Because the table could be 'resized' (and therefore replaced) during   */
    /* the method we get a local ref to the current one & use it throughout.  */
    Entry[] safeTable = table;

    long count = 0;
    Entry current;

    /* Go through the linked lists in the table, counting non-null entries    */
    for (int i = 0; i < safeTable.length; i++) {
      current = safeTable[i];
      while (current != null) {
        count++;
        current = current.next;
      }
    }

    if (count > Integer.MAX_VALUE) {
      count = Integer.MAX_VALUE;
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "size",  (int)count);
    return (int)count;
  }
231976
def get_file_size(file_object):
    ''''''
    position = file_object.tell()

    file_object.seek(0, 2)
    file_size = file_object.tell()
    file_object.seek(position, 0)

    return file_size
1362066
public final int size()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "size");
    int result = (m_tail >= m_head) ? (m_tail - m_head) : (m_array.length - m_head + m_tail);
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "size", new Integer(result));
    return result;
  }
769650
public Integer getFileSizeThreshold()
   {
      if (childNode.getTextValueForPatternName("file-size-threshold") != null && !childNode.getTextValueForPatternName("file-size-threshold").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("file-size-threshold"));
      }
      return null;
   }
708728
def get_size(self):
    
    if not self._is_open:
      raise IOError('Not opened.')

    if self._decoded_stream_size is None:
      self._decoded_stream_size = self._GetDecodedStreamSize()

    return self._decoded_stream_size
1366940
def get_size(fileobj):
    

    old_pos = fileobj.tell()
    try:
        fileobj.seek(0, 2)
        return fileobj.tell()
    finally:
        fileobj.seek(old_pos, 0)
62705
public int size() {
		writeLock.lock();
		try {
			if (this.size < 0) {
				this.size = 0;
				for (LinkedHashMap<String, String> value : this.values()) {
					this.size += value.size();
				}
			}
		} finally {
			writeLock.unlock();
		}
		return this.size;
	}
812289
public int size() {
        int retval=0;
        for(long i=low, num_iterations=0; i < high && num_iterations < buffer.length; i++, num_iterations++) {
            int index=index(i);
            if(buffer[index] != null)
                retval++;
        }
        return retval;
    }
1106253
def get_file_size(filename):
    
    if os.path.isfile(filename):
        return convert_size(os.path.getsize(filename))
    return None
1089162
def size(self, filename: str) -> int:
        '''
        '''
        yield from self._control_stream.write_command(Command('SIZE', filename))

        reply = yield from self._control_stream.read_reply()

        self.raise_if_not_match('File size', ReplyCodes.file_status, reply)

        try:
            return int(reply.text.strip())
        except ValueError:
            return
1183395
public int size() {
        if (pad_bits == 0) {
            return bin.length;
        }
        if (bin.length == 0) {
            throw new java.lang.IllegalStateException("Impossible length");
        }
        return bin.length - 1;
    }
431445
function getSize()
    {
        if (!$this->_assertUsable())
            return null;

        $size  = null;
        if ($uri = $this->getMetadata('uri'))
            ## clear the stat cache of stream URI
            clearstatcache(true, $uri);

        $stats = fstat($this->rHandler);
        if (isset($stats['size']))
            $size = $stats['size'];

        return $size;
    }
297343
public static Long getSize(final File file){
        if ( file!=null && file.exists() ){
            return file.length();
        }
        return null;
    }
132622
public int getSize() {
		if (size < 0) {
			size = logCache==null ? 0 : logCache.getSize();
			size += traceCache==null ? 0 : traceCache.getSize();
		}
		return size;
	}