blob: daf7a53753a09ac818bda78d5accdaccb80592d6 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
//#define ASTAR_NO_POOLING //@SHOWINEDITOR Disable pooling for some reason. Could be debugging or just for measuring the difference.
using System.Collections.Generic;
namespace Pathfinding.Util {
/// <summary>
/// Lightweight Stack Pool.
/// Handy class for pooling stacks of type T.
///
/// Usage:
/// - Claim a new stack using <code> Stack<SomeClass> foo = StackPool<SomeClass>.Claim (); </code>
/// - Use it and do stuff with it
/// - Release it with <code> StackPool<SomeClass>.Release (foo); </code>
///
/// You do not need to clear the stack before releasing it.
/// After you have released a stack, you should never use it again.
///
/// Warning: This class is not thread safe
///
/// Since: Version 3.2
/// See: Pathfinding.Util.ListPool
/// </summary>
public static class StackPool<T> {
/// <summary>Internal pool</summary>
static readonly List<Stack<T> > pool;
/// <summary>Static constructor</summary>
static StackPool () {
pool = new List<Stack<T> >();
}
/// <summary>
/// Claim a stack.
/// Returns a pooled stack if any are in the pool.
/// Otherwise it creates a new one.
/// After usage, this stack should be released using the Release function (though not strictly necessary).
/// </summary>
public static Stack<T> Claim () {
#if ASTAR_NO_POOLING
return new Stack<T>();
#else
lock (pool) {
if (pool.Count > 0) {
Stack<T> ls = pool[pool.Count-1];
pool.RemoveAt(pool.Count-1);
return ls;
}
}
return new Stack<T>();
#endif
}
/// <summary>
/// Makes sure the pool contains at least count pooled items.
/// This is good if you want to do all allocations at start.
/// </summary>
public static void Warmup (int count) {
var tmp = new Stack<T>[count];
for (int i = 0; i < count; i++) tmp[i] = Claim();
for (int i = 0; i < count; i++) Release(tmp[i]);
}
/// <summary>
/// Releases a stack.
/// After the stack has been released it should not be used anymore.
/// Releasing a stack twice will cause an error.
/// </summary>
public static void Release (Stack<T> stack) {
#if !ASTAR_NO_POOLING
stack.Clear();
lock (pool) {
for (int i = 0; i < pool.Count; i++)
if (pool[i] == stack) UnityEngine.Debug.LogError("The Stack is released even though it is inside the pool");
pool.Add(stack);
}
#endif
}
/// <summary>
/// Clears all pooled stacks of this type.
/// This is an O(n) operation, where n is the number of pooled stacks
/// </summary>
public static void Clear () {
lock (pool) {
pool.Clear();
}
}
/// <summary>Number of stacks of this type in the pool</summary>
public static int GetSize () {
return pool.Count;
}
}
}
|
