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
  - Get involved
  - 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.building_blocks.fallback_allocator

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-2017 by the D Language Foundation | Page generated by Ddoc on Fri Sep 1 12:52:50 2017