Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Foundation
  - Donate
- Resources
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.experimental.allocator.common

Utility and ancillary artifacts of std.experimental.allocator. This module shouldn't be used directly; its functionality will be migrated into more appropriate parts of std.
Authors:
Andrei Alexandrescu, Timon Gehr (Ternary)

template `stateSize`(T)
  Returns the size in bytes of the state that needs to be allocated to hold an object of type T. `stateSize`!T is zero for structs that are not nested and have no nonstatic member variables.
enum auto `hasStaticallyKnownAlignment`(Allocator);
  Returns true if the Allocator has the alignment known at compile time; otherwise it returns false.
enum uint `chooseAtRuntime`;
  `chooseAtRuntime` is a compile-time constant of type size_t that several parameterized structures in this module recognize to mean deferral to runtime of the exact value. For example, BitmappedBlock!(Allocator, 4096) (described in detail below) defines a block allocator with block size of 4096 bytes, whereas BitmappedBlock!(Allocator, `chooseAtRuntime`) defines a block allocator that has a field storing the block size, initialized by the user.
enum uint `unbounded`;
  `unbounded` is a compile-time constant of type size_t that several parameterized structures in this module recognize to mean "infinite" bounds for the parameter. For example, Freelist (described in detail below) accepts a maxNodes parameter limiting the number of freelist items. If `unbounded` is passed for maxNodes, then there is no limit and no checking for the number of nodes.
enum uint `platformAlignment`;
  The alignment that is guaranteed to accommodate any D object allocation on the current platform.
size_t `goodAllocSize`(A)(auto ref A `a`, size_t `n`);
  The default good size allocation is deduced as `n` rounded up to the allocator's alignment.
package pure nothrow @nogc @safe size_t `roundUpToMultipleOf`(size_t `s`, uint `base`);
  Returns `s` rounded up to a multiple of `base`.
package pure nothrow @nogc @safe size_t `roundUpToAlignment`(size_t `n`, uint `alignment`);
  Returns `n` rounded up to a multiple of `alignment`, which must be a power of 2.
package pure nothrow @nogc @safe size_t `roundDownToAlignment`(size_t `n`, uint `alignment`);
  Returns `n` rounded down to a multiple of `alignment`, which must be a power of 2.
package pure nothrow @nogc void[] `roundUpToAlignment`(void[] `b`, uint `a`);
  Advances the beginning of `b` to start at alignment `a`. The resulting buffer may therefore be shorter. Returns the adjusted buffer, or `null` if obtaining `a` non-empty buffer is impossible.
package pure nothrow @nogc @safe size_t `divideRoundUp`(size_t `a`, size_t `b`);
  Like `a` / `b` but rounds the result up, not down.
package pure nothrow @nogc void[] `roundStartToMultipleOf`(void[] `s`, uint `base`);
  Returns `s` rounded up to a multiple of `base`.
package pure nothrow @nogc @safe size_t `roundUpToPowerOf2`(size_t `s`);
  Returns `s` rounded up to the nearest power of 2.
package pure nothrow @nogc @safe uint `trailingZeros`(ulong `x`);
  Returns the number of trailing zeros of `x`.
pure nothrow @nogc bool `alignedAt`(T)(T* `ptr`, uint `alignment`);
  Returns true if `ptr` is aligned at `alignment`.
package pure nothrow @nogc uint `effectiveAlignment`(void* `ptr`);
  Returns the effective alignment of `ptr`, i.e. the largest power of two that is a divisor of `ptr`.
package pure nothrow @nogc void* `alignDownTo`(void* `ptr`, uint `alignment`);
  Aligns a pointer down to a specified `alignment`. The resulting pointer is less than or equal to the given pointer.
package pure nothrow @nogc void* `alignUpTo`(void* `ptr`, uint `alignment`);
  Aligns a pointer up to a specified `alignment`. The resulting pointer is greater than or equal to the given pointer.
bool `reallocate`(Allocator)(ref Allocator `a`, ref void[] `b`, size_t `s`);
  The default `reallocate` function first attempts to use expand. If Allocator.expand is not defined or returns `false`, `reallocate` allocates `a` new block of memory of appropriate size and copies data from the old block to the new block. Finally, if Allocator defines deallocate, `reallocate` uses it to free the old memory block.
  `reallocate` does not attempt to use Allocator.`reallocate` even if defined. This is deliberate so allocators may use it internally within their own implementation of `reallocate`.
bool `alignedReallocate`(Allocator)(ref Allocator `alloc`, ref void[] `b`, size_t `s`, uint `a`);
  The default `alignedReallocate` function first attempts to use expand. If Allocator.expand is not defined or returns `false`, `alignedReallocate` allocates `a` new block of memory of appropriate size and copies data from the old block to the new block. Finally, if Allocator defines deallocate, `alignedReallocate` uses it to free the old memory block.
  `alignedReallocate` does not attempt to use Allocator.reallocate even if defined. This is deliberate so allocators may use it internally within their own implementation of reallocate.
string `forwardToMember`(string `member`, string[] `funs`...);
  Forwards each of the methods in `funs` (if defined) to `member`.

Copyright © 1999-2017 by the D Language Foundation | Page generated by Ddoc on Thu Aug 10 17:51:10 2017