I'm building a binary file. I can write my 'short[] myArray' directly to the file using: File f = File( "myFile.wav", "wb" ); f.rawWrite(myArray); It doesn't write any array formatting stuff (i.e. '[ , , ]'); it just moves the data into myFile like I want.

I can't seem to do this with myStruct? myStruct is just a declaration and initialization of a dozen atomic types (e.g uint WAVE_Id = 0x45_56_41_57). When I issue f.rawWrite(myStruct), it writes "myStruct(...,...,etc. ) instead of just writing the data.

Is there way to write the myStruct data to the file in a single statement...or two?

Thanks for any assistance.

On 9/26/21 11:09 AM, Paul wrote:

What is happening is that myStruct must have an alias-this to an array, and it is writing this array.

That's the only reasonable explanation I can think of.

f.rawWrite((&myStruct)[0 .. 1]);

This will change the myStruct into an array of one struct instance, and then it can deal with it.

-Steve

Hmm...well this is what I did and sort of got what I wanted; it did compile and write data!

auto myStruct = new mystruct[1];
File f = File("myFile.wav", "wb");
f.rawWrite(myStruct); //this is 44 bytes
f.rawWrite(shortWaveArray);

What I got in the file was this:
-my 44 byte myStruct data + (4 bytes of zero)!
-then, my shortWaveArray data

What's with the 4 bytes of zero?

Thanks

I miss-counted. All is well!

Thanks Ali / Steven

Finished product...
~15k samples x 2 sin() waves/composite wave x 16 DTMF tones = 16 DTMF wave files in ~40ms!

I love D.

On Sunday, 26 September 2021 at 15:09:38 UTC, Paul wrote:

    Header[1] header;

    void readFileHeader( ref File f )
    {
        f.rawRead( header );
    }

Such i read raw data from .ttf file.

And will be logically if will to write:

    Header[1] header;

    void writeFileHeader( ref File f )
    {
        f.rawWrite( header );
    }

Declaration rawRead/rawWrite is useful, beauty and logical:

    void rawWrite(T)( in T[] buffer );

Reason for using array for return number of readed bytes:

    auto readed = f.rawRead( header );
    // readed.length
    // readed[0]
    // readed[1]

And logically and symmetrically use rawWrite() with array:

    Header[1] header;
    f.rawWrite( header );

You can write other implementation:

    void rawWrite( T )( ref FILE f, T data )
    {
        //
    }

Why not ?

And check the cerealed: https://code.dlang.org/packages/cerealed

    struct Foo
    {
        int i;
    }

    const foo = Foo(5);

    f.rawWrite( foo.cerealize ) // is ubyte[]

On Monday, 27 September 2021 at 13:45:19 UTC, Paul wrote:

   mybyte1   =   3 ?
   nocereal1 = 123 ?
   nibble    =  14 ?
   bit       =   1 ?

Author of package is https://github.com/atilaneves
Issues here: https://github.com/atilaneves/cerealed/issues

Yes, "Bits" not worked. No value for bits3.
Next is correct:

import std;
import cerealed;

    struct MyStruct
    {
        ubyte mybyte1;
        @NoCereal uint nocereal1; //won't be serialised
        @Bits!4 ubyte nibble;
        @Bits!1 ubyte bit;
        @Bits!3 ubyte bits3;
        ubyte mybyte2;
    }

    void main()
    {
        assert(  MyStruct(3, 123, 14, 1, 2, 42).cerealise == [ 3, 0xea /*1110 1 010*/, 42]);
        writeln( MyStruct(3, 123, 14, 1, 2, 42).cerealise );
    }
    ```

`[3, 234, 42]`

And check simple struct without attributes Bits, NoCereal:

import std;
import cerealed;

struct MyStruct
{
    ubyte mybyte1;
    ubyte mybyte2;
}

void main()
{
    writeln( MyStruct(3, 42).cerealise );
}
```

[3, 42]