public void *Remove()
{
Ion.assert(_top != _begin);
_top--;
count--;
return(*_top);
}
void map_put_uint64_from_uint64(ulong key, ulong val)
{
Ion.assert(key != 0);
if (val == 0)
{
return;
}
if (2 * len >= cap)
{
map_grow(2 * cap);
}
Ion.assert(2 * len < cap);
Ion.assert(Ion.IS_POW2(cap));
for (var i = key; ; i++)
{
i &= cap - 1;
if (keys[i] == 0)
{
len++;
keys[i] = key;
vals[i] = val;
return;
}
if (keys[i] == key)
{
vals[i] = val;
return;
}
}
}
static int Main(string[] args)
{
var ion = new Ion();
if (args.Length > 0)
{
ion.ion_main(args);
}
else
{
ion.ion_test("test1");
}
return(0);
}
public static PtrBuffer *Create(int capacity = START_CAPACITY, int multiplier = MULTIPLIER)
{
Ion.assert(multiplier >= MULTIPLIER);
Ion.assert(capacity > 0);
var b = (PtrBuffer *)Ion.xmalloc(sizeof(PtrBuffer));
b->_capacity = capacity;
b->_multiplier = multiplier;
b->count = 0;
b->buf_byte_size = capacity * Ion.PTR_SIZE;
b->_begin = (void **)Ion.xmalloc(b->buf_byte_size);
b->_top = b->_begin;
b->_end = b->_begin + b->buf_byte_size;
return(b);
}
public void Add(T *val)
{
Ion.Write(_top, val);
if (++count == _capacity)
{
_capacity *= _multiplier;
buffer_size = _capacity * item_size;
_begin = Ion.xrealloc(_begin, buffer_size);
_top = _begin + count;
}
else
{
_top++;
}
}
public void Add(void *val)
{
*_top = val;
if (++count == _capacity)
{
_capacity *= _multiplier;
buf_byte_size = _capacity * Ion.PTR_SIZE;
_begin = (void **)Ion.xrealloc(_begin, buf_byte_size);
_top = _begin + count;
_end = _begin + _capacity;
}
else
{
_top++;
}
}
public void Append(T *val, int len)
{
if (count + len >= _capacity)
{
while (_capacity < len)
{
_capacity *= _multiplier;
}
buffer_size = _capacity * item_size;
_begin = Ion.xrealloc(_begin, buffer_size);
_top = _begin + count;
}
Unsafe.CopyBlock(_top, val, (uint)(len * item_size));
count += len;
_top += len;
}
public static Buffer <T> Create(int capacity = START_CAPACITY, int multiplier = MULTIPLIER)
{
Ion.assert(capacity >= START_CAPACITY);
Ion.assert(multiplier > 1);
var b = new Buffer <T>
{
item_size = sizeof(T),
_capacity = capacity,
_multiplier = multiplier,
count = 0
};
b.buffer_size = b._capacity * b.item_size;
b._begin = (T *)Ion.xmalloc(b.buffer_size);
b._top = b._begin;
return(b);
}
void map_grow(ulong new_cap)
{
new_cap = Ion.CLAMP_MIN(new_cap, 16);
var new_map = new Map
{
keys = (ulong *)Ion.xcalloc((int)new_cap, sizeof(ulong)),
vals = (ulong *)(void **)Ion.xmalloc((int)new_cap * sizeof(ulong)),
cap = new_cap
};
for (ulong i = 0; i < cap; i++)
{
if (keys[i] != 0)
{
new_map.map_put_uint64_from_uint64(keys[i], vals[i]);
}
}
Ion.xfree(keys);
Ion.xfree(vals);
this = new_map;
}
ulong map_get_uint64_from_uint64(ulong key)
{
if (len == 0)
{
return(0);
}
Ion.assert(Ion.IS_POW2(cap));
Ion.assert(len < cap);
for (var i = key; ; i++)
{
i &= cap - 1;
if (keys[i] == key)
{
return(vals[i]);
}
if (keys[i] == 0)
{
return(0);
}
}
}
public void free()
{
Ion.xfree(_begin);
}
public void free()
{
Ion.xfree(_begin);
this = default;
}
internal void free()
{
Ion.xfree(keys);
Ion.xfree(vals);
this = default;
}
