Awkward Array: Class Hierarchy

Loading...
Searching...
No Matches
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]

►CLibraryPathCallback |
C StartupLibraryPathCallback |
C ArrayBuilder | User interface to the Builder system: the ArrayBuilder is a fixed reference while the Builder subclass instances change in response to accumulating data
►C ArrayCache | Abstract superclass of cache for VirtualArray, defining the interface
C PyArrayCache |
►C ArrayGenerator | Abstract superclass to generate arrays for VirtualArray, defining the interface
C PyArrayGenerator |
C SliceGenerator | Generator for lazy slicing. Used to avoid materializing a VirtualArray before its content is needed (in case its content is never needed)
C BuffersContainer | Abstract class to represent the output of ak.to_buffers. In Python, this would be a dict of NumPy arrays
►C Content | Abstract superclass of all array node types (flat hierarchy). Any Content can be nested within any other Content
C BitMaskedArray | Represents potentially missing data by overlaying a bit mask over its content
C ByteMaskedArray | Represents potentially missing data by overlaying a byte mask over its content
C EmptyArray | Represents an array with length zero and (perhaps as a consequence) UnknownType
C IndexedArrayOf< T, ISOPTION > | Filters, rearranges, and/or duplicates items in its content through an index, which has the same effect as lazily-applied carry
C ListArrayOf< T > | Represents an array of nested lists that can have different lengths using two indexes named starts and stops
C ListOffsetArrayOf< T > | Represents an array of nested lists that can have different lengths using one index named offsets
C None | Represents a scalar missing value, which is `None` in Python
C NumpyArray | Represents a rectilinear numerical array that can be converted to and from NumPy without loss of information or copying the underlying buffer
C Record | Represents a tuple or record, a scalar value from RecordArray
C RecordArray | Represents an array of tuples or records, in which a tuple has a fixed number of differently typed fields and a record has a named set of differently typed fields
C RegularArray | Represents an array of nested lists that all have the same length using a scalar size, rather than an index
C UnionArrayOf< T, I > | Represents heterogeneous data by interleaving several contents, indicating which is relevant at a given position with tags and where to find each item in the contents with an interleaved index
C UnmaskedArray | Converts content of any type into an OptionType in which all values happen to be valid
C VirtualArray | Represents an array that can be generated on demand
C CppBuffers< T > |
C FileLikeObject | Abstract class to represent a file-like object, something with a `read(num_bytes)` method. Satisfies RapidJSON's Stream interface
►C Form | Abstract superclass of all array node forms, which expresses the nesting structure without any large `Index` or data buffers
C BitMaskedForm | Form describing BitMaskedArray
C ByteMaskedForm | Form describing ByteMaskedArray
C EmptyForm | Form describing EmptyArray
C IndexedForm | Form describing IndexedArray (with `OPTION = false`)
C IndexedOptionForm | Form describing IndexedOptionArray
C ListForm | Form describing ListArray
C ListOffsetForm | Form describing ListOffsetArray
C NumpyForm | Form describing NumpyArray
C RecordForm | Form describing RecordArray (not a Record)
C RegularForm | Form describing RegularArray
C UnionForm | Form describing UnionArray
C UnmaskedForm | Form describing UnmaskedArray
C VirtualForm | Form describing VirtualArray
►C FormBuilder< T, I > | Abstract base class for nodes within a LayoutBuilder Every builder will have an output buffer based on the key_format="part{partition}-{form_key}-{attribute}"
C BitMaskedArrayBuilder< T, I > | BitMaskedArray builder from a Bit Masked JSON Form
C ByteMaskedArrayBuilder< T, I > |
C EmptyArrayBuilder< T, I > |
C IndexedArrayBuilder< T, I > |
C IndexedOptionArrayBuilder< T, I > |
C ListArrayBuilder< T, I > |
C ListOffsetArrayBuilder< T, I > |
C NumpyArrayBuilder< T, I > |
C RecordArrayBuilder< T, I > |
C RegularArrayBuilder< T, I > |
C UnionArrayBuilder< T, I > |
C UnmaskedArrayBuilder< T, I > |
C ForthInputBuffer | HERE
C ForthMachineOf< T, I > |
►C ForthOutputBuffer | HERE
C ForthOutputBufferOf< OUT > |
C FromJsonObjectSchema |
C GrowableBuffer< PRIMITIVE > | Discontiguous, one-dimensional buffer (which consists of multiple contiguous, one-dimensional panels) that can grow indefinitely by calling append
►C Identities | A contiguous, two-dimensional array of integers and a list of strings used to represent a path from the root of an array structure to each item in an array
C IdentitiesOf< T > | A contiguous, two-dimensional array of integers and a list of strings used to represent a path from the root of an array structure to each item in an array
►C Index | A contiguous, one-dimensional array of integers used to represent data structures, rather than numerical data in the arrays themselves
C IndexOf< I > |
C IndexOf< T > | A contiguous, one-dimensional array of integers used to represent data structures, rather than numerical data in the arrays themselves
C Iterator | Represents the current state of iteration over a Content array
C array_deleter< T > | Used as a `std::shared_ptr` deleter (second argument) to overload `delete ptr` with `delete[] ptr`
C cuda_array_deleter< T > | Used as a `std::shared_ptr` deleter (second argument) to overload `delete ptr` with `cudaFree`
C LibraryCallback |
C LibraryPathCallback |
C no_deleter< T > | Used as a `std::shared_ptr` deleter (second argument) to overload `delete ptr` with nothing (no dereferencing)
C LayoutBuilder< T, I > | User interface to the FormBuilder system: the LayoutBuilder is a fixed reference while the FormBuilder subclass instances change in response to accumulating data
C BitMasked< VALID_WHEN, LSB_ORDER, BUILDER > | Builds a BitMaskedArray in which mask values are packed into a bitmap
C ByteMasked< VALID_WHEN, BUILDER > | Builds a ByteMaskedArray using a mask which is an array of booleans that determines whether the corresponding value in the contents array is valid or not
C Empty | Builds an EmptyArray which has no content in it. It is used whenever an array's type is not known because it is empty
C EmptyRecord< IS_TUPLE > | Builds an Empty RecordArray which has has `zero` contents. It still represents a non-empty array. In this case, its length is specified by length
C Field< ENUM, BUILDER > | Helper class for sending a pair of field names (as enum) and field type as template parameters in `Record`
C Indexed< PRIMITIVE, BUILDER > | Builds an IndexedArray which consists of an `index` buffer. It is a general-purpose tool for changing the order of and/or duplicating some content
C IndexedOption< PRIMITIVE, BUILDER > | Builds an IndexedOptionArray which consists of an `index` buffer. The negative values in the index are interpreted as missing
C List< PRIMITIVE, BUILDER > | Builds a ListArray which generalizes ListOffsetArray. Instead of a single offsets array, ListArray has - starts which is the starting index of each list and stops which is the stopping index of each list
C ListOffset< PRIMITIVE, BUILDER > | Builds a ListOffsetArray which describes unequal-length lists (often called a "jagged" or "ragged" array). The underlying data for all lists are in a BUILDER content. It is subdivided into lists according to an offsets array, which specifies the starting and stopping index of each list
C Numpy< PRIMITIVE > | Builds a NumpyArray which describes multi-dimensional data of `PRIMITIVE` type
C Record< MAP, BUILDERS > | Builds a RecordArray which represents an array of records, which can be of same or different types. Its contents is an ordered list of arrays with the same length as the length of its shortest content; all are aligned element-by-element, associating a field name to every content
C Regular< SIZE, BUILDER > | Builds a RegularArray that describes lists that have the same length, a single integer size. Its underlying content is a flattened view of the data; that is, each list is not stored separately in memory, but is inferred as a subinterval of the underlying data
C Tuple< BUILDERS > | Builds a RecordArray which represents an array of tuples which can be of same or different types without field names, indexed only by their order
C Union< TAGS, INDEX, BUILDERS > | Builds a UnionArray which represents data drawn from an ordered list of contents, which can have different types, using tags, which is an array of integers indicating which content each array element draws from and index, which is an array of integers indicating which element from the content to draw from
C Unmasked< BUILDER > | Builds an UnmaskedArray which the values are never, in fact, missing. It exists to satisfy systems that formally require this high-level type without the overhead of generating an array of all True or all False values
C Options< OPTIONS > | Container for all configuration options needed by ArrayBuilder, GrowableBuffer, LayoutBuilder and the Builder subclasses
C Panel< PRIMITIVE > |
►C PartitionedArray | Abstract superclass of all PartitionedArray node types. PartitionedArrays contain a list of Content, but Content cannot contain PartitionedArrays
C IrregularlyPartitionedArray | PartitionedArray of arbitrary length partitions
►C Reducer | Abstract class for all reducer algorithms
C ReducerAll | Reducer algorithm that returns `true` if all values are `true`, `false` otherwise. The identity is `true`
C ReducerAny | Reducer algorithm that returns `true` if any values are `true`, `false` otherwise. The identity is `false`
C ReducerArgmax | Reducer algorithm that returns the position of the maximum value. The identity is meaningless and should be covered using `mask = true`
C ReducerArgmin | Reducer algorithm that returns the position of the minimum value. The identity is meaningless and should be covered using `mask = true`
C ReducerCount | Reducer algorithm that simply counts items. The identity is `0`
C ReducerCountNonzero | Reducer algorithm that counts non-zero items. The identity is `0`
C ReducerMax | Reducer algorithm that returns the maximum value. The identity is minus infinity or the smallest possible value
C ReducerMin | Reducer algorithm that returns the minimum value. The identity is infinity or the largest possible value
C ReducerProd | Reducer algorithm that multiplies items. The identity is `1`
C ReducerSum | Reducer algorithm that adds up items. The identity is `0`
C Slice | A sequence of SliceItem objects representing a tuple passed to Python's `__getitem__`
►C SliceItem | Abstract class for slice items, which are elements of a tuple passed to an array's `__getitem__` in Python
C SliceArrayOf< T > | Represents an array of integers in a slice (possibly converted from an array of booleans)
C SliceAt | Represents an integer in a tuple of slices passed to `__getitem__` in Python
C SliceEllipsis | Represents a Python `Ellipsis` object (usual syntax: `array[...]`)
C SliceField | Represents a single string in a slice tuple, indicating that a RecordArray should be replaced by one of its fields
C SliceFields |
C SliceJaggedOf< T > | Represents an array of nested lists, where the content may be SliceArrayOf, SliceMissingOf, or SliceJaggedOf (no equivalent in NumPy)
C SliceMissingOf< T > | Represents a SliceArrayOf, SliceMissingOf, or SliceJaggedOf with missing values: `None` (no equivalent in NumPy)
C SliceNewAxis | Represents NumPy's newaxis marker (a.k.a. `None`), which prompts `__getitem__` to insert a length-1 regular dimension (RegularArray) at some point in the slice tuple
C SliceRange | Represents a Python `slice` object (usual syntax: `array[start:stop:step]`)
►C ToJson |
C ToJsonFile | Produces a JSON-formatted file
C ToJsonPrettyFile | Produces a pretty JSON-formatted file
C ToJsonPrettyString | Produces a pretty JSON-formatted string
C ToJsonString | Produces a JSON-formatted string
►C Type | Abstract superclass of all high level types (flat hierarchy)
C ArrayType | Describes the high level type of a user-facing array, i.e. `ak.Array` in Python, as opposed to Content. The length of the array is part of its type
C ListType | Describes the high level type of lists of variable length, as opposed to RegularType
C OptionType | Describes the high level type of data with possible missing values, represented by `None` in python
C PrimitiveType | Describes the high level type of an array that contains fixed-size items, such as numbers or booleans
C RecordType | Describes the high level type of data containing tuples or records
C RegularType | Describes the high level type of lists of a given length, as opposed to ListType
C UnionType | Describes the high level type of heterogeneous data
C UnknownType | Describes the high level type of data with whose type is not known, usually because an ArrayBuilder did not have any instances to sample
C NameValuePair< T > |
C visit_impl< INDEX > | Class to index tuple at runtime
C visit_impl< 0 > | `INDEX` reached `0`, which means the runtime index did not exist in the tuple
C voider<... > |
C Error |
C ForthMachine | HERE
C GrowableBuffer< double > |
C GrowableBuffer< INDEX > |
C GrowableBuffer< int64_t > |
C GrowableBuffer< int8_t > |
C GrowableBuffer< std::complex< double > > |
C GrowableBuffer< TAGS > |
C GrowableBuffer< uint8_t > |
C Panel< double > |
C Panel< INDEX > |
C Panel< int64_t > |
C Panel< int8_t > |
C Panel< std::complex< double > > |
C Panel< TAGS > |
C Panel< uint8_t > |
C PersistentSharedPtr | Array nodes are frequently copied, but for some applications (one in Numba) it's better to keep a persistent `std::shared_ptr`
C pyobject_deleter< T > | Used as a `std::shared_ptr` deleter (second argument) to overload `delete ptr` with `Py_DECREF(ptr)`
►Cenable_shared_from_this |
►C Builder | Abstract base class for nodes within an ArrayBuilder that cumulatively discover an array's type and fill it
C BoolBuilder | Builder node that accumulates boolean values
C Complex128Builder | Builder node that accumulates real numbers (`double`)
C DatetimeBuilder | Builder node that accumulates integers (`int64_t`)
C Float64Builder | Builder node that accumulates real numbers (`double`)
C Int64Builder | Builder node that accumulates integers (`int64_t`)
C ListBuilder | Builder node that accumulates lists
C OptionBuilder | Builder node that accumulates data with missing values (`None`)
C RecordBuilder | Builder node for accumulated records
C StringBuilder | Builder node that accumulates strings
C TupleBuilder | Builder node for accumulated tuples
C UnionBuilder | Builder node for accumulated heterogeneous data
C UnknownBuilder | Builder node for accumulated data whose type is not yet known
C RecordArray | Represents an array of tuples or records, in which a tuple has a fixed number of differently typed fields and a record has a named set of differently typed fields
►Cfalse_type |
C is_specialization< Test, Ref > |
►Ctrue_type |
C is_specialization< Ref< Args... >, Ref > |