// Written by: Benjamin Shropshire 2009
// released to the public domain
// NO WARENTY IS GIVEN. USE AT YOUR OWN RISK.

import std.stdio;

struct Size(uint bits)
{
	static assert(0 < bits);
	static if(bits <= 8)  alias ubyte  Ret; else
	static if(bits <= 16) alias ushort Ret; else
	static if(bits <= 32) alias uint   Ret; else
	static if(bits <= 64) alias ulong  Ret; else
	static assert(false);

	static const Ret mask = Ret.max >>> (Ret.sizeof*8 - bits);

	Ret[] data;
	Ret scratch;
	uint last = uint.max;

	Ret opIndex(int i)
	{
		static if(bits == Ret.sizeof*8) return data[i];
		else
		{
			uint base = (i * bits) / (Ret.sizeof*8);
			uint off = (i * bits) % (Ret.sizeof*8);

			Ret low = (last == uint.max || i + 1 != last) ? data[base] : scratch;

			Ret ret = low >>> off;

			const uint k = (Ret.sizeof*8 - bits);

			if(off >= Ret.sizeof*8 - bits)
			{
				scratch = data[base + 1];
				last = i;

				ret |= scratch << (Ret.sizeof*8 - off);
			}

			return ret & mask;
		}
	}

	Ret opIndexAssign(Ret v,int i)
	{
		assert(v <= mask);

		static if(bits == Ret.sizeof*8) return data[i] = v;
		else
		{
			uint base = (i * bits) / (Ret.sizeof*8);
			uint off = (i * bits) % (Ret.sizeof*8);

			last = uint.max;

			data[base] = (v << off) | (~(mask << off) & data[base]);

			if(off >= Ret.sizeof*8 - bits)
			{
				uint b = Ret.sizeof*8 - off;
				data[base + 1] = (v >>> b) | ((~mask >>> b) & data[base + 1]);
			}

			return v;
		}
	}
	void length (uint l)
	{
		static if(bits == Ret.sizeof*8) data.length = l;
		else data.length = ((l+1) * bits) / (Ret.sizeof*8);
	}
}

void main()
{
	Size!(12) d;

	d.length = 10;
	d[0] = 0x000;
	d[1] = 0x111;
	d[2] = 0x222;
	d[3] = 0x333;
	d[4] = 0x444;
	d[5] = 0x555;
	d[6] = 0x666;
	d[7] = 0x777;
	d[8] = 0x888;
	d[9] = 0x999;

	foreach(v;d.data) writef("%04x, ", v);
	writef("\n");

	for(int i = 0; i <= 9; i++)	writef("%03x, ", d[i]);
	writef("\n");
}