114 lines
3.4 KiB
C++
114 lines
3.4 KiB
C++
// Copyright (c) 2016 The WebM project authors. All Rights Reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the LICENSE file in the root of the source
|
|
// tree. An additional intellectual property rights grant can be found
|
|
// in the file PATENTS. All contributing project authors may
|
|
// be found in the AUTHORS file in the root of the source tree.
|
|
#include "test_utils/limited_reader.h"
|
|
|
|
namespace webm {
|
|
|
|
LimitedReader::LimitedReader(std::unique_ptr<Reader> impl)
|
|
: impl_(std::move(impl)) {}
|
|
|
|
Status LimitedReader::Read(std::size_t num_to_read, std::uint8_t* buffer,
|
|
std::uint64_t* num_actually_read) {
|
|
assert(num_to_read > 0);
|
|
assert(buffer != nullptr);
|
|
assert(num_actually_read != nullptr);
|
|
|
|
*num_actually_read = 0;
|
|
std::size_t expected = num_to_read;
|
|
|
|
num_to_read = std::min({num_to_read, single_read_limit_, total_read_limit_});
|
|
|
|
// Handle total_read_skip_limit_ separately since std::size_t can be
|
|
// smaller than std::uint64_t.
|
|
if (num_to_read > total_read_skip_limit_) {
|
|
num_to_read = static_cast<std::size_t>(total_read_skip_limit_);
|
|
}
|
|
|
|
if (num_to_read == 0) {
|
|
return return_status_when_blocked_;
|
|
}
|
|
|
|
Status status = impl_->Read(num_to_read, buffer, num_actually_read);
|
|
assert(*num_actually_read <= num_to_read);
|
|
|
|
if (status.code == Status::kOkCompleted && *num_actually_read < expected) {
|
|
status.code = Status::kOkPartial;
|
|
}
|
|
|
|
if (total_read_limit_ != std::numeric_limits<std::size_t>::max()) {
|
|
total_read_limit_ -= static_cast<std::size_t>(*num_actually_read);
|
|
}
|
|
|
|
if (total_read_skip_limit_ != std::numeric_limits<std::uint64_t>::max()) {
|
|
total_read_skip_limit_ -= *num_actually_read;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
Status LimitedReader::Skip(std::uint64_t num_to_skip,
|
|
std::uint64_t* num_actually_skipped) {
|
|
assert(num_to_skip > 0);
|
|
assert(num_actually_skipped != nullptr);
|
|
|
|
*num_actually_skipped = 0;
|
|
std::uint64_t expected = num_to_skip;
|
|
|
|
num_to_skip = std::min({num_to_skip, single_skip_limit_, total_skip_limit_,
|
|
total_read_skip_limit_});
|
|
|
|
if (num_to_skip == 0) {
|
|
return return_status_when_blocked_;
|
|
}
|
|
|
|
Status status = impl_->Skip(num_to_skip, num_actually_skipped);
|
|
assert(*num_actually_skipped <= num_to_skip);
|
|
|
|
if (status.code == Status::kOkCompleted && *num_actually_skipped < expected) {
|
|
status.code = Status::kOkPartial;
|
|
}
|
|
|
|
if (total_skip_limit_ != std::numeric_limits<std::uint64_t>::max()) {
|
|
total_skip_limit_ -= *num_actually_skipped;
|
|
}
|
|
|
|
if (total_read_skip_limit_ != std::numeric_limits<std::uint64_t>::max()) {
|
|
total_read_skip_limit_ -= *num_actually_skipped;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
std::uint64_t LimitedReader::Position() const { return impl_->Position(); }
|
|
|
|
void LimitedReader::set_return_status_when_blocked(Status status) {
|
|
return_status_when_blocked_ = status;
|
|
}
|
|
|
|
void LimitedReader::set_single_read_limit(std::size_t max_num_bytes) {
|
|
single_read_limit_ = max_num_bytes;
|
|
}
|
|
|
|
void LimitedReader::set_single_skip_limit(std::uint64_t max_num_bytes) {
|
|
single_skip_limit_ = max_num_bytes;
|
|
}
|
|
|
|
void LimitedReader::set_total_read_limit(std::size_t max_num_bytes) {
|
|
total_read_limit_ = max_num_bytes;
|
|
}
|
|
|
|
void LimitedReader::set_total_skip_limit(std::uint64_t max_num_bytes) {
|
|
total_skip_limit_ = max_num_bytes;
|
|
}
|
|
|
|
void LimitedReader::set_total_read_skip_limit(std::uint64_t max_num_bytes) {
|
|
total_read_skip_limit_ = max_num_bytes;
|
|
}
|
|
|
|
} // namespace webm
|