< Summary

Information
Class: Trailblazer.Pathing.NavigationAStarPayloadCache
Assembly: Trailblazer
File(s): /home/runner/work/Trailblazer/Trailblazer/src/Trailblazer/Pathing/Search/AStar/NavigationAStarPayloadCache.cs
Line coverage
100%
Covered lines: 342
Uncovered lines: 0
Coverable lines: 342
Total lines: 612
Line coverage: 100%
Branch coverage
100%
Covered branches: 130
Total branches: 130
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%88100%
get_CachedBytes()100%11100%
get_LeasedBytes()100%11100%
get_DetachedBytes()100%11100%
get_Count()100%11100%
get_ActiveLeaseCount()100%11100%
get_ReservedLeaseCount()100%11100%
get_ReservedPayloadBytes()100%11100%
get_World()100%11100%
IsWorldCurrent(...)100%22100%
TryCreateGuide(...)100%1212100%
TryCreatePublicGuide(...)100%22100%
TryReservePayload(...)100%1010100%
ReleasePayloadReservation(...)100%66100%
TryCheckoutReserved(...)100%1414100%
TryPublish(...)100%2828100%
RemoveExact(...)100%44100%
Return(...)100%66100%
ReturnGuide(...)100%22100%
RetainGuideIfReusable(...)100%22100%
Checkout(...)100%44100%
RecycleLease(...)100%11100%
IsReservationCurrentUnderLock(...)100%66100%
ReleasePayloadReservationUnderLock(...)100%11100%
FindSlot(...)100%1414100%
Touch(...)100%22100%
LinkMostRecent(...)100%22100%
Unlink(...)100%44100%
RemoveAt(...)100%22100%
.ctor(...)100%11100%

File(s)

/home/runner/work/Trailblazer/Trailblazer/src/Trailblazer/Pathing/Search/AStar/NavigationAStarPayloadCache.cs

#LineLine coverage
 1//=======================================================================
 2// NavigationAStarPayloadCache.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using GridForge.Grids;
 10
 11namespace Trailblazer.Pathing;
 12
 13internal struct NavigationAStarPayloadReservation
 14{
 15    internal NavigationAStarPayloadReservation(
 16        NavigationAStarPayloadCache owner,
 17        NavigationAStarPayloadReservationSlot slot,
 18        ulong generation,
 19        long maximumBytes)
 20    {
 21        Owner = owner;
 22        Slot = slot;
 23        Generation = generation;
 24        MaximumBytes = maximumBytes;
 25    }
 26
 27    internal readonly NavigationAStarPayloadCache? Owner;
 28    internal readonly NavigationAStarPayloadReservationSlot? Slot;
 29    internal readonly ulong Generation;
 30    internal readonly long MaximumBytes;
 31    internal readonly bool HasLeaseSlot => Owner != null;
 32}
 33
 34internal sealed class NavigationAStarPayloadReservationSlot
 35{
 36    internal ulong Generation;
 37    internal long MaximumBytes;
 38    internal bool IsReserved;
 39    internal NavigationAStarPayloadReservationSlot? NextPooled;
 40}
 41
 42/// <summary>Stores a bounded concrete set of dependency-validated A* payloads.</summary>
 43internal sealed class NavigationAStarPayloadCache
 44{
 105245    private readonly object _sync = new();
 46    private readonly GridWorld _world;
 47    private readonly NavigationAStarPayloadKey[] _keys;
 48    private readonly CacheEntry?[] _entries;
 49    private readonly byte[] _states;
 50    private readonly int[] _previous;
 51    private readonly int[] _next;
 52    private readonly int _mask;
 53    private readonly int _maximumEntries;
 54    private readonly long _maximumReusableBytes;
 55    private readonly long _maximumSinglePayloadBytes;
 56    private readonly long _maximumActivePayloadBytes;
 57    private readonly int _maximumActiveLeases;
 105258    private int _leastRecent = -1;
 105259    private int _mostRecent = -1;
 60    private int _count;
 61    private int _activeLeaseCount;
 62    private int _reservedLeaseCount;
 63    private long _cachedBytes;
 64    private long _leasedBytes;
 65    private long _detachedBytes;
 66    private long _reservedPayloadBytes;
 67    private NavigationAStarPayloadLease? _freeLeases;
 68    private NavigationAStarGuideLease? _freeGuides;
 69    private NavigationAStarPayloadReservationSlot? _freeReservationSlots;
 70
 105271    internal NavigationAStarPayloadCache(
 105272        GridWorld world,
 105273        int maxEntries,
 105274        long maxReusableBytes = long.MaxValue,
 105275        long maxSinglePayloadBytes = long.MaxValue,
 105276        long maxActivePayloadBytes = long.MaxValue,
 105277        int maxActiveLeases = int.MaxValue)
 78    {
 105279        SwiftThrowHelper.ThrowIfNull(world, nameof(world));
 105280        SwiftThrowHelper.ThrowIfNegative(maxEntries, nameof(maxEntries));
 105281        if (maxReusableBytes < 0)
 182            throw new ArgumentOutOfRangeException(nameof(maxReusableBytes));
 105183        if (maxSinglePayloadBytes < 0)
 184            throw new ArgumentOutOfRangeException(nameof(maxSinglePayloadBytes));
 105085        if (maxActivePayloadBytes < 0)
 186            throw new ArgumentOutOfRangeException(nameof(maxActivePayloadBytes));
 104987        SwiftThrowHelper.ThrowIfNegative(maxActiveLeases, nameof(maxActiveLeases));
 104988        SwiftThrowHelper.ThrowIfArgument(
 104989            maxSinglePayloadBytes > maxActivePayloadBytes,
 104990            nameof(maxSinglePayloadBytes),
 104991            "A single payload cannot exceed the complete active-payload byte ceiling.");
 104992        int tableSize = 1;
 104993        int required = checked(Math.Max(1, maxEntries * 2));
 905794        while (tableSize < required)
 800895            tableSize = checked(tableSize * 2);
 104996        _world = world;
 104997        _keys = new NavigationAStarPayloadKey[tableSize];
 104998        _entries = new CacheEntry[tableSize];
 104999        _states = new byte[tableSize];
 1049100        _previous = new int[tableSize];
 1049101        _next = new int[tableSize];
 1049102        Array.Fill(_previous, -1);
 1049103        Array.Fill(_next, -1);
 1049104        _mask = tableSize - 1;
 1049105        _maximumEntries = maxEntries;
 1049106        _maximumReusableBytes = maxReusableBytes;
 1049107        _maximumSinglePayloadBytes = maxSinglePayloadBytes;
 1049108        _maximumActivePayloadBytes = maxActivePayloadBytes;
 1049109        _maximumActiveLeases = maxActiveLeases;
 1049110    }
 111
 112    internal long CachedBytes
 113    {
 114        get
 115        {
 68116            lock (_sync)
 68117                return _cachedBytes;
 68118        }
 119    }
 120
 121    internal long LeasedBytes
 122    {
 123        get
 124        {
 8125            lock (_sync)
 8126                return _leasedBytes;
 8127        }
 128    }
 129
 130    internal long DetachedBytes
 131    {
 132        get
 133        {
 7134            lock (_sync)
 7135                return _detachedBytes;
 7136        }
 137    }
 138
 139    internal int Count
 140    {
 141        get
 142        {
 81143            lock (_sync)
 81144                return _count;
 81145        }
 146    }
 147
 148    internal int ActiveLeaseCount
 149    {
 150        get
 151        {
 60152            lock (_sync)
 60153                return _activeLeaseCount;
 60154        }
 155    }
 156
 157    internal int ReservedLeaseCount
 158    {
 159        get
 160        {
 33161            lock (_sync)
 33162                return _reservedLeaseCount;
 33163        }
 164    }
 165
 166    internal long ReservedPayloadBytes
 167    {
 168        get
 169        {
 14170            lock (_sync)
 14171                return _reservedPayloadBytes;
 14172        }
 173    }
 174
 127175    internal GridWorld World => _world;
 176
 177    internal bool IsWorldCurrent(NavigationAStarPayload payload) =>
 9766178        payload.WorldChangeSequence is not ulong sequence
 9766179        || _world.ChangeSequence == sequence;
 180
 181    internal NavigationAStarQueryStatus TryCreateGuide(
 182        NavigationWorldGraphStore store,
 183        NavigationAStarPayloadLease payloadLease,
 184        out NavigationAStarGuideLease? guide)
 185    {
 633186        SwiftThrowHelper.ThrowIfNull(store, nameof(store));
 633187        SwiftThrowHelper.ThrowIfNull(payloadLease, nameof(payloadLease));
 633188        NavigationAStarPayload payload = payloadLease.Payload;
 633189        if (!payload.HasPath)
 190        {
 1191            payloadLease.Dispose();
 1192            guide = null;
 1193            return NavigationAStarQueryStatus.NoPath;
 194        }
 632195        NavigationWorldGraphLease? graphLease = store.TryAcquire();
 632196        if (graphLease == null)
 197        {
 2198            payloadLease.Dispose();
 2199            guide = null;
 2200            return NavigationAStarQueryStatus.CapacityExceeded;
 201        }
 630202        using (graphLease)
 203        {
 630204            if (!graphLease.Graph.IsDependencyCurrent(payload.Dependencies)
 630205                || !store.Current.IsDependencyCurrent(payload.Dependencies)
 630206                || !IsWorldCurrent(payload))
 207            {
 2208                payloadLease.Dispose();
 2209                guide = null;
 2210                return NavigationAStarQueryStatus.Stale;
 211            }
 628212        }
 628213        lock (_sync)
 214        {
 628215            guide = _freeGuides;
 628216            if (guide == null)
 73217                guide = new NavigationAStarGuideLease(this);
 218            else
 219            {
 555220                _freeGuides = guide.NextPooled;
 555221                guide.NextPooled = null;
 222            }
 555223        }
 628224        guide.Bind(store, payloadLease);
 628225        return NavigationAStarQueryStatus.Success;
 2226    }
 227
 228    internal NavigationGuideStatus TryCreatePublicGuide(
 229        NavigationWorldGraphStore store,
 230        NavigationAStarPayloadLease payloadLease,
 231        out NavigationGuideLease? guide)
 232    {
 358233        NavigationAStarQueryStatus status = TryCreateGuide(
 358234            store,
 358235            payloadLease,
 358236            out NavigationAStarGuideLease? inner);
 358237        if (status != NavigationAStarQueryStatus.Success)
 238        {
 1239            guide = null;
 1240            return NavigationGuideStatusMapper.ToPublic(status);
 241        }
 357242        guide = new NavigationGuideLease(inner!);
 357243        return NavigationGuideStatus.Success;
 244    }
 245
 246    internal bool TryReservePayload(
 247        long maximumBytes,
 248        out NavigationAStarPayloadReservation reservation)
 249    {
 1158250        if (maximumBytes < 0)
 1251            throw new ArgumentOutOfRangeException(nameof(maximumBytes));
 1157252        reservation = default;
 1157253        if (maximumBytes > _maximumSinglePayloadBytes)
 4254            return false;
 1153255        lock (_sync)
 256        {
 1153257            if (_activeLeaseCount + _reservedLeaseCount >= _maximumActiveLeases
 1153258                || maximumBytes > _maximumActivePayloadBytes
 1153259                - _leasedBytes
 1153260                - _reservedPayloadBytes)
 261            {
 5262                return false;
 263            }
 1148264            _reservedPayloadBytes = checked(_reservedPayloadBytes + maximumBytes);
 1148265            _reservedLeaseCount++;
 1148266            NavigationAStarPayloadReservationSlot? slot = _freeReservationSlots;
 1148267            if (slot == null)
 268            {
 122269                slot = new NavigationAStarPayloadReservationSlot();
 270            }
 271            else
 272            {
 1026273                _freeReservationSlots = slot.NextPooled;
 1026274                slot.NextPooled = null;
 275            }
 1148276            slot.Generation = unchecked(slot.Generation + 1UL);
 1148277            slot.MaximumBytes = maximumBytes;
 1148278            slot.IsReserved = true;
 1148279            reservation = new NavigationAStarPayloadReservation(
 1148280                this,
 1148281                slot,
 1148282                slot.Generation,
 1148283                maximumBytes);
 1148284            return true;
 285        }
 1153286    }
 287
 288    internal void ReleasePayloadReservation(
 289        ref NavigationAStarPayloadReservation reservation)
 290    {
 1480291        if (reservation.Owner == null)
 292        {
 1422293            reservation = default;
 1422294            return;
 295        }
 58296        if (!ReferenceEquals(reservation.Owner, this))
 1297            return;
 57298        NavigationAStarPayloadReservation released = reservation;
 57299        reservation = default;
 57300        lock (_sync)
 301        {
 57302            if (IsReservationCurrentUnderLock(released))
 55303                ReleasePayloadReservationUnderLock(released);
 57304        }
 57305    }
 306
 307    internal bool TryCheckoutReserved(
 308        NavigationAStarPayloadKey key,
 309        NavigationWorldGraph graph,
 310        ref NavigationAStarPayloadReservation reservation,
 311        out NavigationAStarPayloadLease lease)
 312    {
 1022313        SwiftThrowHelper.ThrowIfNull(graph, nameof(graph));
 1022314        lease = null!;
 1022315        lock (_sync)
 316        {
 1022317            if (!IsReservationCurrentUnderLock(reservation))
 1318                return false;
 1021319            FindSlot(key, out int slot, out bool found);
 1021320            if (!found)
 111321                return false;
 910322            CacheEntry current = _entries[slot]!;
 910323            if (!graph.IsDependencyCurrent(current.Payload.Dependencies)
 910324                || !IsWorldCurrent(current.Payload))
 325            {
 22326                RemoveAt(slot);
 22327                return false;
 328            }
 888329            long otherReservations =
 888330                _reservedPayloadBytes - reservation.MaximumBytes;
 888331            if (current.Payload.RetainedBytes > reservation.MaximumBytes
 888332                || (current.LeaseCount == 0
 888333                    && current.Payload.RetainedBytes > _maximumActivePayloadBytes
 888334                        - _leasedBytes
 888335                        - otherReservations))
 336            {
 1337                return false;
 338            }
 887339            ReleasePayloadReservationUnderLock(reservation);
 887340            reservation = default;
 887341            lease = Checkout(current);
 887342            Touch(slot);
 887343            return true;
 344        }
 1022345    }
 346
 347    internal bool TryPublish(
 348        NavigationAStarPayload payload,
 349        NavigationWorldGraphStore store,
 350        ref NavigationAStarPayloadReservation reservation,
 351        out NavigationAStarPayloadLease lease)
 352    {
 213353        SwiftThrowHelper.ThrowIfNull(payload, nameof(payload));
 213354        SwiftThrowHelper.ThrowIfNull(store, nameof(store));
 213355        lease = null!;
 213356        long retainedBytes = payload.RetainedBytes;
 213357        if (!ReferenceEquals(reservation.Owner, this)
 213358            || retainedBytes > reservation.MaximumBytes)
 359        {
 1360            return false;
 361        }
 212362        lock (_sync)
 363        {
 212364            if (!IsReservationCurrentUnderLock(reservation))
 1365                return false;
 211366            NavigationWorldGraph graph = store.Current;
 211367            if (!graph.IsDependencyCurrent(payload.Dependencies)
 211368                || !IsWorldCurrent(payload))
 4369                return false;
 207370            long otherReservations =
 207371                _reservedPayloadBytes - reservation.MaximumBytes;
 207372            FindSlot(payload.Key, out int slot, out bool found);
 207373            if (found)
 374            {
 7375                CacheEntry current = _entries[slot]!;
 7376                if (graph.IsDependencyCurrent(current.Payload.Dependencies)
 7377                    && IsWorldCurrent(current.Payload))
 378                {
 6379                    if (current.LeaseCount == 0
 6380                            && current.Payload.RetainedBytes > _maximumActivePayloadBytes
 6381                                - _leasedBytes
 6382                                - otherReservations)
 383                    {
 1384                        return false;
 385                    }
 5386                    ReleasePayloadReservationUnderLock(reservation);
 5387                    reservation = default;
 5388                    lease = Checkout(current);
 5389                    Touch(slot);
 5390                    return true;
 391                }
 1392                RemoveAt(slot);
 393            }
 394
 201395            if (_maximumEntries == 0 || retainedBytes > _maximumReusableBytes)
 396            {
 2397                var detached = new CacheEntry(payload, isCached: false);
 2398                _detachedBytes = checked(_detachedBytes + retainedBytes);
 2399                ReleasePayloadReservationUnderLock(reservation);
 2400                reservation = default;
 2401                lease = Checkout(detached);
 2402                return true;
 403            }
 404
 265405            while (_count >= _maximumEntries
 265406                || retainedBytes > _maximumReusableBytes - _cachedBytes)
 66407                RemoveAt(_leastRecent);
 408
 199409            FindSlot(payload.Key, out slot, out found);
 199410            var entry = new CacheEntry(payload, isCached: true);
 199411            _states[slot] = 1;
 199412            _keys[slot] = payload.Key;
 199413            _entries[slot] = entry;
 199414            LinkMostRecent(slot);
 199415            _count++;
 199416            _cachedBytes = checked(_cachedBytes + retainedBytes);
 199417            ReleasePayloadReservationUnderLock(reservation);
 199418            reservation = default;
 199419            lease = Checkout(entry);
 199420            return true;
 421        }
 212422    }
 423
 424    internal void RemoveExact(NavigationAStarPayload payload)
 425    {
 1426        SwiftThrowHelper.ThrowIfNull(payload, nameof(payload));
 1427        lock (_sync)
 428        {
 1429            FindSlot(payload.Key, out int slot, out bool found);
 1430            if (found && ReferenceEquals(_entries[slot]!.Payload, payload))
 1431                RemoveAt(slot);
 1432        }
 1433    }
 434
 435    internal void Return(NavigationAStarPayloadLease lease)
 436    {
 1074437        CacheEntry? entry = lease.DetachEntry();
 1074438        if (entry == null)
 1439            return;
 1073440        lock (_sync)
 441        {
 1073442            entry.LeaseCount--;
 1073443            _activeLeaseCount--;
 1073444            if (entry.LeaseCount == 0)
 445            {
 798446                _leasedBytes = checked(_leasedBytes - entry.Payload.RetainedBytes);
 798447                if (!entry.IsCached)
 12448                    _detachedBytes = checked(_detachedBytes - entry.Payload.RetainedBytes);
 449            }
 1073450            RecycleLease(lease);
 1073451        }
 1073452    }
 453
 454    internal void ReturnGuide(NavigationAStarGuideLease guide, long generation)
 455    {
 613456        if (!guide.TryDetach(
 613457                generation,
 613458                out NavigationAStarPayloadLease payloadLease))
 5459            return;
 608460        payloadLease.Dispose();
 608461        lock (_sync)
 608462            RetainGuideIfReusable(generation, guide, ref _freeGuides);
 608463    }
 464
 465    internal static void RetainGuideIfReusable(
 466        long generation,
 467        NavigationAStarGuideLease guide,
 468        ref NavigationAStarGuideLease? freeGuides)
 469    {
 610470        if (!NavigationGenerationCounter.CanAdvance(generation))
 1471            return;
 609472        guide.NextPooled = freeGuides;
 609473        freeGuides = guide;
 609474    }
 475
 476    private NavigationAStarPayloadLease Checkout(CacheEntry entry)
 477    {
 1093478        if (entry.LeaseCount == 0)
 818479            _leasedBytes = checked(_leasedBytes + entry.Payload.RetainedBytes);
 1093480        entry.LeaseCount++;
 1093481        _activeLeaseCount++;
 1093482        NavigationAStarPayloadLease? lease = _freeLeases;
 1093483        if (lease == null)
 110484            lease = new NavigationAStarPayloadLease(this);
 485        else
 486        {
 983487            _freeLeases = lease.NextPooled;
 983488            lease.NextPooled = null;
 489        }
 1093490        lease.Bind(entry);
 1093491        return lease;
 492    }
 493
 494    private void RecycleLease(NavigationAStarPayloadLease lease)
 495    {
 1073496        lease.NextPooled = _freeLeases;
 1073497        _freeLeases = lease;
 1073498    }
 499
 500    private bool IsReservationCurrentUnderLock(
 501        NavigationAStarPayloadReservation reservation) =>
 1291502        ReferenceEquals(reservation.Owner, this)
 1291503        && reservation.Slot != null
 1291504        && reservation.Slot.Generation == reservation.Generation
 1291505        && reservation.Slot.IsReserved;
 506
 507    private void ReleasePayloadReservationUnderLock(
 508        NavigationAStarPayloadReservation reservation)
 509    {
 1148510        NavigationAStarPayloadReservationSlot slot = reservation.Slot!;
 1148511        _reservedPayloadBytes -= slot.MaximumBytes;
 1148512        _reservedLeaseCount--;
 1148513        slot.MaximumBytes = 0;
 1148514        slot.IsReserved = false;
 1148515        slot.NextPooled = _freeReservationSlots;
 1148516        _freeReservationSlots = slot;
 1148517    }
 518
 519    private void FindSlot(
 520        NavigationAStarPayloadKey key,
 521        out int slot,
 522        out bool found)
 523    {
 1428524        slot = key.GetHashCode() & _mask;
 1428525        int firstRemoved = -1;
 3448526        for (int probe = 0; probe < _states.Length; probe++)
 527        {
 1600528            byte state = _states[slot];
 1600529            if (state == 0)
 530            {
 386531                found = false;
 386532                if (firstRemoved >= 0)
 42533                    slot = firstRemoved;
 386534                return;
 535            }
 1214536            if (state == 1 && _keys[slot].Equals(key))
 537            {
 918538                found = true;
 918539                return;
 540            }
 296541            if (state == 2 && firstRemoved < 0)
 166542                firstRemoved = slot;
 296543            slot = (slot + 1) & _mask;
 544        }
 124545        found = false;
 124546        slot = firstRemoved;
 124547    }
 548
 549    private void Touch(int slot)
 550    {
 892551        if (_mostRecent == slot)
 882552            return;
 10553        Unlink(slot);
 10554        LinkMostRecent(slot);
 10555    }
 556
 557    private void LinkMostRecent(int slot)
 558    {
 209559        _previous[slot] = _mostRecent;
 209560        _next[slot] = -1;
 209561        if (_mostRecent >= 0)
 54562            _next[_mostRecent] = slot;
 563        else
 155564            _leastRecent = slot;
 209565        _mostRecent = slot;
 209566    }
 567
 568    private void Unlink(int slot)
 569    {
 100570        int previous = _previous[slot];
 100571        int next = _next[slot];
 100572        if (previous >= 0)
 12573            _next[previous] = next;
 574        else
 88575            _leastRecent = next;
 100576        if (next >= 0)
 17577            _previous[next] = previous;
 578        else
 83579            _mostRecent = previous;
 100580        _previous[slot] = -1;
 100581        _next[slot] = -1;
 100582    }
 583
 584    private void RemoveAt(int slot)
 585    {
 90586        CacheEntry entry = _entries[slot]!;
 90587        _cachedBytes = checked(_cachedBytes - entry.Payload.RetainedBytes);
 90588        entry.IsCached = false;
 90589        if (entry.LeaseCount != 0)
 10590            _detachedBytes = checked(_detachedBytes + entry.Payload.RetainedBytes);
 90591        Unlink(slot);
 90592        _keys[slot] = default;
 90593        _entries[slot] = null;
 90594        _states[slot] = 2;
 90595        _count--;
 90596    }
 597
 598    internal sealed class CacheEntry
 599    {
 201600        internal CacheEntry(NavigationAStarPayload payload, bool isCached)
 601        {
 201602            Payload = payload;
 201603            IsCached = isCached;
 201604        }
 605
 606        internal NavigationAStarPayload Payload { get; }
 607
 608        internal int LeaseCount { get; set; }
 609
 610        internal bool IsCached { get; set; }
 611    }
 612}
Generated by: ReportGenerator 5.5.11.0
09/02/2026 - 04:28:06
GitHub | reportgenerator.io

Methods/Properties

.ctor(GridForge.Grids.GridWorld,System.Int32,System.Int64,System.Int64,System.Int64,System.Int32)
get_CachedBytes()
get_LeasedBytes()
get_DetachedBytes()
get_Count()
get_ActiveLeaseCount()
get_ReservedLeaseCount()
get_ReservedPayloadBytes()
get_World()
IsWorldCurrent(Trailblazer.Pathing.NavigationAStarPayload)
TryCreateGuide(Trailblazer.Pathing.NavigationWorldGraphStore,Trailblazer.Pathing.NavigationAStarPayloadLease,Trailblazer.Pathing.NavigationAStarGuideLease&)
TryCreatePublicGuide(Trailblazer.Pathing.NavigationWorldGraphStore,Trailblazer.Pathing.NavigationAStarPayloadLease,System.Nullable`1<Trailblazer.Pathing.NavigationGuideLease>&)
TryReservePayload(System.Int64,Trailblazer.Pathing.NavigationAStarPayloadReservation&)
ReleasePayloadReservation(Trailblazer.Pathing.NavigationAStarPayloadReservation&)
TryCheckoutReserved(Trailblazer.Pathing.NavigationAStarPayloadKey,Trailblazer.Pathing.NavigationWorldGraph,Trailblazer.Pathing.NavigationAStarPayloadReservation&,Trailblazer.Pathing.NavigationAStarPayloadLease&)
TryPublish(Trailblazer.Pathing.NavigationAStarPayload,Trailblazer.Pathing.NavigationWorldGraphStore,Trailblazer.Pathing.NavigationAStarPayloadReservation&,Trailblazer.Pathing.NavigationAStarPayloadLease&)
RemoveExact(Trailblazer.Pathing.NavigationAStarPayload)
Return(Trailblazer.Pathing.NavigationAStarPayloadLease)
ReturnGuide(Trailblazer.Pathing.NavigationAStarGuideLease,System.Int64)
RetainGuideIfReusable(System.Int64,Trailblazer.Pathing.NavigationAStarGuideLease,Trailblazer.Pathing.NavigationAStarGuideLease&)
Checkout(Trailblazer.Pathing.NavigationAStarPayloadCache/CacheEntry)
RecycleLease(Trailblazer.Pathing.NavigationAStarPayloadLease)
IsReservationCurrentUnderLock(Trailblazer.Pathing.NavigationAStarPayloadReservation)
ReleasePayloadReservationUnderLock(Trailblazer.Pathing.NavigationAStarPayloadReservation)
FindSlot(Trailblazer.Pathing.NavigationAStarPayloadKey,System.Int32&,System.Boolean&)
Touch(System.Int32)
LinkMostRecent(System.Int32)
Unlink(System.Int32)
RemoveAt(System.Int32)
.ctor(Trailblazer.Pathing.NavigationAStarPayload,System.Boolean)