std.experimental.allocator.building_blocks.fallback_allocator - D Programming Language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - 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.building_blocks.fallback_allocator

Source std/experimental/allocator/building_blocks/fallback_allocator.d

struct `FallbackAllocator`(Primary, Fallback);
  `FallbackAllocator` is the allocator equivalent of an "or" operator in algebra. An allocation request is first attempted with the Primary allocator. If that returns null, the request is forwarded to the Fallback allocator. All other requests are dispatched appropriately to one of the two allocators.
  In order to work, `FallbackAllocator` requires that Primary defines the owns method. This is needed in order to decide which allocator was responsible for a given allocation.
  `FallbackAllocator` is useful for fast, special-purpose allocators backed up by general-purpose allocators. The example below features a stack region backed up by the GCAllocator.
  Primary `primary`;
    The primary allocator.
  Fallback `fallback`;
    The fallback allocator.
  static FallbackAllocator `instance`;
    If both Primary and Fallback are stateless, FallbackAllocator defines a static instance called `instance`.
  enum uint `alignment`;
    The alignment offered is the minimum of the two allocators' alignment.
  void[] `allocate`(size_t `s`);
    Allocates memory trying the primary allocator first. If it returns null, the fallback allocator is tried.
  void[] `alignedAllocate`(size_t `s`, uint `a`);
    FallbackAllocator offers `alignedAllocate` iff at least one of the allocators also offers it. It attempts to allocate using either or both.
  bool `expand`(ref void[] `b`, size_t `delta`);
    `expand` is defined if and only if at least one of the allocators defines `expand`. It works as follows. If primary.owns(`b`), then the request is forwarded to primary.`expand` if it is defined, or fails (returning false) otherwise. If primary does not own `b`, then the request is forwarded to fallback.`expand` if it is defined, or fails (returning false) otherwise.
  bool `reallocate`(ref void[] `b`, size_t `newSize`);
    `reallocate` works as follows. If primary.owns(`b`), then primary.reallocate(b, newSize) is attempted. If it fails, an attempt is made to move the allocation from primary to fallback.
    If primary does not own `b`, then fallback.reallocate(b, newSize) is attempted. If that fails, an attempt is made to move the allocation from fallback to primary.
  Ternary `owns`(void[] `b`);
    `owns` is defined if and only if both allocators define `owns`. Returns primary.owns(b) | fallback.owns(b).
  Ternary `resolveInternalPointer`(const void* `p`, ref void[] `result`);
    `resolveInternalPointer` is defined if and only if both allocators define it.
  bool `deallocate`(void[] `b`);
    `deallocate` is defined if and only if at least one of the allocators define `deallocate`. It works as follows. If primary.owns(`b`), then the request is forwarded to primary.`deallocate` if it is defined, or is a no-op otherwise. If primary does not own `b`, then the request is forwarded to fallback.`deallocate` if it is defined, or is a no-op otherwise.
  Ternary `empty`();
    `empty` is defined if both allocators also define it.
    Returns:
    primary.empty & fallback.empty
FallbackAllocator!(Primary, Fallback) `fallbackAllocator`(Primary, Fallback)(auto ref Primary `p`, auto ref Fallback `f`);
  Convenience function that uses type deduction to return the appropriate FallbackAllocator instance. To initialize with allocators that don't have state, use their it static member.
  Examples:

      import std.experimental.allocator.building_blocks.region : Region;
      import std.experimental.allocator.gc_allocator : GCAllocator;
      import std.typecons : Ternary;
      auto a = fallbackAllocator(Region!GCAllocator(1024), GCAllocator.instance);
      auto b1 = a.allocate(1020);
      writeln(b1.length); // 1020
      writeln(a.primary.owns(b1)); // Ternary.yes
      auto b2 = a.allocate(10);
      writeln(b2.length); // 10
      writeln(a.primary.owns(b2)); // Ternary.no

Copyright © 1999-2019 by the D Language Foundation | Page generated by Ddoc on Mon Sep 2 02:29:25 2019