D - Casting int to bit[]
- C. Sauls (26/26) Dec 19 2003 Is it possible, or could be made possible, to cast an integral type to
- J Anderson (4/30) Dec 20 2003 It would guess that bit's would be stored as 8-bit or 32-bit on most
- Sean L. Palmer (7/33) Dec 20 2003 I asked for this a while back. I'd post a link but by god the web inter...
- C. Sauls (22/36) Dec 20 2003 Out of fairness I thought I should show how I currently have this
- Alix Pexton (12/48) Dec 21 2003 I think that the attached code should do something like a cast to and
- Chris Sauls (10/30) Dec 24 2003 It does indeed work... and it leads me to ressurect another subject we
- Alix Pexton (8/38) Dec 26 2003 I'm very pleased it worked, that it has been helpful, and that it has
Is it possible, or could be made possible, to cast an integral type to
an array of bits, and vice versa? Ie:
int i = 123;
bit[] bs = cast(bit[]) i;
// bs == 0000 0000 0000 0000 0000 0000 0111 1011
int i2 = cast(int) bs;
// i2 == 123
An example of how I think this could be useful:
const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[] buf = cast(bit[]) i;
int nibel;
char[] ret;
for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}
Would it not be possible to implement this by duplicating the int's
memory into the storage for the bit[]? Might be something I don't know
about that prevents it. Just a random thought.
-- C. Sauls
-- Invironz
Dec 19 2003
J Anderson <REMOVEanderson badmama.com.au> C. Sauls wrote:Is it possible, or could be made possible, to cast an integral type to an array of bits, and vice versa? Ie:That would be quite useful for set RLE (run length encoding) as well.int i = 123; bit[] bs = cast(bit[]) i; // bs == 0000 0000 0000 0000 0000 0000 0111 1011 int i2 = cast(int) bs; // i2 == 123 An example of how I think this could be useful: const char[] hexdigits = "0123456789ABCDEF"; char[] toHexLiteral(int i) { bit[] buf = cast(bit[]) i; int nibel; char[] ret; for (int idx = 0; idx < buf.length; idx += 4) { nibel = cast(int) buf[idx..idx+4]; ret ~= hexdigits[nibel]; } return ret; } Would it not be possible to implement this by duplicating the int's memory into the storage for the bit[]? Might be something I don't know about that prevents it. Just a random thought.It would guess that bit's would be stored as 8-bit or 32-bit on most machines, there probably wouldn't be a need for copying.-- C. Sauls -- Invironz
Dec 20 2003
I asked for this a while back. I'd post a link but by god the web interface
for the D ng sucks hard.
One thing about this is that it could potentially replace bitfields.
(instead of a bitfield you'd have a constant slice of some bit array)
Sean
"C. Sauls" <ibisbasenji yahoo.com> wrote in message
news:bs0qdh$112i$1 digitaldaemon.com...
Is it possible, or could be made possible, to cast an integral type to
an array of bits, and vice versa? Ie:
int i = 123;
bit[] bs = cast(bit[]) i;
// bs == 0000 0000 0000 0000 0000 0000 0111 1011
int i2 = cast(int) bs;
// i2 == 123
An example of how I think this could be useful:
const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[] buf = cast(bit[]) i;
int nibel;
char[] ret;
for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}
Would it not be possible to implement this by duplicating the int's
memory into the storage for the bit[]? Might be something I don't know
about that prevents it. Just a random thought.
-- C. Sauls
-- Invironz
Dec 20 2003
C. Sauls wrote:
const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[] buf = cast(bit[]) i;
int nibel;
char[] ret;
for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}
Out of fairness I thought I should show how I currently have this
implemented, since its not too complex as is. I just think that
int->bit[],bit[]->int has some potential.
Current toHexLiteral():
// begin snippet
const char[] hexdigits = "0123456789abcdef";
char[] toHexLiteral(uint foo)
{
char[] ret;
for (int i = 28; i >= 0; i -= 4)
{
ret ~= hexdigits[cast(ubyte)(foo >> i) & 0x0f];
}
return ret;
}
// end snippet
It more-or-less does the same thing, but includes all the fun and joy of
bit-shifting. I think the bit[] indexing would be instructionally
simpler. Could be wrong. Wouldn't be the first time. :D
-- C. Sauls
-- Invironz
Dec 20 2003
I think that the attached code should do something like a cast to and from a bit array, using templates, so it will work for more types than just uint, but what you get will not be that usefull for signed types, floats, pointers, arrays, references. But the process could be built upon to do more interesting things. I haven't tested it, so don't cry foul if it doesn't work, though I don't see why it souldn't work... Alix... C. Sauls wrote:C. Sauls wrote:-- Alix Pexton Webmaster - http://www.theDjournal.com Alix theDjournal.comconst char[] hexdigits = "0123456789ABCDEF"; char[] toHexLiteral(int i) { bit[] buf = cast(bit[]) i; int nibel; char[] ret; for (int idx = 0; idx < buf.length; idx += 4) { nibel = cast(int) buf[idx..idx+4]; ret ~= hexdigits[nibel]; } return ret; }Out of fairness I thought I should show how I currently have this implemented, since its not too complex as is. I just think that int->bit[],bit[]->int has some potential. Current toHexLiteral(): // begin snippet const char[] hexdigits = "0123456789abcdef"; char[] toHexLiteral(uint foo) { char[] ret; for (int i = 28; i >= 0; i -= 4) { ret ~= hexdigits[cast(ubyte)(foo >> i) & 0x0f]; } return ret; } // end snippet It more-or-less does the same thing, but includes all the fun and joy of bit-shifting. I think the bit[] indexing would be instructionally simpler. Could be wrong. Wouldn't be the first time. :D -- C. Sauls -- Invironz
Dec 21 2003
Alix Pexton wrote:
> template TBitMask(T){
public alias bit[T.size * 8] bitMask;
private union masker{
bitMask bits;
T type;
}
public bitMask typeToMask(in T t){
masker m;
m.type = t;
return m.bits;
}
public T maskToType(in bitMask bm){
masker m;
m.bits = bm;
return m.type;
}
}
It does indeed work... and it leads me to ressurect another subject we
brought up once some while back: persistance. I've done a little
experimenting with this template of yours and found that it could very
well be used to build a nice persisting module! I'll post my own
experiment here sometime soon, once I clear up a couple of bugs and add
a lovely packaging feature I'm wanting. :)
-- C. Sauls
-- Invironz
Dec 24 2003
I'm very pleased it worked, that it has been helpful, and that it has
inspired you.
Alix...
Chris Sauls wrote:
Alix Pexton wrote:
> template TBitMask(T){
public alias bit[T.size * 8] bitMask;
private union masker{
bitMask bits;
T type;
}
public bitMask typeToMask(in T t){
masker m;
m.type = t;
return m.bits;
}
public T maskToType(in bitMask bm){
masker m;
m.bits = bm;
return m.type;
}
}
It does indeed work... and it leads me to ressurect another subject we
brought up once some while back: persistance. I've done a little
experimenting with this template of yours and found that it could very
well be used to build a nice persisting module! I'll post my own
experiment here sometime soon, once I clear up a couple of bugs and
add a lovely packaging feature I'm wanting. :)
-- C. Sauls
-- Invironz
--
Alix Pexton
Webmaster - http://www.theDjournal.com
Alix theDjournal.com
Dec 26 2003