Rollup merge of #109174 - soerenmeier:cursor_fns, r=dtolnay · model-checking/verify-rust-std@f9befad (original) (raw)

`@@ -209,55 +209,60 @@ impl Cursor

209

`where

210

`T: AsRef<[u8]>,

211

212

/// Returns the remaining slice.

212

/// Splits the underlying slice at the cursor position and returns them.

213

`///

214

`/// # Examples

215

`///

216

```` /// ```


`217`

``

`-

/// #![feature(cursor_remaining)]

`

``

`217`

`+

/// #![feature(cursor_split)]

`

`218`

`218`

`/// use std::io::Cursor;

`

`219`

`219`

`///

`

`220`

`220`

`/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

`

`221`

`221`

`///

`

`222`

``

`-

/// assert_eq!(buff.remaining_slice(), &[1, 2, 3, 4, 5]);

`

``

`222`

`+

/// assert_eq!(buff.split(), ([].as_slice(), [1, 2, 3, 4, 5].as_slice()));

`

`223`

`223`

`///

`

`224`

`224`

`/// buff.set_position(2);

`

`225`

``

`-

/// assert_eq!(buff.remaining_slice(), &[3, 4, 5]);

`

`226`

``

`-

///

`

`227`

``

`-

/// buff.set_position(4);

`

`228`

``

`-

/// assert_eq!(buff.remaining_slice(), &[5]);

`

``

`225`

`+

/// assert_eq!(buff.split(), ([1, 2].as_slice(), [3, 4, 5].as_slice()));

`

`229`

`226`

`///

`

`230`

`227`

`/// buff.set_position(6);

`

`231`

``

`-

/// assert_eq!(buff.remaining_slice(), &[]);

`

``

`228`

`+

/// assert_eq!(buff.split(), ([1, 2, 3, 4, 5].as_slice(), [].as_slice()));

`

`232`

`229`

```` /// ```

233

#[unstable(feature = "cursor_remaining", issue = "86369")]

234

pub fn remaining_slice(&self) -> &[u8] {

235

let len = self.pos.min(self.inner.as_ref().len() as u64);

236

&self.inner.as_ref()[(len as usize)..]

230

#[unstable(feature = "cursor_split", issue = "86369")]

231

pub fn split(&self) -> (&[u8], &[u8]) {

232

let slice = self.inner.as_ref();

233

let pos = self.pos.min(slice.len() as u64);

234

slice.split_at(pos as usize)

237

235

236

}

238

237

239

`` -

/// Returns true if the remaining slice is empty.

238

impl Cursor

239

where

240

T: AsMut<[u8]>,

241

{

242

/// Splits the underlying slice at the cursor position and returns them

243

/// mutably.

240

244

`///

241

245

`/// # Examples

242

246

`///

243

247

```` /// ```


`244`

``

`-

/// #![feature(cursor_remaining)]

`

``

`248`

`+

/// #![feature(cursor_split)]

`

`245`

`249`

`/// use std::io::Cursor;

`

`246`

`250`

`///

`

`247`

`251`

`/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);

`

`248`

`252`

`///

`

`249`

``

`-

/// buff.set_position(2);

`

`250`

``

`-

/// assert!(!buff.is_empty());

`

``

`253`

`+

/// assert_eq!(buff.split_mut(), ([].as_mut_slice(), [1, 2, 3, 4, 5].as_mut_slice()));

`

`251`

`254`

`///

`

`252`

``

`-

/// buff.set_position(5);

`

`253`

``

`-

/// assert!(buff.is_empty());

`

``

`255`

`+

/// buff.set_position(2);

`

``

`256`

`+

/// assert_eq!(buff.split_mut(), ([1, 2].as_mut_slice(), [3, 4, 5].as_mut_slice()));

`

`254`

`257`

`///

`

`255`

``

`-

/// buff.set_position(10);

`

`256`

``

`-

/// assert!(buff.is_empty());

`

``

`258`

`+

/// buff.set_position(6);

`

``

`259`

`+

/// assert_eq!(buff.split_mut(), ([1, 2, 3, 4, 5].as_mut_slice(), [].as_mut_slice()));

`

`257`

`260`

```` /// ```

258

#[unstable(feature = "cursor_remaining", issue = "86369")]

259

pub fn is_empty(&self) -> bool {

260

self.pos >= self.inner.as_ref().len() as u64

261

#[unstable(feature = "cursor_split", issue = "86369")]

262

pub fn split_mut(&mut self) -> (&mut [u8], &mut [u8]) {

263

let slice = self.inner.as_mut();

264

let pos = self.pos.min(slice.len() as u64);

265

slice.split_at_mut(pos as usize)

261

266

262

267

263

268

`@@ -319,15 +324,15 @@ where

319

324

`T: AsRef<[u8]>,

320

325

321

326

`fn read(&mut self, buf: &mut [u8]) -> io::Result {

322

let n = Read::read(&mut self.remaining_slice(), buf)?;

327

let n = Read::read(&mut Cursor::split(self).1, buf)?;

323

328

`self.pos += n as u64;

324

329

`Ok(n)

325

330

326

331

327

332

`fn read_buf(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {

328

333

`let prev_written = cursor.written();

329

334

330

Read::read_buf(&mut self.remaining_slice(), cursor.reborrow())?;

335

Read::read_buf(&mut Cursor::split(self).1, cursor.reborrow())?;

331

336

332

337

`self.pos += (cursor.written() - prev_written) as u64;

333

338

`@@ -351,7 +356,7 @@ where

351

356

352

357

353

358

`fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {

354

let result = Read::read_exact(&mut self.remaining_slice(), buf);

359

let result = Read::read_exact(&mut Cursor::split(self).1, buf);

355

360

356

361

`match result {

357

362

`Ok(_) => self.pos += buf.len() as u64,

`@@ -365,14 +370,14 @@ where

365

370

`fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {

366

371

`let prev_written = cursor.written();

367

372

368

let result = Read::read_buf_exact(&mut self.remaining_slice(), cursor.reborrow());

373

let result = Read::read_buf_exact(&mut Cursor::split(self).1, cursor.reborrow());

369

374

`self.pos += (cursor.written() - prev_written) as u64;

370

375

371

376

` result

372

377

373

378

374

379

`fn read_to_end(&mut self, buf: &mut Vec) -> io::Result {

375

let content = self.remaining_slice();

380

let content = Cursor::split(self).1;

376

381

`let len = content.len();

377

382

` buf.try_reserve(len)?;

378

383

` buf.extend_from_slice(content);

`@@ -383,7 +388,7 @@ where

383

388

384

389

`fn read_to_string(&mut self, buf: &mut String) -> io::Result {

385

390

`let content =

386

crate::str::from_utf8(self.remaining_slice()).map_err(|_| io::Error::INVALID_UTF8)?;

391

crate::str::from_utf8(Cursor::split(self).1).map_err(|_| io::Error::INVALID_UTF8)?;

387

392

`let len = content.len();

388

393

` buf.try_reserve(len)?;

389

394

` buf.push_str(content);

`@@ -399,7 +404,7 @@ where

399

404

`T: AsRef<[u8]>,

400

405

401

406

`fn fill_buf(&mut self) -> io::Result<&[u8]> {

402

Ok(self.remaining_slice())

407

Ok(Cursor::split(self).1)

403

408

404

409

`fn consume(&mut self, amt: usize) {

405

410

`self.pos += amt as u64;