How big is the page, excluding headers?
506749
public int getDataSize() {
        // Data size is given by lvs
        int size = 0;
        for(int i=0; i<numLVs; i++) {
            size += IOUtils.toInt(lvs[i]);
        }
        return size;
    }
846554
def check_content_length(status, headers, env)
      headers.each { |key, value|
        if key.downcase == 'content-length'
          ## There must not be a <tt>Content-Length</tt> header when the
          ## +Status+ is 1xx, 204 or 304.
          assert("Content-Length header found in #{status} response, not allowed") {
            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
          }

          bytes = 0
          string_body = true

          if @body.respond_to?(:to_ary)
            @body.each { |part|
              unless part.kind_of?(String)
                string_body = false
                break
              end

              bytes += Rack::Utils.bytesize(part)
            }

            if env["REQUEST_METHOD"] == "HEAD"
              assert("Response body was given for HEAD request, but should be empty") {
                bytes == 0
              }
            else
              if string_body
                assert("Content-Length header was #{value}, but should be #{bytes}") {
                  value == bytes.to_s
                }
              end
            end
          end

          return
        end
      }
    end
313126
def total_pages(key, page_size)
      (Amico.redis.zcard(key) / page_size.to_f).ceil
    end
247806
def size():
    
    try:
        assert os != 'nt' and sys.stdout.isatty()
        rows, columns = os.popen('stty size', 'r').read().split()
    except (AssertionError, AttributeError, ValueError):
        # in case of failure, use dimensions of a full screen 13" laptop
        rows, columns = DEFAULT_HEIGHT, DEFAULT_WIDTH

    return int(rows), int(columns)
1009767
def page_size(self) -> int:
        
        page_count = self.page_count
        return self.paginator.max_size + len(f'\nPage {page_count}/{page_count}')
1045107
def validate_page_size(ctx, param, value):
    """"""
    # pylint: disable=unused-argument
    if value == 0:
        raise click.BadParameter("Page size must be non-zero or unset.", param=param)
    return value
1269109
def size(self):
        
        return self._size_full_intension \
                    - len(self.exclude)\
                    + len(self.include)
597177
def header(self, array):
        

        self._check_row_size(array)
        self._header = map(str, array)
806267
function() {
        var w = 0;
        for (var p=0;p<this.pages.length;++p) {
            var cal = this.pages[p];
            w += cal.oDomContainer.offsetWidth;
        }
        if (w > 0) {
            this.oDomContainer.style.width = w + "px";
        }
    }
763886
private short getPageLength () {
        short pageLength = 0;
        for (int i = 0; i < identificationDescriptors.length; ++i) {
            pageLength += identificationDescriptors[i].size();
        }
        return pageLength;
    }
1295214
private int calculatePageSize()
    {
        int meanColumnCount = hintStore.getMeanColumns();
        if (meanColumnCount <= 0)
            return PAGE_SIZE;

        int averageColumnSize = (int) (hintStore.getMeanRowSize() / meanColumnCount);
        if (averageColumnSize <= 0)
            return PAGE_SIZE;

        // page size of 1 does not allow actual paging b/c of >= behavior on startColumn
        return Math.max(2, Math.min(PAGE_SIZE, 4 * 1024 * 1024 / averageColumnSize));
    }
703653
def pagedump(self):
        
        self.fh.seek(self.pagesize)
        pn = 1
        while True:
            try:
                pagedata = self.fh.read(self.pagesize)
                if len(pagedata) == 0:
                    break
                elif len(pagedata) != self.pagesize:
                    print("%06x: incomplete - %d bytes ( pagesize = %d )" % (pn, len(pagedata), self.pagesize))
                    break
                elif pagedata == b'\x00' * self.pagesize:
                    print("%06x: empty" % (pn))
                else:
                    page = self.page(pagedata)

                    print("%06x: preceeding = %06x, reccount = %04x" % (pn, page.preceeding, page.count))
                    for ent in page.index:
                        print("    %s" % ent)
            except Exception as e:
                print("%06x: ERROR decoding as B-tree page: %s" % (pn, e))
            pn += 1
1267001
private function manuallyDetermineHeaderLength()
    {
        // This separator is part of the Start Game command, which is the very
        // first command in the recorded game body. It's … reasonably accurate.
        $separator = pack('c*', 0xF4, 0x01, 0x00, 0x00);
        // We need to reset the file pointer when we're done
        $initialBase = ftell($this->fp);

        $base = $initialBase;
        $buffer = '';
        while (($buffer = fread($this->fp, 8192)) !== false) {
            $index = strpos($buffer, $separator);
            if ($index !== false) {
                $this->headerLen = $base + $index - 4;
                break;
            }
            $base += strlen($buffer);
        }
        fseek($this->fp, $initialBase);
    }
1229969
def content_length(self) -> Optional[int]:
        """"""
        content_length = self._headers.get(hdrs.CONTENT_LENGTH)  # type: ignore

        if content_length is not None:
            return int(content_length)
        else:
            return None
1197122
def size(self):
        
        return len(self._query_compiler.index) * len(self._query_compiler.columns)
88097
def getsize(self, path=None, client_kwargs=None, header=None):
        
        return self._getsize_from_header(self.head(path, client_kwargs, header))
382652
def size(self):
        
        #return len(self._fetch_items())
        if self._check_hash_view():
            return 1
        else:
            return self.engine.open().view.size(xmlrpc.NOHASH, self.viewname)