How to inherit from new Buffer implementation

[corentingurtner]

Hi,
I would like to know how a class could inherit from the new Buffer implementation.

I'm trying to upgrade the node-ogg module for node v4 and nan v2.
(Here is my work so far)

I tried this classic inheritance model:

function ogg_packet (buffer) {
 if (!Buffer.isBuffer(buffer)) {
 Buffer.call(this, binding.sizeof_ogg_packet);
 } else {
 Buffer.call(this, buffer);
 }
 if (this.length != binding.sizeof_ogg_packet) {
 throw new Error('"buffer.length" = ' + this.length + ', expected ' + binding.sizeof_ogg_packet);
 }
}
inherits(ogg_packet, Buffer);

But I get this error when trying to access this.length :

Uncaught TypeError: Method Uint8Array.length called on incompatible receiver [object Object]

Thanks

Note: I also asked the question on SO:
http://stackoverflow.com/questions/32555714

[bnoordhuis]

ES6 extends should work:

> class C extends Buffer { constructor(size) { super(size) } }
[Function: C]

> (new C(32)).length
32

[corentingurtner]

Thanks @bnoordhuis ,

I know it can be seen as going backward, but is there a way in ES5 too?

[bnoordhuis]

I think that's going to be less easy for the same reason that it's difficult to inherit from Array or Uint8Array in ES5. You can maybe hack something together through the __proto__ property.

[trevnorris]

Try something like this:

function Ogg() {
 const ui = new Uint8Array(size);
 Object.setPrototypeOf(ui, Ogg.prototype);
 return ui;
}

Ogg.prototype.__proto__ = Buffer.prototype;
Ogg.__proto__ = Buffer;

Yeah, ugly as sin.

[Fishrock123]

This should probably go into the buffer docs.

[corentingurtner]

Thanks a lot for your answers,

@trevnorris :
I succeed to create an instance this way thanks to your help:

function ogg_packet (buffer) {
 if (!Buffer.isBuffer(buffer)) {
 buffer = new Uint8Array(binding.sizeof_ogg_packet);
 }

 if (buffer.length != binding.sizeof_ogg_packet) {
 throw new Error('"buffer.length" = ' + buffer.length + ', expected ' + binding.sizeof_ogg_packet);
 }

 Object.setPrototypeOf(buffer, ogg_packet.prototype);
 console.log('BUFFER', buffer.toString());
 return buffer;
}
ogg_packet.prototype.__proto__ = Buffer.prototype;
ogg_packet.__proto__ = Buffer;

However, it seems that I can't use Buffer methods (at least toString()) since there is a strict equality check of the instance. For example, trying to print buffer.toString() in the constructor function give me that error:

Uncaught TypeError: argument should be a Buffer
 at TypeError (native)
 at ogg_packet.Buffer.toString (buffer.js:354:23)

[trevnorris]

@corentingurtner That would be from the node::Buffer::HasInstance() check. It's strictly checking the hidden class. Unfortunately there's no way I'm aware of to do proto transversal in the C++ API, similar to instanceof.

/cc @domenic Know of a way to do this proto transversal check in C++?

If there's not a quick fix then let's open a new issue for this.

[domenic]

@trevnorris you can use v8::Object::GetPrototype(). Something like objLocal->GetPrototype()->Get(context, v8_str("constructor")) to get the constructor and then check with Equals against the constructor.

[domenic]

What you really want though is to check that the appropriate internal data is set on the object. Which I think just would be val->IsUint8Array(). Otherwise I can fool it with crap like var notABuffer = {}; notABuffer.__proto__ = Buffer.prototype.

[trevnorris]

@domenic ah yup. sure enough. when I had to reimplement the check I was focused on not allowing users to bypass the instanceof check in JS.

I agree that the check should be simplified down to checking internal data. All methods will work from that point regardless of whether it's actually a Buffer instance. I'll make a PR.