On 03/28/2013 03:24 PM, Vidar Wahlberg wrote:
To follow up with some new woes I'm currently struggling with:
I'm storing some various values in an ubyte array. I discovered that
it's probably std.bitmanip I wish to use in order to "convert" i.e. an
int to 4 bytes (although I went first to std.conv looking for this
feature).
So I have "ubyte[] buffer;", and my second thought is that the "append"
method (http://dlang.org/phobos/std_bitmanip.html#.append) is what I
want to append values to my ubyte-array (my first thought was something
like "buffer ~= to!ubyte[](42);", although then I forgot about
endianness). In the example in the documentation it does say "auto
buffer = appender!(const ubyte[])();", with no explanation as of what
"appender" is (I later learned that this is from std.array), but just
looking a bit up I see that the "write" method explained just above use
"ubyte[] buffer; buffer.write!ubyte(42);", so I assumed that I could use
ubyte[] myself instead of this "appender" which I thought was some
legacy code.
So I write some simple test code:
import std.bitmanip, std.stdio;
void main() {
ubyte[] buffer;
buffer.append!ubyte(42);
}
Run it through rdmd, and get:
"core.exception.AssertError@/usr/include/d/std/array.d(591): Attempting
to fetch the front of an empty array of ubyte".
Just to see what happens I set the size of the buffer ("buffer.length =
1;") before appending and run it again. Now it runs, but instead of
appending it behaves like write(), which was not exactly what I wanted.
At this time I google for this "appender" used in the example and learn
that it comes from std.array, so I import std.array and try again using
"auto buffer = appender!(ubyte[])();", and surely enough, now it does
append correctly to the buffer. Great, I have a solution, so I go back
to my project and implement it like I implemented it in my test code,
but when I compile my project after this addition I get a new cryptic
error message: "Error: __overloadset isn't a template".
After digging a bit I realized that it's because in my project I also
import std.file, apparently there are some collisions between
std.bitmanip and std.file. Again it's solvable, but it's yet another
fight with the language/standard library. I would also assume that it's
not that uncommon for a module that use std.bitmanip to also use
std.file, meaning that this error potentially may occur often.
A bit on the side: It seems to me as importing std.bitmanip somehow adds
new properties to my array (".read()" and ".write()", for example). Not
necessarily a bad thing, more of "I've not seen this before, I was
expecting that I were to concatenate the bytes from the conversion to my
buffer using ~".
Yes, some functions do overload one another's functions...
Usually it's because they are templated, and can accept the same arguments.
using std.file.read will work, or import stdfile = std.file;
stdfile.read;
Just makin sure ya knew how to fix that.