printIntAny
In general, prefer printInt to avoid generic explosion. However this
function may be used when optimal codegen for a particular integer type is
desired.
Function parameters
Parameters
- w:*Writer
- value:anytype
- base:u8
- case:std.fmt.Case
- options:std.fmt.Options
Type definitions in this namespace
Types
- Allocating
- Maintains `Writer` state such that it writes to the unused capacity of an
Writes to `buffer` and returns `error.WriteFailed` when it is full.
Functions
- fixed
- Writes to `buffer` and returns `error.WriteFailed` when it is full.
- buffered
- Returns the contents not yet drained.
- writeVec
- If the total number of bytes of `data` fits inside `unusedCapacitySlice`,
- writeSplat
- If the number of bytes to write based on `data` and `splat` fits inside
- writeSplatHeader
- Returns how many bytes were consumed from `header` and `data`.
- writeSplatHeaderLimit
- Equivalent to `writeSplatHeader` but writes at most `limit` bytes.
- flush
- Drains all remaining buffered data.
- defaultFlush
- Repeatedly calls `VTable.drain` until `end` is zero.
- noopFlush
- Does nothing.
- writableArray
- Asserts the provided buffer has total capacity enough for `len`.
- writableSlice
- Asserts the provided buffer has total capacity enough for `len`.
- writableSliceGreedy
- Asserts the provided buffer has total capacity enough for `minimum_len`.
- writableSliceGreedyPreserve
- Asserts the provided buffer has total capacity enough for `minimum_len`
- writableSlicePreserve
- Asserts the provided buffer has total capacity enough for `len`.
- advance
- After calling `writableSliceGreedy`, this function tracks how many bytes
- writeVecAll
- The `data` parameter is mutable because this function needs to mutate the
- writeSplatAll
- The `data` parameter is mutable because this function needs to mutate the
- writeAll
- Calls `drain` as many times as necessary such that all of `bytes` are
- Renders fmt string with args, calling `writer` with slices of bytes.
- writeByte
- Calls `drain` as many times as necessary such that `byte` is transferred.
- writeBytePreserve
- When draining the buffer, ensures that at least `preserve` bytes
- splatByteAll
- Writes the same byte many times, performing the underlying write call as
- splatByte
- Writes the same byte many times, allowing short writes.
- splatBytesAll
- Writes the same slice many times, performing the underlying write call as
- splatBytes
- Writes the same slice many times, allowing short writes.
- writeInt
- Asserts the `buffer` was initialized with a capacity of at least `@sizeOf(T)` bytes.
- writeStruct
- The function is inline to avoid the dead code in case `endian` is
- sendFile
- Unlike `writeSplat` and `writeVec`, this function will call into `VTable`
- sendFileHeader
- Returns how many bytes from `header` and `file_reader` were consumed.
- sendFileReading
- Asserts nonzero buffer capacity and nonzero `limit`.
- sendFileAll
- Number of bytes logically written is returned.
- sendFileReadingAll
- Equivalent to `sendFileAll` but uses direct `pread` and `read` calls on
- printValue
- Asserts `buffer` capacity of at least 2 if `value` is a union.
- printIntAny
- In general, prefer `printInt` to avoid generic explosion.
- printFloat
- Uses a larger stack buffer; asserts mode is decimal or scientific.
- printFloatHexOptions
- Uses a smaller stack buffer; asserts mode is not decimal or scientific.
- printByteSize
- Format option `precision` is ignored when `value` is less than 1kB
- printDuration
- Writes number of nanoseconds according to its signed magnitude:
- writeUleb128
- Write a single unsigned integer as LEB128 to the given writer.
- writeSleb128
- Write a single signed integer as LEB128 to the given writer.
- writeLeb128
- Write a single integer as LEB128 to the given writer.
- consume
- Removes the first `n` bytes from `buffer` by shifting buffer contents,
- consumeAll
- Shortcut for setting `end` to zero and returning zero.
- unimplementedSendFile
- For use when the `Writer` implementation can cannot offer a more efficient
- fixedDrain
- When this function is called it usually means the buffer got full, so it's
- Hashed
- Provides a `Writer` implementation based on calling `Hasher.update`, sending
- Hashing
- Provides a `Writer` implementation based on calling `Hasher.update`,
Error sets in this namespace
Error Sets
= .{ .vtable = &.{ .drain = failingDrain, .sendFile = failingSendFile, .rebase = failingRebase, }, .buffer = &.{}, }
Values
- failing
- = .{ .vtable = &.{ .drain = failingDrain, .sendFile = failingSendFile, .rebase = failingRebase, }, .buffer = &.{}, }
Source
Implementation
pub fn printIntAny(
w: *Writer,
value: anytype,
base: u8,
case: std.fmt.Case,
options: std.fmt.Options,
) Error!void {
assert(base >= 2);
const value_info = @typeInfo(@TypeOf(value)).int;
// The type must have the same size as `base` or be wider in order for the
// division to work
const min_int_bits = comptime @max(value_info.bits, 8);
const MinInt = std.meta.Int(.unsigned, min_int_bits);
const abs_value = @abs(value);
// The worst case in terms of space needed is base 2, plus 1 for the sign
var buf: [1 + @max(@as(comptime_int, value_info.bits), 1)]u8 = undefined;
var a: MinInt = abs_value;
var index: usize = buf.len;
if (base == 10) {
while (a >= 100) : (a = @divTrunc(a, 100)) {
index -= 2;
buf[index..][0..2].* = std.fmt.digits2(@intCast(a % 100));
}
if (a < 10) {
index -= 1;
buf[index] = '0' + @as(u8, @intCast(a));
} else {
index -= 2;
buf[index..][0..2].* = std.fmt.digits2(@intCast(a));
}
} else {
while (true) {
const digit = a % base;
index -= 1;
buf[index] = std.fmt.digitToChar(@intCast(digit), case);
a /= base;
if (a == 0) break;
}
}
if (value_info.signedness == .signed) {
if (value < 0) {
// Negative integer
index -= 1;
buf[index] = '-';
} else if (options.width == null or options.width.? == 0) {
// Positive integer, omit the plus sign
} else {
// Positive integer
index -= 1;
buf[index] = '+';
}
}
return w.alignBufferOptions(buf[index..], options);
}