Sets the chunk following this chunk in the list of free chunks.

        :param fwd: the chunk to follow this chunk in the list of free chunks
552559
def set_fwd_chunk(self, fwd):
        
        raise NotImplementedError("%s not implemented for %s" % (self.set_fwd_chunk.__func__.__name__,
                                                                 self.__class__.__name__))
1349832
def chunks(f, chunk_size=None):
    
    if not chunk_size:
        chunk_size = 64 * 2 ** 10

    if hasattr(f, "seek"):
        f.seek(0)

    while True:
        data = f.read(chunk_size)
        if not data:
            break
        yield data
1075205
def _startNextChunk(self) -> None:
        
        if self.currentChunk is None:
            self._useLatestChunk()
        else:
            self._useChunk(self.currentChunkIndex + self.chunkSize)
836341
def chunks(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.chunks.__func__.__name__,
                                                                 self.__class__.__name__))
146732
def setter(self, fset):
        
        self.fset = fset
        self.pipe_write = PipeWriteType.PIPE_READ_WRITE
        return self
1122404
def start_transmit(self, fd, data=None):
        
        self._wfds[fd] = (data or fd, self._generation)
        self._update(fd)
280095
private void seekToChunkStart()
    {
        if (getOnDiskFilePointer() != chunkOffset)
        {
            try
            {
                out.seek(chunkOffset);
            }
            catch (IOException e)
            {
                throw new FSReadError(e, getPath());
            }
        }
    }
471269
def set_non_blocking(io)
      flag = File::NONBLOCK
      if defined?(Fcntl::F_GETFL)
        flag |= io.fcntl(Fcntl::F_GETFL)
      end
      io.fcntl(Fcntl::F_SETFL, flag)
    end
203816
def chdir(self, path):
        
        self.cwd = self._join_chunks(self._normalize_path(path))
1099025
def GenFwdState(self):
    
    for c in self.cont:
      self._AddToken("FWD", c, None, None)
    for s in self.sep:
      self._AddToken("FWD", s, None, None)
    self._AddToken("FWD", ".", "PushBack,PopState", None)
433752
def fwd_chunk(self):
        
        if self.is_free():
            base = self.state.memory.load(self.base + 2 * self._chunk_size_t_size, self._chunk_size_t_size)
            return PTChunk(base, self.state)
        else:
            raise SimHeapError("Attempted to access the forward chunk of an allocated chunk")
1267303
public void setChunking()
    {
        checkOutput();
        if (_bufferedOut instanceof ChunkingOutputStream)
            ((ChunkingOutputStream)_bufferedOut).setChunking(true);
        else
            throw new IllegalStateException(_bufferedOut.getClass().toString());
    }
261834
def bck_chunk(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.bck_chunk.__func__.__name__,
                                                                 self.__class__.__name__))
164563
def set_fd_value(tag, value):
    
    if tag.VR == 'OB' or tag.VR == 'UN':
        value = struct.pack('d', value)
    tag.value = value
663718
function (fp) {
    if (this.content) return this;
    fp = path.resolve(this.cwd, fp || this.path);
    this.content = utils.tryRead(fp);
    return this;
  }
277665
def prev_chunk(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.prev_chunk.__func__.__name__,
                                                                 self.__class__.__name__))
1249885
private void add_block_to_freelist(Block block, int ql_index)
    {
        block.next = ql_heads[ql_index].first_block;
        ql_heads[ql_index].first_block = block;
        ql_heads[ql_index].length++;
        if (ql_heads[ql_index].length == 1) {
            nonempty_lists++;
        }
    }