Add a form of dependant types

[gracjan]

Allow for refinement of types based on other argument values. Useful in situations when size of arrays is known only by inspecting other elements. For example consider a callback called from C to JavaScript with this signature:

void (*write)(char *ptr, size_t size);

To handle it properly use this:

function cb_write_refine_ptr_type(ptr, size) {
    // here all non-refined values are present, refined ones are nulls
    return ref.refType(array(ref.types.uint8, size))
}

function cb_write(ptr, size) {
    // ptr is a Buffer of length size here
}

Now use the following Callback call:

ffi.Callback(ref.types.void, [
                    cb_write_refine_ptr_type, 
                    ref.types.size_t], cb_write);

[gracjan]

Fixes #312.

I'd like to get an opinion if the design I proposed here is in general okay with the direction ffi is going.

[gracjan]

There you go. Even tests are there. I do not know where to put documentation.

[TooTallNate]

Thanks for the pull request. I'm having a hard time understanding why this is necessary. Why don't you just do the unwrapping in the cb_write()? This new function seems like unnecessary overhead so far.

As a side note, since you're dealing with raw bytes here, just do ptr = ref.reinterpret(ptr, size) in the first line of cb_write and you'll have a properly sized Buffer instance to work with.

[gracjan]

Okay, this is unnecessary.

My confusion came from two places:

1. I though that demarshaling was done inside _Callback and then buffers were copies of original buffers and were cut in my case.
2. ref.reinterpret can extend beyond size of original buffer, I would not expect this to be the case as it is highly unsafe.

Might be good to put these two things somewhere in documentation. Thanks.

[TooTallNate]

ref.reinterpret can extend beyond size of original buffer, I would not expect this to be the case as it is highly unsafe.

What do you mean by unsafe? Pretty much everything ffi-related is unsafe. You should see my failed efforts to get this module into node core 😞

[gracjan]

Well, I know is unsafe. Just my experience with other buffer like structures was that they allow to take a slice of a buffer but do not allow to go outside of initial buffer length.

[TooTallNate]

Just FYI, ref-array does a .reinterpret() under the hood: https://github.com/TooTallNate/ref-array/blob/cce5fb960c5ca05f9ba0928d02440fea0d4a76bc/lib/array.js#L261-L264, so the UInt8Array approach should be similarly unsafe 😉