In Ruby, GridFlow defines a namespace (module) called GridFlow. Most of the constants it defines are part of that namespace.

Ruby does not have the same concept of object as PD. In GridFlow, object classes may inherit features from other object classes, and also there is no concept of inlet nor outlet, which are instead provided by GridFlow::FObject, which also has the purpose of exporting functionality to PD.

In this document (and in many others) the phrase "a Potato" will be a shorthand for "an object of the class called Potato", which is often used in modern software design and is a nice convention borrowed from biology.

A FObject is normally in two or three parts: a (Ruby) GridFlow::FObject that is the central part; a (C++) FObject; a (C++) BFObject. The GridFlow::FObject is created as a RData kind of box (T_DATA) using Ruby-C's Data_Make_Struct on a GridObject. This is how most Ruby-C programs inherit from Ruby classes. Note that Ruby's boxed objects have a maximum of five fields, and they're usually taken, so additional fields have to be outside of it. This is why RData exists.

So basically you have a C++ FObject that is "part of" a GridFlow::FObject and they point to each other using "peer pointers". The BFObject links back to the RData box through a pointer called peer.

Provides inlets and outlets to Ruby Objects. Provides grid support to FObjects. gives an array of Integers (dimension list) gives a Symbol (number type) ensures received packets have a size that is a whole multiple of this size. must be called from rgrid_begin. establishes grid streams between an outlet and all inlets connected to it. for sending a grid data packet through that outlet. (isn't this one obsolete?) A BitPacking is a simple two-way converter between different numeric layouts.

This class is much like PureData's abstractions.

This is a container for objects. Its proper objects are numbered starting with zero. The wire list is given in terms of those numbers: (sourceobject,sourceinlet,destobject,destinlet). There is a pseudo-object numbered #-1 which map to the container's own inlets and outlets.

wrapper for struct usb_dev_handle

wrapper for struct usb_bus and usb_get_busses()

wrapper for struct usb_device and struct usb_device_descriptor

wrapper for struct usb_config_descriptor, struct usb_interface

wrapper for struct usb_interface_descriptor

wrapper for struct usb_endpoint_descriptor
GridInlets represent inlets that accept grids. GridOutlets represent outlets that send grids. Dim represents a list of dimensions. Grid represents a grid that is fully stored in memory. This represents a one-input operator. Such an object contains a map() function that applies the operator over a memory segment. This represents a two-input operator. Such an object contains four functions for each T, where T is one of the types uint8, int16, int32, float32. for i in 0...n, as[i] := f(as[i],b); This is like [#] with a scalar righthand for i in 0...n, as[i] := f(as[i],bs[i]); bs is not modified. (This is like [#] with a nonscalar righthand)

for i in 0...n, for j in 0...an, as[j] := f(as[j],bs[i*an+j]);

(this is like [#fold])

for j in 0...an: bs[j] := f(as[j],bs[j]);

for i in 1...n: for j in 0...an: bs[j] := f(bs[(i-1)*an+j],bs[i*an+j]);

(this is like [#scan]) This represents a class of GridObjects. This holds linkage information about PureData.