From 1e8b0b7d34711706096093d24cdadd4d7b375369 Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Thu, 10 Oct 2024 12:47:00 +0000 Subject: [PATCH] build based on c5e7f2b --- previews/PR111/LICENSE/index.html | 2 +- previews/PR111/api/index.html | 2 +- previews/PR111/exampleusage/index.html | 2 +- previews/PR111/functions/index.html | 176 +++++++++++----------- previews/PR111/getting_started/index.html | 2 +- previews/PR111/howto/index.html | 2 +- previews/PR111/index.html | 2 +- previews/PR111/indexing/index.html | 2 +- previews/PR111/internals/index.html | 2 +- previews/PR111/search/index.html | 2 +- previews/PR111/types/index.html | 58 +++---- 11 files changed, 126 insertions(+), 126 deletions(-) diff --git a/previews/PR111/LICENSE/index.html b/previews/PR111/LICENSE/index.html index 4e5b85c..7967b3d 100644 --- a/previews/PR111/LICENSE/index.html +++ b/previews/PR111/LICENSE/index.html @@ -1,2 +1,2 @@ -LICENSE · for Julia!
Edit on GitHub

MIT License

Copyright (c) 2023 Jim Pivarski <pivarski@princeton.edu>, Jerry Ling <jerry.ling@cern.ch>, and contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+LICENSE · for Julia!
Edit on GitHub

MIT License

Copyright (c) 2023 Jim Pivarski <pivarski@princeton.edu>, Jerry Ling <jerry.ling@cern.ch>, and contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

diff --git a/previews/PR111/api/index.html b/previews/PR111/api/index.html index 498a5bc..9b83c3c 100644 --- a/previews/PR111/api/index.html +++ b/previews/PR111/api/index.html @@ -1,2 +1,2 @@ -Reference Guide · for Julia!
Edit on GitHub
+Reference Guide · for Julia!
Edit on GitHub
diff --git a/previews/PR111/exampleusage/index.html b/previews/PR111/exampleusage/index.html index 3455ee0..e81dc39 100644 --- a/previews/PR111/exampleusage/index.html +++ b/previews/PR111/exampleusage/index.html @@ -19,4 +19,4 @@ const ak = pyimport("awkward") println(ak.__version__) -2.5.0 +2.5.0 diff --git a/previews/PR111/functions/index.html b/previews/PR111/functions/index.html index 76ef75a..8739b85 100644 --- a/previews/PR111/functions/index.html +++ b/previews/PR111/functions/index.html @@ -1,111 +1,111 @@ -Functions · for Julia!
Edit on GitHub

Functions

Built-in functions

Every Content subclass has the following built-in functions:

Base.length — Function
Base.length(parameters::Parameters)
source
Base.length(layout::PrimitiveArray)
source
Base.length(layout::EmptyArray)
source
Base.length(layout::ListOffsetArray)

Length of a ListOffsetArray.

source
Base.length(layout::ListArray)

Length of a ListArray.

source
Base.length(layout::RegularArray)

Length of a RegularArray.

source
Base.length(layout::RecordArray)
source
Base.length(layout::TupleArray)
source
Base.length(layout::IndexedArray)
source
Base.length(layout::IndexedOptionArray)
source
Base.length(layout::ByteMaskedArray)
source
Base.length(layout::BitMaskedArray)
source
Base.length(layout::UnmaskedArray)
source
Base.length(layout::UnionArray)
source
Base.size — Function

Treat instances of Content as if they are one-dimensional arrays.

source
Base.firstindex — Function
Base.firstindex(layout::PrimitiveArray)
source
Base.firstindex(layout::EmptyArray)
source
Base.firstindex(layout::ListOffsetArray)

First index of a ListOffsetArray offsets.

source
Base.firstindex(layout::ListArray)

First index of a ListArray starts.

source
Base.firstindex(layout::RegularArray)

First index of a RegularArray is always 1.

source
Base.firstindex(layout::RecordArray)
source
Base.firstindex(layout::TupleArray)
source
Base.firstindex(layout::IndexedArray)
source
Base.firstindex(layout::IndexedOptionArray)
source
Base.firstindex(layout::ByteMaskedArray)
source
Base.firstindex(layout::BitMaskedArray)
source
Base.firstindex(layout::UnmaskedArray)
source
Base.firstindex(layout::UnionArray)
source
Base.lastindex — Function
Base.lastindex(layout::PrimitiveArray)
source
Base.lastindex(layout::EmptyArray)
source
Base.lastindex(layout::ListOffsetArray)

Last index of a ListOffsetArray offsets.

source
Base.lastindex(layout::ListArray)

Last index of a ListArray starts.

source
Base.lastindex(layout::RegularArray)

Last index of a RegularArray.

source
Base.lastindex(layout::RecordArray)
source
Base.lastindex(layout::TupleArray)
source
Base.lastindex(layout::IndexedArray)
source
Base.lastindex(layout::IndexedOptionArray)
source
Base.lastindex(layout::ByteMaskedArray)
source
Base.lastindex(layout::BitMaskedArray)
source
Base.lastindex(layout::UnmaskedArray)
source
Base.lastindex(layout::UnionArray)
source
Base.getindex — Function
Base.getindex(layout::PrimitiveArray, i::Int)
source
Base.getindex(layout::PrimitiveArray, r::UnitRange{Int})
source
Base.getindex(layout::EmptyArray, i::Int)
source
Base.getindex(layout::EmptyArray, r::UnitRange{Int})
source
Base.getindex(layout::ListOffsetArray, i::Int)
source
Base.getindex(layout::ListOffsetArray, r::UnitRange{Int})
source
Base.getindex(layout::ListOffsetArray, f::Symbol)
source
Base.getindex(layout::ListArray, i::Int)
source
Base.getindex(layout::ListArray, r::UnitRange{Int})
source
Base.getindex(layout::ListArray, f::Symbol)
source
Base.getindex(layout::RegularArray, i::Int)
source
Base.getindex(layout::RegularArray, r::UnitRange{Int})
source
Base.getindex(layout::RegularArray, f::Symbol)
source
Base.getindex(
+Functions · for Julia!
Edit on GitHub
Functions
Built-in functions
Every Content subclass has the following built-in functions:
Base.length — Function
Base.length(parameters::Parameters)
source
Base.length(layout::PrimitiveArray)
source
Base.length(layout::EmptyArray)
source
Base.length(layout::ListOffsetArray)
Length of a ListOffsetArray.
source
Base.length(layout::ListArray)
Length of a ListArray.
source
Base.length(layout::RegularArray)
Length of a RegularArray.
source
Base.length(layout::RecordArray)
source
Base.length(layout::TupleArray)
source
Base.length(layout::IndexedArray)
source
Base.length(layout::IndexedOptionArray)
source
Base.length(layout::ByteMaskedArray)
source
Base.length(layout::BitMaskedArray)
source
Base.length(layout::UnmaskedArray)
source
Base.length(layout::UnionArray)
source
Base.size — Function
Treat instances of Content as if they are one-dimensional arrays.
source
Base.firstindex — Function
Base.firstindex(layout::PrimitiveArray)
source
Base.firstindex(layout::EmptyArray)
source
Base.firstindex(layout::ListOffsetArray)
First index of a ListOffsetArray offsets.
source
Base.firstindex(layout::ListArray)
First index of a ListArray starts.
source
Base.firstindex(layout::RegularArray)
First index of a RegularArray is always 1.
source
Base.firstindex(layout::RecordArray)
source
Base.firstindex(layout::TupleArray)
source
Base.firstindex(layout::IndexedArray)
source
Base.firstindex(layout::IndexedOptionArray)
source
Base.firstindex(layout::ByteMaskedArray)
source
Base.firstindex(layout::BitMaskedArray)
source
Base.firstindex(layout::UnmaskedArray)
source
Base.firstindex(layout::UnionArray)
source
Base.lastindex — Function
Base.lastindex(layout::PrimitiveArray)
source
Base.lastindex(layout::EmptyArray)
source
Base.lastindex(layout::ListOffsetArray)
Last index of a ListOffsetArray offsets.
source
Base.lastindex(layout::ListArray)
Last index of a ListArray starts.
source
Base.lastindex(layout::RegularArray)
Last index of a RegularArray.
source
Base.lastindex(layout::RecordArray)
source
Base.lastindex(layout::TupleArray)
source
Base.lastindex(layout::IndexedArray)
source
Base.lastindex(layout::IndexedOptionArray)
source
Base.lastindex(layout::ByteMaskedArray)
source
Base.lastindex(layout::BitMaskedArray)
source
Base.lastindex(layout::UnmaskedArray)
source
Base.lastindex(layout::UnionArray)
source
Base.getindex — Function
Base.getindex(layout::PrimitiveArray, i::Int)
source
Base.getindex(layout::PrimitiveArray, r::UnitRange{Int})
source
Base.getindex(layout::EmptyArray, i::Int)
source
Base.getindex(layout::EmptyArray, r::UnitRange{Int})
source
Base.getindex(layout::ListOffsetArray, i::Int)
source
Base.getindex(layout::ListOffsetArray, r::UnitRange{Int})
source
Base.getindex(layout::ListOffsetArray, f::Symbol)
source
Base.getindex(layout::ListArray, i::Int)
source
Base.getindex(layout::ListArray, r::UnitRange{Int})
source
Base.getindex(layout::ListArray, f::Symbol)
source
Base.getindex(layout::RegularArray, i::Int)
source
Base.getindex(layout::RegularArray, r::UnitRange{Int})
source
Base.getindex(layout::RegularArray, f::Symbol)
source
Base.getindex(
     layout::ListOffsetArray{INDEX,PrimitiveArray{UInt8,BUFFER,:char},:string},
     i::Int,
-) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
+) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
     layout::ListArray{INDEX,PrimitiveArray{UInt8,BUFFER,:char},:string},
     i::Int,
-) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
+) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
     layout::RegularArray{PrimitiveArray{UInt8,BUFFER,:char},:string},
     i::Int,
-) where {BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
+) where {BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
     layout::ListOffsetArray{INDEX,PrimitiveArray{UInt8,BUFFER,:byte},:bytestring},
     i::Int,
-) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
+) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
     layout::ListArray{INDEX,PrimitiveArray{UInt8,BUFFER,:byte},:bytestring},
     i::Int,
-) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
+) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
     layout::RegularArray{PrimitiveArray{UInt8,BUFFER,:byte},:bytestring},
     i::Int,
-) where {BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
+) where {BUFFER<:AbstractVector{UInt8}}
source
Base.getindex(
     layout::RecordArray{FIELDS,CONTENTS,BEHAVIOR},
     i::Int,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
     layout::RecordArray{FIELDS,CONTENTS,BEHAVIOR},
     r::UnitRange{Int},
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
     layout::RecordArray{FIELDS,CONTENTS,BEHAVIOR},
     f::Symbol,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
     layout::Record{FIELDS,CONTENTS},
     f::Symbol,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Base.getindex(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Base.getindex(
     layout::TupleArray{CONTENTS,BEHAVIOR},
     i::Int,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
+) where {CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Base.getindex(
     layout::TupleArray{CONTENTS,BEHAVIOR},
     r::UnitRange{Int},
-) where {VALUES<:Content,CONTENTS<:Base.Tuple{VALUES},BEHAVIOR}
source
Base.getindex(
+) where {VALUES<:Content,CONTENTS<:Base.Tuple{VALUES},BEHAVIOR}
source
Base.getindex(
     layout::SlotRecord{CONTENTS},
     f::Int64,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Base.getindex(layout::IndexedArray, i::Int)
source
Base.getindex(layout::IndexedArray, r::UnitRange{Int})
source
Base.getindex(layout::IndexedArray, f::Symbol)
source
Base.getindex(layout::IndexedOptionArray, i::Int)
source
Base.getindex(layout::IndexedOptionArray, r::UnitRange{Int})
source
Base.getindex(layout::IndexedOptionArray, f::Symbol)
source
Base.getindex(layout::ByteMaskedArray, i::Int)
source
Base.getindex(layout::ByteMaskedArray, r::UnitRange{Int})
source
Base.getindex(layout::ByteMaskedArray, f::Symbol)
source
Base.getindex(layout::BitMaskedArray, i::Int)
source
Base.getindex(layout::BitMaskedArray, r::UnitRange{Int})
source
Base.getindex(layout::BitMaskedArray, f::Symbol)
source
Base.getindex(layout::UnmaskedArray, i::Int)
source
Base.getindex(layout::UnmaskedArray, r::UnitRange{Int})
source
Base.getindex(layout::UnmaskedArray, f::Symbol)
source
Base.getindex(layout::UnionArray, i::Int)
source
Base.getindex(layout::UnionArray, r::UnitRange{Int})
source
Base.getindex(layout::UnionArray, f::Symbol)
source
Base.iterate — Function
Base.iterate(layout::Content)
Enable the use of Julia's iteration protocol on instances of Content type.
Examples
# Assuming Content is defined and an instance is created
+) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Base.getindex(layout::IndexedArray, i::Int)
source
Base.getindex(layout::IndexedArray, r::UnitRange{Int})
source
Base.getindex(layout::IndexedArray, f::Symbol)
source
Base.getindex(layout::IndexedOptionArray, i::Int)
source
Base.getindex(layout::IndexedOptionArray, r::UnitRange{Int})
source
Base.getindex(layout::IndexedOptionArray, f::Symbol)
source
Base.getindex(layout::ByteMaskedArray, i::Int)
source
Base.getindex(layout::ByteMaskedArray, r::UnitRange{Int})
source
Base.getindex(layout::ByteMaskedArray, f::Symbol)
source
Base.getindex(layout::BitMaskedArray, i::Int)
source
Base.getindex(layout::BitMaskedArray, r::UnitRange{Int})
source
Base.getindex(layout::BitMaskedArray, f::Symbol)
source
Base.getindex(layout::UnmaskedArray, i::Int)
source
Base.getindex(layout::UnmaskedArray, r::UnitRange{Int})
source
Base.getindex(layout::UnmaskedArray, f::Symbol)
source
Base.getindex(layout::UnionArray, i::Int)
source
Base.getindex(layout::UnionArray, r::UnitRange{Int})
source
Base.getindex(layout::UnionArray, f::Symbol)
source
Base.iterate — Function
Base.iterate(layout::Content)
Enable the use of Julia's iteration protocol on instances of Content type.
Examples
# Assuming Content is defined and an instance is created
 for element in layout_instance
     println(element)
-end
Initialization: The iteration process starts by calling Base.iterate(layout) with the collection layout as the only argument. This should return  the first element and the initial state.
source
Base.iterate(layout::Content, state)
Iteration: The iteration continues by repeatedly calling  Base.iterate(layout, state) with the collection and the current state.  This returns the next element and the next state until it returns  nothing, indicating the end of the iteration.
Parameters
layout::Content: This specifies that the function operates on an  instance of the type Content.
state: This represents the current state of the iteration,  typically an index or position in the collection.
source
Base.eltype — Function
Base.eltype(layout::PrimitiveArray)
source
Base.eltype(layout::EmptyArray)
source
Base.eltype(layout::ListType)
source
Base.eltype(layout::IndexedArray)
source
Base.eltype(layout::IndexedOptionArray)
source
Base.eltype(layout::ByteMaskedArray)
source
Base.eltype(layout::BitMaskedArray)
source
Base.eltype(layout::UnmaskedArray)
source
Base.eltype(layout::UnionArray)
source
Base.:== — Function
Base.:(==)(layout1::Content, layout2::Content)
Two Content objects are considered equal only if they have the same  elements in the same order.
source
Base.:(==)(
+end
Initialization: The iteration process starts by calling Base.iterate(layout) with the collection layout as the only argument. This should return  the first element and the initial state.
source
Base.iterate(layout::Content, state)
Iteration: The iteration continues by repeatedly calling  Base.iterate(layout, state) with the collection and the current state.  This returns the next element and the next state until it returns  nothing, indicating the end of the iteration.
Parameters
layout::Content: This specifies that the function operates on an  instance of the type Content.
state: This represents the current state of the iteration,  typically an index or position in the collection.
source
Base.eltype — Function
Base.eltype(layout::PrimitiveArray)
source
Base.eltype(layout::EmptyArray)
source
Base.eltype(layout::ListType)
source
Base.eltype(layout::IndexedArray)
source
Base.eltype(layout::IndexedOptionArray)
source
Base.eltype(layout::ByteMaskedArray)
source
Base.eltype(layout::BitMaskedArray)
source
Base.eltype(layout::UnmaskedArray)
source
Base.eltype(layout::UnionArray)
source
Base.:== — Function
Base.:(==)(layout1::Content, layout2::Content)
Two Content objects are considered equal only if they have the same  elements in the same order.
source
Base.:(==)(
     layout1::RecordArray{FIELDS,CONTENTS1},
     layout2::RecordArray{FIELDS,CONTENTS2},
 ) where {
     FIELDS,
     CONTENTS1<:Base.Tuple{Vararg{Content}},
     CONTENTS2<:Base.Tuple{Vararg{Content}},
-}
source
Base.:(==)(
+}
source
Base.:(==)(
     layout1::Record{FIELDS,CONTENTS1},
     layout2::Record{FIELDS,CONTENTS2},
 ) where {
     FIELDS,
     CONTENTS1<:Base.Tuple{Vararg{Content}},
     CONTENTS2<:Base.Tuple{Vararg{Content}},
-}
source
Base.:(==)(
+}
source
Base.:(==)(
     layout1::TupleArray{CONTENTS1},
     layout2::TupleArray{CONTENTS2},
 ) where {
     N,
     CONTENTS1<:Base.Tuple{Vararg{Content,N}},
     CONTENTS2<:Base.Tuple{Vararg{Content,N}},
-}
source
Base.:(==)(
+}
source
Base.:(==)(
     layout1::SlotRecord{CONTENTS1},
     layout2::SlotRecord{CONTENTS2},
 ) where {
     N,
     CONTENTS1<:Base.Tuple{Vararg{Content,N}},
     CONTENTS2<:Base.Tuple{Vararg{Content,N}},
-}
source
Base.push! — Function
Base.push!(layout::PrimitiveArray{ITEM}, input::ITEM) where {ITEM}
Push multiple ITEM elements (from another collection) to an instance of PrimitiveArray.
source
Base.push!(layout::PrimitiveArray{ITEM}, input::Number) where {ITEM}
source
Base.push!(layout::EmptyArray, input)
source
Base.push!(layout::ListType{BEHAVIOR}, input::String) where {BEHAVIOR}
source
Base.push!(layout::ListType, input::AbstractVector)
source
Base.push!(
+}
source
Base.push! — Function
Base.push!(layout::PrimitiveArray{ITEM}, input::ITEM) where {ITEM}
Push multiple ITEM elements (from another collection) to an instance of PrimitiveArray.
source
Base.push!(layout::PrimitiveArray{ITEM}, input::Number) where {ITEM}
source
Base.push!(layout::EmptyArray, input)
source
Base.push!(layout::ListType{BEHAVIOR}, input::String) where {BEHAVIOR}
source
Base.push!(layout::ListType, input::AbstractVector)
source
Base.push!(
     layout::RecordArray{FIELDS,CONTENTS},
     input::NamedTuple{FIELDS},
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Base.push!(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Base.push!(
     layout::TupleArray{CONTENTS},
     input::INPUT,
-) where {N,CONTENTS<:Base.Tuple{Vararg{Content,N}},INPUT<:Base.Tuple{Vararg{Any,N}}}
source
Base.push!(layout::IndexedArray, input)
source
Base.push!(layout::IndexedOptionArray, input)
source
Base.push!(layout::ByteMaskedArray, input)
source
Base.push!(layout::BitMaskedArray, input)
source
Base.push!(layout::UnmaskedArray, input)
source
Base.push!(special::Specialization, input)
source
Base.push!(layout::UnionArray, input)
source
Base.append! — Function
Base.append!(layout::Content, input)
Append multiple elements (from another collection) to an instance of Content.
source
Base.append!(layout::OptionType, input)
Appending elements to an array of type OptionType, handling missing values.
source
Base.append!(special::Specialization, input)
source
Base.show — Function
Base.show(io::IO, parameters::Parameters)
source
Base.show(
+) where {N,CONTENTS<:Base.Tuple{Vararg{Content,N}},INPUT<:Base.Tuple{Vararg{Any,N}}}
source
Base.push!(layout::IndexedArray, input)
source
Base.push!(layout::IndexedOptionArray, input)
source
Base.push!(layout::ByteMaskedArray, input)
source
Base.push!(layout::BitMaskedArray, input)
source
Base.push!(layout::UnmaskedArray, input)
source
Base.push!(special::Specialization, input)
source
Base.push!(layout::UnionArray, input)
source
Base.append! — Function
Base.append!(layout::Content, input)
Append multiple elements (from another collection) to an instance of Content.
source
Base.append!(layout::OptionType, input)
Appending elements to an array of type OptionType, handling missing values.
source
Base.append!(special::Specialization, input)
source
Base.show — Function
Base.show(io::IO, parameters::Parameters)
source
Base.show(
     io::IO,
     data::Union{Content,Record,Tuple};
     limit_rows::Int = 1,
     limit_cols::Int = 80,
-)
source
Base.show(data::Union{Content,Record,Tuple}; limit_rows::Int = 1, limit_cols::Int = 80)
source
Manipulating and checking structure
Every Content subclass has the following functions for manipulating and checking structure:
AwkwardArray.has_parameter — Function
has_parameter(parameters::Parameters, key::String)
source
has_parameter(content::CONTENT, key::String) where {CONTENT<:Content}
Return true if a parameter exists.
source
has_parameter(content::EmptyArray, key::String)
source
AwkwardArray.get_parameter — Function
get_parameter(parameters::Parameters, key::String)
source
get_parameter(content::CONTENT, key::String) where {CONTENT<:Content}
Return a parameter or raises an error.
source
get_parameter(content::EmptyArray, key::String)
source
Manipulating and checking structure
Every Content subclass has the following functions for manipulating and checking structure:
AwkwardArray.has_parameter — Function
has_parameter(parameters::Parameters, key::String)
source
has_parameter(content::CONTENT, key::String) where {CONTENT<:Content}
Return true if a parameter exists.
source
has_parameter(content::EmptyArray, key::String)
source
AwkwardArray.get_parameter — Function
get_parameter(parameters::Parameters, key::String)
source
get_parameter(content::CONTENT, key::String) where {CONTENT<:Content}
Return a parameter or raises an error.
source
get_parameter(content::EmptyArray, key::String)
source
AwkwardArray.copy — Function
copy(
     layout::PrimitiveArray{ITEM,BUFFER1,BEHAVIOR};
     data::Union{Unset,BUFFER2} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {ITEM,BUFFER1<:AbstractVector{ITEM},BUFFER2<:AbstractVector,BEHAVIOR}
source
copy(behavior::Union{Unset,Symbol} = Unset())
source
copy(
+) where {ITEM,BUFFER1<:AbstractVector{ITEM},BUFFER2<:AbstractVector,BEHAVIOR}
source
copy(behavior::Union{Unset,Symbol} = Unset())
source
copy(
     layout::ListOffsetArray{INDEX1,CONTENT1,BEHAVIOR};
     offsets::Union{Unset,INDEX2} = Unset(),
     content::Union{Unset,CONTENT2} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {INDEX1<:IndexBig,INDEX2<:IndexBig,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
Copy of a ListOffsetArray.
source
copy(
+) where {INDEX1<:IndexBig,INDEX2<:IndexBig,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
Copy of a ListOffsetArray.
source
copy(
     layout::ListArray{INDEX1,CONTENT1,BEHAVIOR};
     starts::Union{Unset,INDEX2} = Unset(),
     stops::Union{Unset,INDEX2} = Unset(),
     content::Union{Unset,CONTENT2} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {INDEX1<:IndexBig,INDEX2<:IndexBig,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
Copy of a ListArray.
source
copy(
+) where {INDEX1<:IndexBig,INDEX2<:IndexBig,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
Copy of a ListArray.
source
copy(
     layout::RegularArray{CONTENT1,BEHAVIOR};
     content::Union{Unset,CONTENT2} = Unset(),
     size::Union{Unset,Int} = Unset(),
     zeros_length::Union{Unset,Int} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
Copy of a RegularArray.
source
copy(
+) where {CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
Copy of a RegularArray.
source
copy(
     layout::RecordArray{FIELDS1,CONTENTS1,BEHAVIOR};
     contents::Union{Unset,NamedTuple{FIELDS2,CONTENTS2}} = Unset(),
     length::Union{Unset,Int64} = Unset(),
@@ -117,7 +117,7 @@
     CONTENTS1<:Base.Tuple{Vararg{Content}},
     CONTENTS2<:Base.Tuple{Vararg{Content}},
     BEHAVIOR,
-}
source
copy(
+}
source
copy(
     layout::TupleArray{CONTENTS1,BEHAVIOR};
     contents::Union{Unset,CONTENTS2} = Unset(),
     length::Union{Unset,Int64} = Unset(),
@@ -127,13 +127,13 @@
     CONTENTS1<:Base.Tuple{Vararg{Content}},
     CONTENTS2<:Base.Tuple{Vararg{Content}},
     BEHAVIOR,
-}
source
copy(
+}
source
copy(
     layout::IndexedArray{INDEX1,CONTENT1,BEHAVIOR};
     index::Union{Unset,INDEX2} = Unset(),
     content::Union{Unset,CONTENT2} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {INDEX1<:IndexBig,INDEX2<:IndexBig,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
+) where {INDEX1<:IndexBig,INDEX2<:IndexBig,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
     layout::IndexedOptionArray{INDEX1,CONTENT1,BEHAVIOR};
     index::Union{Unset,INDEX2} = Unset(),
     content::Union{Unset,CONTENT2} = Unset(),
@@ -145,271 +145,271 @@
     CONTENT1<:Content,
     CONTENT2<:Content,
     BEHAVIOR,
-}
Copy of an IndexedOptionArray, potentially with some modifications to its fields.
source
copy(
+}
Copy of an IndexedOptionArray, potentially with some modifications to its fields.
source
copy(
     layout::ByteMaskedArray{INDEX1,CONTENT1,BEHAVIOR};
     mask::Union{Unset,INDEX2} = Unset(),
     content::Union{Unset,CONTENT2} = Unset(),
     valid_when::Union{Unset,Bool} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {INDEX1<:IndexBool,INDEX2<:IndexBool,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
+) where {INDEX1<:IndexBool,INDEX2<:IndexBool,CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
     layout::BitMaskedArray{CONTENT1,BEHAVIOR};
     mask::Union{Unset,BitVector} = Unset(),
     content::Union{Unset,CONTENT2} = Unset(),
     valid_when::Union{Unset,Bool} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
+) where {CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
     layout::UnmaskedArray{CONTENT1,BEHAVIOR};
     content::Union{Unset,CONTENT2} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-) where {CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
+) where {CONTENT1<:Content,CONTENT2<:Content,BEHAVIOR}
source
copy(
     layout::UnionArray{TAGS1,INDEX1,CONTENTS1,BEHAVIOR};
     tags::Union{Unset,TAGS2} = Unset(),
     index::Union{Unset,INDEX2} = Unset(),
     contents::Union{Unset,CONTENTS2} = Unset(),
     parameters::Union{Unset,Parameters} = Unset(),
     behavior::Union{Unset,Symbol} = Unset(),
-)
source
AwkwardArray.is_valid — Function
is_valid(layout::PrimitiveArray)
source
is_valid(layout::EmptyArray)
source
is_valid(layout::ListOffsetArray)
Check if a ListOffsetArray is valid.
source
is_valid(layout::ListArray)
Check if a ListArray is valid.
source
is_valid(layout::RegularArray)
Check if a RegularArray is valid.
source
is_valid(layout::RecordArray)
source
is_valid(layout::TupleArray)
source
is_valid(layout::IndexedArray)
source
is_valid(layout::IndexedOptionArray)
source
is_valid(layout::ByteMaskedArray)
source
is_valid(layout::BitMaskedArray)
source
is_valid(layout::UnmaskedArray)
source
is_valid(layout::UnionArray)
source
Filling an array
Every Content subclass has the following functions for filling an array:
AwkwardArray.end_list! — Function
end_list!(layout::ListOffsetArray)
source
end_list!(layout::ListArray)
source
end_list!(layout::RegularArray)
source
end_list!(layout::IndexedArray)
source
end_list!(layout::IndexedOptionArray)
source
end_list!(layout::ByteMaskedArray)
source
end_list!(layout::BitMaskedArray)
source
end_list!(layout::UnmaskedArray)
source
end_list!(special::Specialization)
source
AwkwardArray.is_valid — Function
is_valid(layout::PrimitiveArray)
source
is_valid(layout::EmptyArray)
source
is_valid(layout::ListOffsetArray)
Check if a ListOffsetArray is valid.
source
is_valid(layout::ListArray)
Check if a ListArray is valid.
source
is_valid(layout::RegularArray)
Check if a RegularArray is valid.
source
is_valid(layout::RecordArray)
source
is_valid(layout::TupleArray)
source
is_valid(layout::IndexedArray)
source
is_valid(layout::IndexedOptionArray)
source
is_valid(layout::ByteMaskedArray)
source
is_valid(layout::BitMaskedArray)
source
is_valid(layout::UnmaskedArray)
source
is_valid(layout::UnionArray)
source
Filling an array
Every Content subclass has the following functions for filling an array:
AwkwardArray.end_list! — Function
end_list!(layout::ListOffsetArray)
source
end_list!(layout::ListArray)
source
end_list!(layout::RegularArray)
source
end_list!(layout::IndexedArray)
source
end_list!(layout::IndexedOptionArray)
source
end_list!(layout::ByteMaskedArray)
source
end_list!(layout::BitMaskedArray)
source
end_list!(layout::UnmaskedArray)
source
end_list!(special::Specialization)
source
AwkwardArray.push_null! — Function
push_null!(layout::IndexedOptionArray)
source
push_null!(layout::ByteMaskedArray)
source
push_null!(layout::BitMaskedArray)
source
push_null!(
     special::Specialization{ARRAY,TAGGED},
-) where {ARRAY<:UnionArray,TAGGED<:OptionType}
source
AwkwardArray.push_dummy! — Function
push_dummy!(layout::PrimitiveArray{ITEM}) where {ITEM}
source
push_dummy!(layout::ListOffsetArray)
source
push_dummy!(layout::ListArray)
source
push_dummy!(layout::RegularArray)
source
push_dummy!(layout::RecordArray)
source
push_dummy!(layout::TupleArray)
source
push_dummy!(layout::IndexedArray)
source
push_dummy!(layout::IndexedOptionArray)
source
push_dummy!(layout::ByteMaskedArray)
source
push_dummy!(layout::BitMaskedArray)
source
push_dummy!(layout::UnmaskedArray)
source
push_dummy!(special::Specialization)
source
Selecting fields
RecordArrayand TupleArray have the following for selecting fields (as opposed to rows):
AwkwardArray.push_dummy! — Function
push_dummy!(layout::PrimitiveArray{ITEM}) where {ITEM}
source
push_dummy!(layout::ListOffsetArray)
source
push_dummy!(layout::ListArray)
source
push_dummy!(layout::RegularArray)
source
push_dummy!(layout::RecordArray)
source
push_dummy!(layout::TupleArray)
source
push_dummy!(layout::IndexedArray)
source
push_dummy!(layout::IndexedOptionArray)
source
push_dummy!(layout::ByteMaskedArray)
source
push_dummy!(layout::BitMaskedArray)
source
push_dummy!(layout::UnmaskedArray)
source
push_dummy!(special::Specialization)
source
Selecting fields
RecordArrayand TupleArray have the following for selecting fields (as opposed to rows):
AwkwardArray.slot — Function
slot(
     layout::RecordArray{FIELDS,CONTENTS,BEHAVIOR},
     f::Symbol,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
slot(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
slot(
     layout::TupleArray{CONTENTS,BEHAVIOR},
     f::Int,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Specializations
UnionArrayhas the following for dealing with specializations:
Convertion
Finally, all Contentsubclasses can be converted with the following:
AwkwardArray.to_vector — Function
to_vector(layout::Content; view::Bool = false, na::Union{Missing,Nothing} = missing)
source
to_vector(
+) where {CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
source
Specializations
UnionArrayhas the following for dealing with specializations:
Convertion
Finally, all Contentsubclasses can be converted with the following:
AwkwardArray.to_vector — Function
to_vector(layout::Content; view::Bool = false, na::Union{Missing,Nothing} = missing)
source
to_vector(
     record::Record{FIELDS,CONTENTS};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}} = NamedTuple{FIELDS}
source
to_vector(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}} = NamedTuple{FIELDS}
source
to_vector(
     tuple::Tuple{CONTENTS};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
to_vector(
+) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
to_vector(
     layout::PrimitiveArray{ITEM},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {ITEM}
source
to_vector(
+) where {ITEM}
source
to_vector(
     layout::EmptyArray,
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-)
source
to_vector(
+)
source
to_vector(
     layout::ListOffsetArray{INDEX,CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
     layout::ListArray{INDEX,CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
     layout::RegularArray{CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {CONTENT<:Content}
source
to_vector(
+) where {CONTENT<:Content}
source
to_vector(
     layout::ListOffsetArray{INDEX,PrimitiveArray{UInt8,BUFFER,:char},:string},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
to_vector(
+) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
to_vector(
     layout::ListArray{INDEX,PrimitiveArray{UInt8,BUFFER,:char},:string},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
to_vector(
+) where {INDEX<:IndexBig,BUFFER<:AbstractVector{UInt8}}
source
to_vector(
     layout::RegularArray{PrimitiveArray{UInt8,BUFFER,:char},:string},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {BUFFER<:AbstractVector{UInt8}}
source
to_vector(
+) where {BUFFER<:AbstractVector{UInt8}}
source
to_vector(
     layout::RecordArray{FIELDS,CONTENTS},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
to_vector(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
to_vector(
     layout::TupleArray{CONTENTS},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
to_vector(
+) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
to_vector(
     layout::IndexedArray{INDEX,CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
     layout::IndexedOptionArray{INDEX,CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
to_vector(
     layout::ByteMaskedArray{INDEX,CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {INDEX<:IndexBool,CONTENT<:Content}
source
to_vector(
+) where {INDEX<:IndexBool,CONTENT<:Content}
source
to_vector(
     layout::BitMaskedArray{CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {CONTENT<:Content}
source
to_vector(
+) where {CONTENT<:Content}
source
to_vector(
     layout::UnmaskedArray{CONTENT},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {CONTENT<:Content}
source
to_vector(
+) where {CONTENT<:Content}
source
to_vector(
     layout::UnionArray{TAGS,INDEX,CONTENTS},
     r::UnitRange{Int};
     view::Bool = false,
     na::Union{Missing,Nothing} = missing,
-) where {TAGS<:Index8,INDEX<:IndexBig,CONTENTS<:Base.Tuple}
source
AwkwardArray.from_buffers — Function
from_buffers(
     form::String,
     length::Int,
     containers::Dict{String,BUFFER};
     buffer_key::BUFFER_KEY_FUNCTION = default_buffer_key,
-) where {BUFFER<:AbstractVector{UInt8},BUFFER_KEY_FUNCTION<:Function}
source
from_buffers(
+) where {BUFFER<:AbstractVector{UInt8},BUFFER_KEY_FUNCTION<:Function}
source
from_buffers(
     form::Dict{String,Any},
     length::Int,
     containers::Dict{String,BUFFER};
     buffer_key::BUFFER_KEY_FUNCTION = default_buffer_key,
-) where {BUFFER<:AbstractVector{UInt8},BUFFER_KEY_FUNCTION<:Function}
source
Arrays of Stings
Arrays of Stings
AwkwardArray.ByteStringOffsetArray — Function
ByteStringOffsetArray(
     offsets::INDEX,
     data::AbstractVector{UInt8};
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig}
The function that constructs a specialized array type for handling byte strings with specific offsets.
  • offsets: This is an array of indices (INDEX) which determines where each string starts within the byte array.
  • data: This is a vector of UInt8 (unsigned 8-bit integers), representing the raw bytes of the strings.
  • parameters: Optional parameters for configuring the ListOffsetArray.
  • byte_parameters: Optional parameters specifically for the PrimitiveArray holding the byte data.
  • INDEX<: Ensures that offsets is a subtype of IndexBig, which typically implies a larger indexing type suitable for big data.
Note
It is a ListType with behavior = :bytestring.
source
ByteStringOffsetArray(;
+) where {INDEX<:IndexBig}
The function that constructs a specialized array type for handling byte strings with specific offsets.
  • offsets: This is an array of indices (INDEX) which determines where each string starts within the byte array.
  • data: This is a vector of UInt8 (unsigned 8-bit integers), representing the raw bytes of the strings.
  • parameters: Optional parameters for configuring the ListOffsetArray.
  • byte_parameters: Optional parameters specifically for the PrimitiveArray holding the byte data.
  • INDEX<: Ensures that offsets is a subtype of IndexBig, which typically implies a larger indexing type suitable for big data.
Note
It is a ListType with behavior = :bytestring.
source
ByteStringOffsetArray(;
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-)
A default constructor that initializes an empty ByteStringOffsetArray.
source
AwkwardArray.ByteStringArray — Function
ByteStringArray(
     starts::INDEX,
     stops::INDEX,
     data::AbstractVector{UInt8};
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig}
The ByteStringArray function constructs a specialized array type for handling byte strings, similar to ByteStringOffsetArray, but it uses separate starts and stops indices rather than a single offsets array.
source
ByteStringArray(;
+) where {INDEX<:IndexBig}
The ByteStringArray function constructs a specialized array type for handling byte strings, similar to ByteStringOffsetArray, but it uses separate starts and stops indices rather than a single offsets array.
source
ByteStringArray(;
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-)
A default constructor that initializes an empty ByteStringArray.
source
AwkwardArray.ByteStringRegularArray — Function
ByteStringRegularArray(
     data::AbstractVector{UInt8},
     size::Int;
     zeros_length::Int = 0,
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-)
source
ByteStringRegularArray(
+)
source
ByteStringRegularArray(
     size::Int;
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-)
source
ByteStringRegularArray(;
+)
source
ByteStringRegularArray(;
     parameters::Parameters = Parameters(),
     byte_parameters::Parameters = Parameters(),
-)
source
AwkwardArray.StringArray — Function
StringArray(
     starts::INDEX,
     stops::INDEX,
     data::AbstractVector{UInt8};
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig}
source
StringArray(
+) where {INDEX<:IndexBig}
source
StringArray(
     starts::INDEX,
     stops::INDEX,
     data::String;   # data provided as a String, rather than AbstractVector{UInt8}
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig}
source
StringArray(;
+) where {INDEX<:IndexBig}
source
StringArray(;
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-)
source
AwkwardArray.StringOffsetArray — Function
StringOffsetArray(
     offsets::INDEX,
     data::AbstractVector{UInt8};
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig}
source
StringOffsetArray(
+) where {INDEX<:IndexBig}
source
StringOffsetArray(
     offsets::INDEX,
     data::String;
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig}
source
StringOffsetArray(; parameters = Parameters(), char_parameters = Parameters())
source
AwkwardArray.StringRegularArray — Function
StringRegularArray(
     data::AbstractVector{UInt8},
     size::Int;
     zeros_length::Int = 0,
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-)
source
StringRegularArray(
+)
source
StringRegularArray(
     data::String,
     size::Int;
     zeros_length::Int = 0,
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-)
source
StringRegularArray(
+)
source
StringRegularArray(
     size::Int;
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-)
source
StringRegularArray(;
+)
source
StringRegularArray(;
     parameters::Parameters = Parameters(),
     char_parameters::Parameters = Parameters(),
-)
source
Utilities
AwkwardArray.isprimitive — Function
isprimitive(t::Type)
Determine if a given type is one of the fundamental data types in Julia  that are typically considered primitive. These include:
Integer: Represents all integer types (e.g., Int64, UInt8). AbstractFloat: Represents all floating-point types (e.g., Float64, Float32). Bool: Represents boolean values (true and false). Char: Represents character values.
source
AwkwardArray.check_primitive_type — Function
check_primitive_type(ITEM)
A utility that provides a string representation for various primitive  types in Julia. It helps in identifying the type of an item and mapping  it to a human-readable format. This is useful in scenarios where type  information needs to be logged, serialized, or displayed. If a type is  not recognized, it defaults to returning unknown.
source
Private functions
Utilities
AwkwardArray.isprimitive — Function
isprimitive(t::Type)
Determine if a given type is one of the fundamental data types in Julia  that are typically considered primitive. These include:
Integer: Represents all integer types (e.g., Int64, UInt8). AbstractFloat: Represents all floating-point types (e.g., Float64, Float32). Bool: Represents boolean values (true and false). Char: Represents character values.
source
AwkwardArray.check_primitive_type — Function
check_primitive_type(ITEM)
A utility that provides a string representation for various primitive  types in Julia. It helps in identifying the type of an item and mapping  it to a human-readable format. This is useful in scenarios where type  information needs to be logged, serialized, or displayed. If a type is  not recognized, it defaults to returning unknown.
source
Private functions
AwkwardArray._get_buffer — Function
_get_buffer(
     form_key::Union{Nothing,String},
     attribute::String,
     buffer_key::BUFFER_KEY_FUNCTION,
     containers::Dict{String,BUFFER},
-) where {BUFFER<:AbstractVector{UInt8},BUFFER_KEY_FUNCTION<:Function}
source
AwkwardArray._get_index — Function
_get_index(
     form_snippet::String,
     length::Int64,
     buffer::BUFFER,
-) where {BUFFER<:AbstractVector{UInt8}}
source
AwkwardArray._to_buffers! — Function
_to_buffers!(
     layout::PrimitiveArray{ITEM,BUFFER},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {ITEM,BUFFER<:AbstractVector{ITEM}}
source
_to_buffers!(
+) where {ITEM,BUFFER<:AbstractVector{ITEM}}
source
_to_buffers!(
     layout::EmptyArray,
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-)
source
_to_buffers!(
+)
source
_to_buffers!(
     layout::ListOffsetArray{INDEX,CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
_to_buffers!(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
_to_buffers!(
     layout::ListArray{INDEX,CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
_to_buffers!(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
_to_buffers!(
     layout::RegularArray{CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {CONTENT<:Content}
source
_to_buffers!(
+) where {CONTENT<:Content}
source
_to_buffers!(
     layout::RecordArray{FIELDS,CONTENTS},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
_to_buffers!(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
_to_buffers!(
     layout::TupleArray{CONTENTS},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
_to_buffers!(
+) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
source
_to_buffers!(
     layout::IndexedArray{INDEX,CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {INDEX<:IndexBig,CONTENT<:Content}
source
_to_buffers!(
+) where {INDEX<:IndexBig,CONTENT<:Content}
source
_to_buffers!(
     layout::IndexedOptionArray{INDEX,CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {INDEX<:IndexBigSigned,CONTENT<:Content}
source
_to_buffers!(
+) where {INDEX<:IndexBigSigned,CONTENT<:Content}
source
_to_buffers!(
     layout::ByteMaskedArray{INDEX,CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {INDEX<:IndexBool,CONTENT<:Content}
source
_to_buffers!(
+) where {INDEX<:IndexBool,CONTENT<:Content}
source
_to_buffers!(
     layout::BitMaskedArray{CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {CONTENT<:Content}
source
_to_buffers!(
+) where {CONTENT<:Content}
source
_to_buffers!(
     layout::UnmaskedArray{CONTENT},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {CONTENT<:Content}
source
_to_buffers!(
+) where {CONTENT<:Content}
source
_to_buffers!(
     layout::UnionArray{TAGS,INDEX,CONTENTS},
     number::Vector{Int64},
     containers::Dict{String,AbstractVector{UInt8}},
-) where {TAGS<:Index8,INDEX<:IndexBig,CONTENTS<:Base.Tuple{Vararg{Content}}}
source
Index

+) where {TAGS<:Index8,INDEX<:IndexBig,CONTENTS<:Base.Tuple{Vararg{Content}}}
source

Index

diff --git a/previews/PR111/getting_started/index.html b/previews/PR111/getting_started/index.html index 0c71006..1c5ab19 100644 --- a/previews/PR111/getting_started/index.html +++ b/previews/PR111/getting_started/index.html @@ -8,4 +8,4 @@ const ak = pyimport("awkward") println(ak.__version__) -2.6.4

See Examples.

+2.6.4

See Examples.

diff --git a/previews/PR111/howto/index.html b/previews/PR111/howto/index.html index 7afb330..04c96c2 100644 --- a/previews/PR111/howto/index.html +++ b/previews/PR111/howto/index.html @@ -1,2 +1,2 @@ -HowTo · for Julia!
Edit on GitHub
+HowTo · for Julia!
Edit on GitHub
diff --git a/previews/PR111/index.html b/previews/PR111/index.html index f50102f..30e84ab 100644 --- a/previews/PR111/index.html +++ b/previews/PR111/index.html @@ -59,4 +59,4 @@ "three" julia> typeof(array[3]) -String

Most applications of behavior apply to RecordArrays (e.g. Vector in Python).

+String

Most applications of behavior apply to RecordArrays (e.g. Vector in Python).

diff --git a/previews/PR111/indexing/index.html b/previews/PR111/indexing/index.html index f09b1a7..08cb05b 100644 --- a/previews/PR111/indexing/index.html +++ b/previews/PR111/indexing/index.html @@ -1,2 +1,2 @@ -Indexing · for Julia!
Edit on GitHub
+Indexing · for Julia!
Edit on GitHub
diff --git a/previews/PR111/internals/index.html b/previews/PR111/internals/index.html index f123422..fcd52be 100644 --- a/previews/PR111/internals/index.html +++ b/previews/PR111/internals/index.html @@ -1,2 +1,2 @@ -Internals · for Julia!
Edit on GitHub
+Internals · for Julia!
Edit on GitHub
diff --git a/previews/PR111/search/index.html b/previews/PR111/search/index.html index c535ebb..fd879c6 100644 --- a/previews/PR111/search/index.html +++ b/previews/PR111/search/index.html @@ -1,2 +1,2 @@ -Search · for Julia!

Loading search...

    +Search · for Julia!

    Loading search...

      diff --git a/previews/PR111/types/index.html b/previews/PR111/types/index.html index 451523d..a5d9744 100644 --- a/previews/PR111/types/index.html +++ b/previews/PR111/types/index.html @@ -19,7 +19,7 @@ valid_when::Bool = false, parameters::Parameters = Parameters(), behavior::Symbol = :default -) where {CONTENT<:Content}

      This is the outer constructor for the BitMaskedArray struct. It initializes a new instance of BitMaskedArray with the given mask, content, and optional valid_when, parameters, and behavior. The where {CONTENT<:Content} clause ensures that CONTENT satisfies the specified constraint.

      new{CONTENT,behavior}(mask, content, valid_when, parameters)

      creates a new instance of BitMaskedArray with the specified type parameters and field values.

      Note

      All Python BitMaskedArrays must be converted to lsb_order = true.

      source
      AwkwardArray.BitMaskedArray — Method
      BitMaskedArray{CONTENT}(;
+) where {CONTENT<:Content}

      This is the outer constructor for the BitMaskedArray struct. It initializes a new instance of BitMaskedArray with the given mask, content, and optional valid_when, parameters, and behavior. The where {CONTENT<:Content} clause ensures that CONTENT satisfies the specified constraint.

      new{CONTENT,behavior}(mask, content, valid_when, parameters)

      creates a new instance of BitMaskedArray with the specified type parameters and field values.

      Note

      All Python BitMaskedArrays must be converted to lsb_order = true.

      source
      AwkwardArray.BitMaskedArray — Method
      BitMaskedArray{CONTENT}(;
     valid_when::Bool = false,
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
@@ -33,7 +33,7 @@
     valid_when = valid_when,
     parameters = parameters,
     behavior = behavior,
-)
      source
      AwkwardArray.ByteMaskedArray — Type
      ByteMaskedArray{INDEX<:IndexBool, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}

      Specialized array type designed to handle arrays where elements can be optionally masked using a mask of type INDEX (which is constrained to be a subtype of IndexBool).

      Inherits from OptionType.

      struct ByteMaskedArray{INDEX<:IndexBool, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}
+)
      source
      AwkwardArray.ByteMaskedArray — Type
      ByteMaskedArray{INDEX<:IndexBool, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}

      Specialized array type designed to handle arrays where elements can be optionally masked using a mask of type INDEX (which is constrained to be a subtype of IndexBool).

      Inherits from OptionType.

      struct ByteMaskedArray{INDEX<:IndexBool, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}
     mask::INDEX
     content::CONTENT
     valid_when::Bool
@@ -53,7 +53,7 @@
     valid_when::Bool = false, 
     parameters::Parameters = Parameters(), 
     behavior::Symbol = :default
-) where {INDEX<:IndexBool, CONTENT<:Content}:

      This is the outer constructor for the ByteMaskedArray struct. It initializes a new instance of ByteMaskedArray with the given mask, content, and optional valid_when, parameters, and behavior. The where {INDEX<:IndexBool, CONTENT<:Content} clause ensures that INDEX and CONTENT satisfy the specified constraints.

      new{INDEX, CONTENT, behavior}(mask, content, valid_when, parameters)

      creates a new instance of ByteMaskedArray with the specified type parameters and field values.

      source
      AwkwardArray.ByteMaskedArray — Method
      ByteMaskedArray{INDEX,CONTENT}(;
+) where {INDEX<:IndexBool, CONTENT<:Content}:

      This is the outer constructor for the ByteMaskedArray struct. It initializes a new instance of ByteMaskedArray with the given mask, content, and optional valid_when, parameters, and behavior. The where {INDEX<:IndexBool, CONTENT<:Content} clause ensures that INDEX and CONTENT satisfy the specified constraints.

      new{INDEX, CONTENT, behavior}(mask, content, valid_when, parameters)

      creates a new instance of ByteMaskedArray with the specified type parameters and field values.

      source
      AwkwardArray.ByteMaskedArray — Method
      ByteMaskedArray{INDEX,CONTENT}(;
     valid_when::Bool = false,
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
@@ -67,13 +67,13 @@
     valid_when = valid_when,
     parameters = parameters,
     behavior = behavior,
-)
      source
      AwkwardArray.Content — Type

      Abstract Content type. Each layout is subtype from this.

      List of functions

      Every Content subclass has the following built-in functions:

      They also have the following functions for manipulating and checking structure:

      They have the following functions for filling an array:

      RecordArray and TupleArray have the following for selecting fields (as opposed to rows):

      • AwkwardArray.slot: gets a RecordArray or TupleArray field, to avoid conflicts with Base.getindex for TupleArrays (both use integers to select a field)
      • AwkwardArray.Record: scalar representation of an item from a RecordArray
      • AwkwardArray.SlotRecord: scalar representation of an item from a TupleArray (note: not the same as Base.Tuple)

      UnionArray has the following for dealing with specializations:

      Finally, all Content subclasses can be converted with the following:

      source
      AwkwardArray.EmptyArray — Type

      Represents an array that is always empty.

      struct EmptyArray{BEHAVIOR} <: LeafType{BEHAVIOR}
+)
      source
      AwkwardArray.Content — Type

      Abstract Content type. Each layout is subtype from this.

      List of functions

      Every Content subclass has the following built-in functions:

      They also have the following functions for manipulating and checking structure:

      They have the following functions for filling an array:

      RecordArray and TupleArray have the following for selecting fields (as opposed to rows):

      • AwkwardArray.slot: gets a RecordArray or TupleArray field, to avoid conflicts with Base.getindex for TupleArrays (both use integers to select a field)
      • AwkwardArray.Record: scalar representation of an item from a RecordArray
      • AwkwardArray.SlotRecord: scalar representation of an item from a TupleArray (note: not the same as Base.Tuple)

      UnionArray has the following for dealing with specializations:

      Finally, all Content subclasses can be converted with the following:

      source
      AwkwardArray.EmptyArray — Type

      Represents an array that is always empty.

      struct EmptyArray{BEHAVIOR} <: LeafType{BEHAVIOR}
     behavior::Symbol
     
     function EmptyArray(; behavior::Symbol = :default)
         new{behavior}(behavior)
     end
-end

      Type Parameter:

      • {BEHAVIOR}: The EmptyArray type has a parameter BEHAVIOR which is used to parameterize the type. This can be useful for specifying different behaviors or properties for different instances of EmptyArray.

      Inheritance:

      • <: LeafType{BEHAVIOR}: This indicates that EmptyArray is a subtype of LeafType with the same BEHAVIOR parameter.

      Field:

      • behavior::Symbol: This field stores a Symbol indicating the behavior of the empty array. A Symbol in Julia is a type that represents interned strings and is often used for identifiers and labels.

      Constructor:

      function EmptyArray(; behavior::Symbol = :default): This is an inner constructor that allows for the creation of EmptyArray instances. The behavior argument is optional and defaults to :default if not provided. new{behavior}(behavior): The new function is used to create an instance of EmptyArray with the specified behavior. The {behavior} syntax is used to pass the type parameter to the instance.

      source
      AwkwardArray.IndexedArray — Type
      IndexedArray{INDEX<:IndexBig,CONTENT<:Content,BEHAVIOR} <: Content{BEHAVIOR}

      IndexedArray represents an array that references its elements through an index.

      struct IndexedArray{INDEX<:IndexBig, CONTENT<:Content, BEHAVIOR} <: Content{BEHAVIOR}
+end

      Type Parameter:

      • {BEHAVIOR}: The EmptyArray type has a parameter BEHAVIOR which is used to parameterize the type. This can be useful for specifying different behaviors or properties for different instances of EmptyArray.

      Inheritance:

      • <: LeafType{BEHAVIOR}: This indicates that EmptyArray is a subtype of LeafType with the same BEHAVIOR parameter.

      Field:

      • behavior::Symbol: This field stores a Symbol indicating the behavior of the empty array. A Symbol in Julia is a type that represents interned strings and is often used for identifiers and labels.

      Constructor:

      function EmptyArray(; behavior::Symbol = :default): This is an inner constructor that allows for the creation of EmptyArray instances. The behavior argument is optional and defaults to :default if not provided. new{behavior}(behavior): The new function is used to create an instance of EmptyArray with the specified behavior. The {behavior} syntax is used to pass the type parameter to the instance.

      source
      AwkwardArray.IndexedArray — Type
      IndexedArray{INDEX<:IndexBig,CONTENT<:Content,BEHAVIOR} <: Content{BEHAVIOR}

      IndexedArray represents an array that references its elements through an index.

      struct IndexedArray{INDEX<:IndexBig, CONTENT<:Content, BEHAVIOR} <: Content{BEHAVIOR}
     index::INDEX
     content::CONTENT
     parameters::Parameters
@@ -85,14 +85,14 @@
         behavior::Symbol = :default,
     ) where {INDEX<:IndexBig, CONTENT<:Content} =
         new{INDEX, CONTENT, behavior}(index, content, parameters)
-end

      Type Parameters:

      • {INDEX<:IndexBig, CONTENT<:Content, BEHAVIOR}: These are the type parameters for the struct.
      • INDEX<:IndexBig: INDEX must be a subtype of IndexBig.
      • CONTENT<:Content: CONTENT must be a subtype of Content.
      • BEHAVIOR: A type parameter for specifying behavior, often used for distinguishing different kinds of behaviors or properties in the array.

      Inheritance:

      • <: Content{BEHAVIOR}: This indicates that IndexedArray is a subtype of Content with the specified BEHAVIOR parameter.

      Fields:

      • index::INDEX: An index of type INDEX, which is a subtype of IndexBig.
      • content::CONTENT: The actual content of the array, of type CONTENT, which is a subtype of Content.
      • parameters::Parameters: An instance of Parameters that holds additional metadata or configuration for the array.

      Constructor:

      IndexedArray(index::INDEX, content::CONTENT; parameters::Parameters = Parameters(), behavior::Symbol = :default)

      This is an inner constructor that allows for the creation of IndexedArray instances. It takes the following arguments:

      • index: The index for the array.
      • content: The content of the array.
      • parameters: Optional parameters for the array, defaulting to a new Parameters instance.
      • behavior: An optional symbol indicating the behavior, defaulting to :default.

      @example new{INDEX, CONTENT, behavior}(index, content, parameters) The new function is used to create an instance of IndexedArray with the specified fields and type parameters.

      source
      AwkwardArray.IndexedArray — Method
      IndexedArray{INDEX,CONTENT}(;
+end

      Type Parameters:

      • {INDEX<:IndexBig, CONTENT<:Content, BEHAVIOR}: These are the type parameters for the struct.
      • INDEX<:IndexBig: INDEX must be a subtype of IndexBig.
      • CONTENT<:Content: CONTENT must be a subtype of Content.
      • BEHAVIOR: A type parameter for specifying behavior, often used for distinguishing different kinds of behaviors or properties in the array.

      Inheritance:

      • <: Content{BEHAVIOR}: This indicates that IndexedArray is a subtype of Content with the specified BEHAVIOR parameter.

      Fields:

      • index::INDEX: An index of type INDEX, which is a subtype of IndexBig.
      • content::CONTENT: The actual content of the array, of type CONTENT, which is a subtype of Content.
      • parameters::Parameters: An instance of Parameters that holds additional metadata or configuration for the array.

      Constructor:

      IndexedArray(index::INDEX, content::CONTENT; parameters::Parameters = Parameters(), behavior::Symbol = :default)

      This is an inner constructor that allows for the creation of IndexedArray instances. It takes the following arguments:

      • index: The index for the array.
      • content: The content of the array.
      • parameters: Optional parameters for the array, defaulting to a new Parameters instance.
      • behavior: An optional symbol indicating the behavior, defaulting to :default.

      @example new{INDEX, CONTENT, behavior}(index, content, parameters) The new function is used to create an instance of IndexedArray with the specified fields and type parameters.

      source
      AwkwardArray.IndexedArray — Method
      IndexedArray{INDEX,CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
 ) where {INDEX<:IndexBig} where {CONTENT<:Content}

      Constructor for the IndexedArray, allowing for the creation of an IndexedArray with default values for its components when specific instances are not provided.

      IndexedArray{INDEX, CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
 ) where {INDEX<:IndexBig} where {CONTENT<:Content} =
-    IndexedArray(INDEX([]), CONTENT(), parameters = parameters, behavior = behavior)
      source
      AwkwardArray.IndexedOptionArray — Type
      IndexedOptionArray{INDEX<:IndexBigSigned, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}

      A type of array where elements are indexed and can be optionally present or missing.

      struct IndexedOptionArray{INDEX<:IndexBigSigned, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}
+    IndexedArray(INDEX([]), CONTENT(), parameters = parameters, behavior = behavior)
      source
      AwkwardArray.IndexedOptionArray — Type
      IndexedOptionArray{INDEX<:IndexBigSigned, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}

      A type of array where elements are indexed and can be optionally present or missing.

      struct IndexedOptionArray{INDEX<:IndexBigSigned, CONTENT<:Content, BEHAVIOR} <: OptionType{BEHAVIOR}
     index::INDEX
     content::CONTENT
     parameters::Parameters
@@ -104,67 +104,67 @@
         behavior::Symbol = :default,
     ) where {INDEX<:IndexBigSigned, CONTENT<:Content} =
         new{INDEX, CONTENT, behavior}(index, content, parameters)
-end

      Type Parameters:

      • INDEX<:IndexBigSigned: The INDEX type parameter must be a subtype of IndexBigSigned.
      • CONTENT<:Content: The CONTENT type parameter must be a subtype of Content.
      • BEHAVIOR: A type parameter without constraints, allowing flexibility in specifying behavior.

      Fields:

      • index::INDEX: Holds the index values, which determine the presence or absence of elements.
      • content::CONTENT: Holds the actual data elements.
      • parameters::Parameters: Holds any additional parameters or metadata associated with the array.

      Constructor:

      The inner constructor IndexedOptionArray takes three arguments: index, content, and optionally parameters and behavior. Default values are provided for parameters (Parameters()) and behavior (:default). The constructor uses new{INDEX, CONTENT, behavior}(index, content, parameters) to create an instance of IndexedOptionArray with the specified types and values.

      Inheritance:

      <: OptionType{BEHAVIOR} means that IndexedOptionArray is a subtype of OptionType{BEHAVIOR}. This indicates that it is a specialized form of OptionType designed to handle optional or nullable data.

      source
      AwkwardArray.IndexedOptionArray — Method
      IndexedOptionArray{INDEX,CONTENT}(;
+end

      Type Parameters:

      • INDEX<:IndexBigSigned: The INDEX type parameter must be a subtype of IndexBigSigned.
      • CONTENT<:Content: The CONTENT type parameter must be a subtype of Content.
      • BEHAVIOR: A type parameter without constraints, allowing flexibility in specifying behavior.

      Fields:

      • index::INDEX: Holds the index values, which determine the presence or absence of elements.
      • content::CONTENT: Holds the actual data elements.
      • parameters::Parameters: Holds any additional parameters or metadata associated with the array.

      Constructor:

      The inner constructor IndexedOptionArray takes three arguments: index, content, and optionally parameters and behavior. Default values are provided for parameters (Parameters()) and behavior (:default). The constructor uses new{INDEX, CONTENT, behavior}(index, content, parameters) to create an instance of IndexedOptionArray with the specified types and values.

      Inheritance:

      <: OptionType{BEHAVIOR} means that IndexedOptionArray is a subtype of OptionType{BEHAVIOR}. This indicates that it is a specialized form of OptionType designed to handle optional or nullable data.

      source
      AwkwardArray.IndexedOptionArray — Method
      IndexedOptionArray{INDEX,CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {INDEX<:IndexBigSigned} where {CONTENT<:Content}

      Constructor for the IndexedOptionArray with default values for its parameters and behavior.

      source
      AwkwardArray.LeafType — Type
      LeafType{BEHAVIOR} <: Content{BEHAVIOR}

      Abstract type LeafType inherits from Content and is parameterized by BEHAVIOR.

      This allows to create a flexible and hierarchical type system where different kinds of content can be represented, and specific behaviors can be parameterized.

      Note

      All Python NumpyArrays have to be converted to 1-dimensional (inner_shape == ()) with RegularArrays when converting to Julia.

      source
      AwkwardArray.ListArray — Type
      ListArray{INDEX<:IndexBig,CONTENT<:Content,BEHAVIOR} <: ListType{BEHAVIOR}

      An array of variable-length lists, where the lengths and positions of the lists are specified by starts and stops indices.

      Type Parameters:

      • INDEX<:IndexBig: This ensures that the type INDEX is a subtype of IndexBig.
      • CONTENT<:Content: This ensures that the type CONTENT is a subtype of Content.
      • BEHAVIOR: This parameter allows for any type and is used to specify the behavior of the ListArray.

      Fields:

      • starts::INDEX: An index specifying the starting positions of the lists within the content.
      • stops::INDEX: An index specifying the stopping positions of the lists within the content.
      • content::CONTENT: The actual content of the array, which contains the elements of the lists.
      • parameters::Parameters: Additional parameters that can provide metadata or other information.

      Constructor:

      The primary constructor initializes a ListArray with given starts, stops indices, and content. parameters::Parameters = Parameters(): This sets a default value for parameters if it is not provided when the constructor is called. behavior::Symbol = :default: This sets a default value for behavior if it is not provided when the constructor is called.

      source
      AwkwardArray.ListArray — Method
      ListArray{INDEX,CONTENT,BEHAVIOR}(;
+) where {INDEX<:IndexBigSigned} where {CONTENT<:Content}

      Constructor for the IndexedOptionArray with default values for its parameters and behavior.

      source
      AwkwardArray.LeafType — Type
      LeafType{BEHAVIOR} <: Content{BEHAVIOR}

      Abstract type LeafType inherits from Content and is parameterized by BEHAVIOR.

      This allows to create a flexible and hierarchical type system where different kinds of content can be represented, and specific behaviors can be parameterized.

      Note

      All Python NumpyArrays have to be converted to 1-dimensional (inner_shape == ()) with RegularArrays when converting to Julia.

      source
      AwkwardArray.ListArray — Type
      ListArray{INDEX<:IndexBig,CONTENT<:Content,BEHAVIOR} <: ListType{BEHAVIOR}

      An array of variable-length lists, where the lengths and positions of the lists are specified by starts and stops indices.

      Type Parameters:

      • INDEX<:IndexBig: This ensures that the type INDEX is a subtype of IndexBig.
      • CONTENT<:Content: This ensures that the type CONTENT is a subtype of Content.
      • BEHAVIOR: This parameter allows for any type and is used to specify the behavior of the ListArray.

      Fields:

      • starts::INDEX: An index specifying the starting positions of the lists within the content.
      • stops::INDEX: An index specifying the stopping positions of the lists within the content.
      • content::CONTENT: The actual content of the array, which contains the elements of the lists.
      • parameters::Parameters: Additional parameters that can provide metadata or other information.

      Constructor:

      The primary constructor initializes a ListArray with given starts, stops indices, and content. parameters::Parameters = Parameters(): This sets a default value for parameters if it is not provided when the constructor is called. behavior::Symbol = :default: This sets a default value for behavior if it is not provided when the constructor is called.

      source
      AwkwardArray.ListArray — Method
      ListArray{INDEX,CONTENT,BEHAVIOR}(;
     parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig} where {CONTENT<:Content} where {BEHAVIOR}

      Constructor of a ListArray with default parameters, initializing the starts, stops and content with default values.

      source
      AwkwardArray.ListArray — Method
      ListArray{INDEX,CONTENT}(;
+) where {INDEX<:IndexBig} where {CONTENT<:Content} where {BEHAVIOR}

      Constructor of a ListArray with default parameters, initializing the starts, stops and content with default values.

      source
      AwkwardArray.ListArray — Method
      ListArray{INDEX,CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {INDEX<:IndexBig} where {CONTENT<:Content}

      Constructor of a ListArray with default parameters, initializing the starts, stops, content and behavior with default values.

      source
      AwkwardArray.ListOffsetArray — Type
      ListOffsetArray{INDEX<:IndexBig,CONTENT<:Content,BEHAVIOR} <: ListType{BEHAVIOR}

      A specialized array to represent variable-length lists within a larger array.

      Type Parameters:

      • INDEX<:IndexBig: Defines a type parameter INDEX which is constrained to subtypes of IndexBig. IndexBig typically refers to integer types capable of holding large indices, such as Int32 or Int64.

      • CONTENT<:Content: Defines a type parameter CONTENT which is constrained to subtypes of Content.

      • BEHAVIOR: A type parameter for behavior, used to define specialized behaviors or metadata associated with the array.

      Inheritance:

      • <: ListType{BEHAVIOR}: Indicates that ListOffsetArray is a subtype of ListType.

      Fields:

      • offsets::INDEX: An array of offsets that indicate the start of each sublist within the content array. The length of this array is one more than the number of sublists, with the last element pointing to the end of the last sublist.

      • content::CONTENT: The actual data stored in the array. This can be any kind of array or list of elements.

      • parameters::Parameters: A structure to hold additional parameters or metadata associated with the array.

      source
      AwkwardArray.ListOffsetArray — Method
      ListOffsetArray{INDEX,CONTENT,BEHAVIOR}(;
+) where {INDEX<:IndexBig} where {CONTENT<:Content}

      Constructor of a ListArray with default parameters, initializing the starts, stops, content and behavior with default values.

      source
      AwkwardArray.ListOffsetArray — Type
      ListOffsetArray{INDEX<:IndexBig,CONTENT<:Content,BEHAVIOR} <: ListType{BEHAVIOR}

      A specialized array to represent variable-length lists within a larger array.

      Type Parameters:

      • INDEX<:IndexBig: Defines a type parameter INDEX which is constrained to subtypes of IndexBig. IndexBig typically refers to integer types capable of holding large indices, such as Int32 or Int64.

      • CONTENT<:Content: Defines a type parameter CONTENT which is constrained to subtypes of Content.

      • BEHAVIOR: A type parameter for behavior, used to define specialized behaviors or metadata associated with the array.

      Inheritance:

      • <: ListType{BEHAVIOR}: Indicates that ListOffsetArray is a subtype of ListType.

      Fields:

      • offsets::INDEX: An array of offsets that indicate the start of each sublist within the content array. The length of this array is one more than the number of sublists, with the last element pointing to the end of the last sublist.

      • content::CONTENT: The actual data stored in the array. This can be any kind of array or list of elements.

      • parameters::Parameters: A structure to hold additional parameters or metadata associated with the array.

      source
      AwkwardArray.ListOffsetArray — Method
      ListOffsetArray{INDEX,CONTENT,BEHAVIOR}(;
     parameters::Parameters = Parameters(),
-) where {INDEX<:IndexBig} where {CONTENT<:Content} where {BEHAVIOR}

      Constructor of a ListOffsetArray with default parameters, initializing the offsets and content with default values.

      source
      AwkwardArray.ListOffsetArray — Method
      ListOffsetArray{INDEX,CONTENT}(;
+) where {INDEX<:IndexBig} where {CONTENT<:Content} where {BEHAVIOR}

      Constructor of a ListOffsetArray with default parameters, initializing the offsets and content with default values.

      source
      AwkwardArray.ListOffsetArray — Method
      ListOffsetArray{INDEX,CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {INDEX<:IndexBig} where {CONTENT<:Content}

      Constructor of a ListOffsetArray with default parameters, initializing the offsets, content and behavior with default values.

      source
      AwkwardArray.ListType — Type
      ListType{BEHAVIOR} <: Content{BEHAVIOR}

      Abstract type ListType inherits from Content and is parameterized by BEHAVIOR.

      source
      AwkwardArray.OptionType — Type
      OptionType{BEHAVIOR} <: Content{BEHAVIOR}

      Abstract type that serves as a base for other types representing optional or nullable data.

      source
      AwkwardArray.Parameters — Type
      Parameters
      source
      AwkwardArray.Parameters — Method
      Parameters(pairs::Vararg{Pair{String,<:Any}})
      source
      AwkwardArray.Parameters — Method
      Parameters()
      source
      AwkwardArray.PrimitiveArray — Type
      PrimitiveArray{ITEM,BUFFER<:AbstractVector{ITEM},BEHAVIOR} <: LeafType{BEHAVIOR}

      A specialized array type designed to handle primitive data types with additional parameters and behaviors.

      Type Parameters:

      • ITEM: Represents the type of the elements stored in the array.

      • BUFFER<:AbstractVector{ITEM}: Constrains BUFFER to be a subtype of AbstractVector that holds items of type ITEM.

      • BEHAVIOR: A type parameter that can represent different behaviors associated with the array.

      Inheritance:

      • <: LeafType{BEHAVIOR}: Indicates that PrimitiveArray is a subtype of LeafType parameterized by BEHAVIOR.

      Fields:

      • data::BUFFER: The main storage for the array, constrained to be an AbstractVector of ITEM.

      • parameters::Parameters: Additional parameters associated with the array, presumably defined elsewhere in the code.

      Constructor:

      • PrimitiveArray(data::BUFFER; parameters::Parameters = Parameters(), behavior::Symbol = :default) where {ITEM,BUFFER<:AbstractVector{ITEM}}: This is the inner constructor for the PrimitiveArray struct. It initializes a new instance of PrimitiveArray with the given data and optional parameters and behavior. The where {ITEM,BUFFER<:AbstractVector{ITEM}} clause ensures that ITEM and BUFFER satisfy the specified constraints.

      new{ITEM,BUFFER,behavior}(data, parameters) creates a new instance of PrimitiveArray with the specified type parameters and field values.

      source
      AwkwardArray.PrimitiveArray — Method
      PrimitiveArray{ITEM,BUFFER,BEHAVIOR}(;
+) where {INDEX<:IndexBig} where {CONTENT<:Content}

      Constructor of a ListOffsetArray with default parameters, initializing the offsets, content and behavior with default values.

      source
      AwkwardArray.ListType — Type
      ListType{BEHAVIOR} <: Content{BEHAVIOR}

      Abstract type ListType inherits from Content and is parameterized by BEHAVIOR.

      source
      AwkwardArray.OptionType — Type
      OptionType{BEHAVIOR} <: Content{BEHAVIOR}

      Abstract type that serves as a base for other types representing optional or nullable data.

      source
      AwkwardArray.Parameters — Type
      Parameters
      source
      AwkwardArray.Parameters — Method
      Parameters(pairs::Vararg{Pair{String,<:Any}})
      source
      AwkwardArray.Parameters — Method
      Parameters()
      source
      AwkwardArray.PrimitiveArray — Type
      PrimitiveArray{ITEM,BUFFER<:AbstractVector{ITEM},BEHAVIOR} <: LeafType{BEHAVIOR}

      A specialized array type designed to handle primitive data types with additional parameters and behaviors.

      Type Parameters:

      • ITEM: Represents the type of the elements stored in the array.

      • BUFFER<:AbstractVector{ITEM}: Constrains BUFFER to be a subtype of AbstractVector that holds items of type ITEM.

      • BEHAVIOR: A type parameter that can represent different behaviors associated with the array.

      Inheritance:

      • <: LeafType{BEHAVIOR}: Indicates that PrimitiveArray is a subtype of LeafType parameterized by BEHAVIOR.

      Fields:

      • data::BUFFER: The main storage for the array, constrained to be an AbstractVector of ITEM.

      • parameters::Parameters: Additional parameters associated with the array, presumably defined elsewhere in the code.

      Constructor:

      • PrimitiveArray(data::BUFFER; parameters::Parameters = Parameters(), behavior::Symbol = :default) where {ITEM,BUFFER<:AbstractVector{ITEM}}: This is the inner constructor for the PrimitiveArray struct. It initializes a new instance of PrimitiveArray with the given data and optional parameters and behavior. The where {ITEM,BUFFER<:AbstractVector{ITEM}} clause ensures that ITEM and BUFFER satisfy the specified constraints.

      new{ITEM,BUFFER,behavior}(data, parameters) creates a new instance of PrimitiveArray with the specified type parameters and field values.

      source
      AwkwardArray.PrimitiveArray — Method
      PrimitiveArray{ITEM,BUFFER,BEHAVIOR}(;
     parameters::Parameters = Parameters(),
-) where {ITEM,BUFFER<:AbstractVector{ITEM},BEHAVIOR}
      source
      AwkwardArray.PrimitiveArray — Method
      PrimitiveArray{ITEM,BUFFER}(;
+) where {ITEM,BUFFER<:AbstractVector{ITEM},BEHAVIOR}
      source
      AwkwardArray.PrimitiveArray — Method
      PrimitiveArray{ITEM,BUFFER}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {ITEM,BUFFER<:AbstractVector{ITEM}}
      source
      AwkwardArray.PrimitiveArray — Method
      PrimitiveArray{ITEM}(;
+) where {ITEM,BUFFER<:AbstractVector{ITEM}}
      source
      AwkwardArray.PrimitiveArray — Method
      PrimitiveArray{ITEM}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {ITEM}
      source
      AwkwardArray.Record — Type
      Record{FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
      source
      AwkwardArray.RecordArray — Type
      RecordArray{FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR} <:Content{BEHAVIOR}
      source
      AwkwardArray.RecordArray — Method
      RecordArray(
+) where {ITEM}
      source
      AwkwardArray.Record — Type
      Record{FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
      source
      AwkwardArray.RecordArray — Type
      RecordArray{FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR} <:Content{BEHAVIOR}
      source
      AwkwardArray.RecordArray — Method
      RecordArray(
     contents::NamedTuple{FIELDS,CONTENTS};
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.RecordArray — Method
      RecordArray{FIELDS,CONTENTS}(;
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.RecordArray — Method
      RecordArray{FIELDS,CONTENTS}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.RegularArray — Type
      RegularArray{CONTENT<:Content,BEHAVIOR} <: ListType{BEHAVIOR}

      A multidimensional array with a fixed size for each dimension, where the overall length of the array is determined by the size of its content and the specified size per dimension.

      Type Parameters:

      • CONTENT<:Content: Ensures that the type CONTENT is a subtype of Content.
      • BEHAVIOR: This parameter can be any type and is used to specify the behavior of the RegularArray.

      Fields:

      • content::CONTENT: The actual content of the array, which contains the elements.
      • size::Int64: The fixed size for each dimension of the array.
      • length::Int64: The total length of the array, calculated based on the content length and size.
      • parameters::Parameters: Additional parameters that can provide metadata or other information.

      Constructor:

      The constructor initializes a RegularArray with the given content and size. zeros_length::Int = 0: This sets a default value for the zeros_length parameter if it is not provided. parameters::Parameters = Parameters(): This sets a default value for parameters if it is not provided. behavior::Symbol = :default: This sets a default value for behavior if it is not provided. The length of the array is calculated as zeros_length if size is 0, otherwise it is calculated as the integer division of the length of content by size.

      source
      AwkwardArray.RegularArray — Method
      RegularArray{CONTENT}(
+) where {FIELDS,CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.RegularArray — Type
      RegularArray{CONTENT<:Content,BEHAVIOR} <: ListType{BEHAVIOR}

      A multidimensional array with a fixed size for each dimension, where the overall length of the array is determined by the size of its content and the specified size per dimension.

      Type Parameters:

      • CONTENT<:Content: Ensures that the type CONTENT is a subtype of Content.
      • BEHAVIOR: This parameter can be any type and is used to specify the behavior of the RegularArray.

      Fields:

      • content::CONTENT: The actual content of the array, which contains the elements.
      • size::Int64: The fixed size for each dimension of the array.
      • length::Int64: The total length of the array, calculated based on the content length and size.
      • parameters::Parameters: Additional parameters that can provide metadata or other information.

      Constructor:

      The constructor initializes a RegularArray with the given content and size. zeros_length::Int = 0: This sets a default value for the zeros_length parameter if it is not provided. parameters::Parameters = Parameters(): This sets a default value for parameters if it is not provided. behavior::Symbol = :default: This sets a default value for behavior if it is not provided. The length of the array is calculated as zeros_length if size is 0, otherwise it is calculated as the integer division of the length of content by size.

      source
      AwkwardArray.RegularArray — Method
      RegularArray{CONTENT}(
     size::Int;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {CONTENT<:Content}

      Constructor of a RegularArray with default parameters, initializing the behavior and content with default values.

      source
      AwkwardArray.RegularArray — Method
      RegularArray{CONTENT,BEHAVIOR}(;
+) where {CONTENT<:Content}

      Constructor of a RegularArray with default parameters, initializing the behavior and content with default values.

      source
      AwkwardArray.RegularArray — Method
      RegularArray{CONTENT,BEHAVIOR}(;
     parameters::Parameters = Parameters(),
-) where {CONTENT<:Content,BEHAVIOR}

      Constructor of a RegularArray with default parameters, initializing the size and content with default values.

      source
      AwkwardArray.RegularArray — Method
      RegularArray{CONTENT}(;
+) where {CONTENT<:Content,BEHAVIOR}

      Constructor of a RegularArray with default parameters, initializing the size and content with default values.

      source
      AwkwardArray.RegularArray — Method
      RegularArray{CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {CONTENT<:Content}

      Constructor of a RegularArray with default parameters, initializing the size, behavior and content with default values.

      source
      AwkwardArray.SlotRecord — Type
      SlotRecord{CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
      source
      AwkwardArray.Specialization — Type
      Specialization{ARRAY<:UnionArray,TAGGED<:Content}
      source
      AwkwardArray.Specialization — Method
      Specialization(layout::UnionArray, tag::Int)
      source
      AwkwardArray.TupleArray — Type
      TupleArray{CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR} <:
-            Content{BEHAVIOR}
      source
      AwkwardArray.TupleArray — Method
      TupleArray(
+) where {CONTENT<:Content}

      Constructor of a RegularArray with default parameters, initializing the size, behavior and content with default values.

      source
      AwkwardArray.SlotRecord — Type
      SlotRecord{CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR}
      source
      AwkwardArray.Specialization — Type
      Specialization{ARRAY<:UnionArray,TAGGED<:Content}
      source
      AwkwardArray.Specialization — Method
      Specialization(layout::UnionArray, tag::Int)
      source
      AwkwardArray.TupleArray — Type
      TupleArray{CONTENTS<:Base.Tuple{Vararg{Content}},BEHAVIOR} <:
+            Content{BEHAVIOR}
      source
      AwkwardArray.TupleArray — Method
      TupleArray(
     contents::CONTENTS;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.TupleArray — Method
      TupleArray{CONTENTS}(;
+) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.TupleArray — Method
      TupleArray{CONTENTS}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.UnionArray — Type
      UnionArray{
+) where {CONTENTS<:Base.Tuple{Vararg{Content}}}
      source
      AwkwardArray.UnionArray — Type
      UnionArray{
     TAGS<:Index8,
     INDEX<:IndexBig,
     CONTENTS<:Base.Tuple{Vararg{Content}},
     BEHAVIOR,
-} <: Content{BEHAVIOR}
      source
      AwkwardArray.UnionArray — Method
      UnionArray{TAGS,INDEX,CONTENTS}(
+} <: Content{BEHAVIOR}
      source
      AwkwardArray.UnionArray — Method
      UnionArray{TAGS,INDEX,CONTENTS}(
     contents::CONTENTS;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-)
      source
      AwkwardArray.UnionArray — Method
      UnionArray{TAGS,INDEX,CONTENTS}(;
+)
      source
      AwkwardArray.UnionArray — Method
      UnionArray{TAGS,INDEX,CONTENTS}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-)
      source
      AwkwardArray.UnmaskedArray — Type
      UnmaskedArray{CONTENT<:Content,BEHAVIOR} <: OptionType{BEHAVIOR}
      source
      AwkwardArray.UnmaskedArray — Method
      UnmaskedArray{CONTENT}(;
+)
      source
      AwkwardArray.UnmaskedArray — Type
      UnmaskedArray{CONTENT<:Content,BEHAVIOR} <: OptionType{BEHAVIOR}
      source
      AwkwardArray.UnmaskedArray — Method
      UnmaskedArray{CONTENT}(;
     parameters::Parameters = Parameters(),
     behavior::Symbol = :default,
-) where {CONTENT<:Content}
      source

      Examples

      julia> using AwkwardArray: StringOffsetArray
+) where {CONTENT<:Content}
      source

      Examples

      julia> using AwkwardArray: StringOffsetArray
 
 julia> array = StringOffsetArray()
 0-element ListOffsetArray{Vector{Int64}, PrimitiveArray{UInt8, Vector{UInt8}, :char}, :string}
@@ -181,4 +181,4 @@
 "three"
 
 julia> typeof(array[3])
-String

      Most applications of behavior apply to RecordArrays (e.g. Vector in Python).

      Index

      +String

      Most applications of behavior apply to RecordArrays (e.g. Vector in Python).

      Index