feat: ADR parsing

Author: Beforerr

src/CommonDataFormat.jl

@@ -7,13 +7,10 @@ export Majority, CompressionType, DataType
 
 include("enums.jl")
 include("parsing.jl")
-include("records.jl")
+include("records/records.jl")
 include("variable.jl")
 include("attribute.jl")
 include("dataset.jl")
-include("loading/cdr.jl")
-include("loading/gdr.jl")
-include("loading/vdr.jl")
 include("loading/vxr.jl")
 include("loading/vvr.jl")
 include("loading/variable.jl")

src/dataset.jl

@@ -25,7 +25,7 @@ function CDFDataset(filename)
         compression_bytes = read_be(io, UInt32)
         compression = CompressionType(compression_bytes)
         RecordSizeType = is_cdf_v3(magic_bytes) ? UInt64 : UInt32
-        # Parse CDF header to extract version, majority, and compression
+        # Parse CDF header
         cdr = CDR(io, 8, RecordSizeType)
         gdr = GDR(io, cdr.gdr_offset, RecordSizeType)
         return CDFDataset{compression, RecordSizeType}(filename, cdr, gdr)
@@ -40,6 +40,10 @@ function Base.getproperty(cdf::CDFDataset{CT}, name::Symbol) where {CT}
         return Majority(cdf.cdr)
     elseif name === :compression
         return CT
+    elseif name === :adr
+        return open(cdf.filename, "r") do io
+            return ADR(io, cdf.gdr.ADRhead, recordsize_type(cdf))
+        end
     else
         return getfield(cdf, name)
     end
@@ -54,7 +58,7 @@ function Base.getindex(cdf::CDFDataset, var_name::String)
         vdr = nothing
         for current_offset in (gdr.rVDRhead, gdr.zVDRhead)
             while current_offset != 0
-                _vdr = load_zVDR(io, current_offset, RecordSizeType)
+                _vdr = zVDR(io, current_offset, RecordSizeType)
                 if _vdr.name == var_name
                     vdr = _vdr
                     break
@@ -66,32 +70,11 @@ function Base.getindex(cdf::CDFDataset, var_name::String)
 
         isnothing(vdr) && throw(KeyError(var_name))
 
-        # Determine dimensions based on variable type
-        dimensions = if vdr.z_num_dims > 0
-            # Z-variable - use its own dimensions
-            collect(Int, vdr.z_dim_sizes)
-        else
-            # R-variable - use GDR dimensions (if any)
-            if length(gdr.r_dim_sizes) > 0
-                collect(Int, gdr.r_dim_sizes)
-            else
-                [1]  # Scalar
-            end
-        end
-
         # Calculate number of records
-        num_records = vdr.max_rec >= 0 ? vdr.max_rec + 1 : 0
-
         data = load_variable_data(io, vdr, RecordSizeType, gdr.r_dim_sizes, cdf.cdr.encoding)
 
         # Create and return CDFVariable
-        return CDFVariable(
-            var_name,
-            data,
-            DataType(vdr.data_type),
-            dimensions,
-            num_records,
-        )
+        return CDFVariable(var_name, data, vdr)
     end
 end
 
@@ -116,3 +99,12 @@ function Base.keys(cdf::CDFDataset)
 end
 
 Base.haskey(cdf::CDFDataset, var_name::String) = var_name in keys(cdf)
+
+# CommonDataModel.jl Interface
+function attribnames(cdf::CDFDataset)
+    return open(cdf.filename, "r") do io
+        gdr = cdf.gdr
+        adr = ADR(io, gdr.ADRhead, recordsize_type(cdf))
+        return adr.attrib_names
+    end
+end

src/loading/cdr.jl

@@ -0,0 +1,43 @@
+"""
+Attribute Descriptor Record (ADR)
+
+Contains a description of an attribute in a CDF. There will be one ADR per attribute. The ADRhead field of the ADR contains the file offset of the first ADR.
+"""
+struct ADR <: Record
+    header::Header
+    ADRnext::Int64    # Offset to next ADR in chain
+    AgrEDRhead::Int64    # The offset of the first Attribute g/rEntry Descriptor Record (AgrEDR) for this attribute.
+    Scope::Int32     # Offset to first attribute descriptor record
+    Num::Int32          # Attribute number
+    NgrEntries::Int32      # Number of r-variables
+    MAXgrEntry::Int32     # Number of attributes
+    rfuA::Int32        # Reserved field A
+    AzEDRhead::Int64   # The offset of the first Attribute zEntry Descriptor Record (AzEDR) for this attribute.
+    NzEntries::Int32      # Number of z-variables
+    MAXzEntry::Int32     # Number of z-entries
+    rfuE::Int32        # Reserved field E
+    Name::String
+end
+
+"""
+    ADR(io::IO, RecordSizeType)
+
+Load an Attribute Descriptor Record from the IO stream at the specified offset.
+"""
+function ADR(io::IO, RecordSizeType)
+    # Read header
+    header = Header(io, RecordSizeType)
+    @assert header.record_type == 4
+
+    # Read ADR fields
+    ADRnext = read_be(io, Int64)
+    AgrEDRhead = read_be(io, Int64)
+    fields1 = read_be(io, 5, Int32)
+    az_edrhead = read_be(io, Int64)
+    fields2 = read_be(io, 3, Int32)
+    name = readname(io)
+
+    return ADR(
+        header, ADRnext, AgrEDRhead, fields1..., az_edrhead, fields2..., name
+    )
+end

src/loading/gdr.jl

@@ -0,0 +1,38 @@
+"""
+CDF Descriptor Record (CDR) - the main file header record
+Contains version, encoding, format information, and pointer to GDR
+"""
+struct CDR <: Record
+    header::Header
+    gdr_offset::UInt64   # Can be UssInt32 for v2, UInt64 for v3
+    version::Int32
+    release::Int32
+    encoding::Int32
+    flags::Int32
+    rfu_a::Int32       # Reserved field A
+    rfu_b::Int32       # Reserved field B
+    increment::Int32
+    identifier::Int32
+    rfu_e::Int32       # Reserved field E
+    # Note: copyright string follows but we'll handle it separately
+end
+
+version(cdr::CDR; verbose = true) = verbose ? (cdr.version, cdr.release, cdr.increment) : cdr.version
+Majority(cdr::CDR) = (cdr.flags & 0x01) != 0 ? Majority(0) : Majority(1)  # Row=0, Column=1
+is_cdf_v3(cdr::CDR) = cdr.version == 3
+
+"""
+    CDR(io::IO, RecordSizeType) -> CDR
+
+Load a CDF Descriptor Record from the IO stream at the specified offset.
+This follows the CDF specification for CDR record structure.
+"""
+@inline function CDR(io::IO, RecordSizeType)
+    # Read header
+    header = Header(io, RecordSizeType)
+    @assert header.record_type == 1 "Invalid CDR record type"
+    # Read remaining CDR fields in order as per CDF specification
+    gdr_offset = read_be(io, RecordSizeType)
+    fields = read_be(io, 9, Int32)
+    return CDR(header, gdr_offset, fields...)
+end

src/records/adr.jl

@@ -0,0 +1,47 @@
+"""
+Global Descriptor Record (GDR) - contains global information about the CDF file
+Points to variable and attribute descriptor records
+"""
+struct GDR
+    header::Header
+    rVDRhead::Int64    # Offset to first r-variable descriptor record
+    zVDRhead::Int64    # Offset to first z-variable descriptor record
+    ADRhead::Int64     # Offset to first attribute descriptor record
+    eof::Int64          # End of file offset
+    NrVars::Int32      # Number of r-variables
+    num_attr::Int32     # Number of attributes
+    r_max_rec::Int32    # Maximum record number for r-variables
+    r_num_dims::Int32   # Number of dimensions for r-variables
+    NzVars::Int32      # Number of z-variables
+    uir_head::Int64     # Unused internal record head
+    rfu_c::Int32        # Reserved field C
+    leap_second_last_updated::Int32
+    rfu_e::Int32        # Reserved field E
+    r_dim_sizes::Vector{UInt32}  # Dimension sizes for r-variables
+end
+
+
+"""
+    GDR(io::IO, RecordSizeType)
+
+Load a Global Descriptor Record from the IO stream at the specified offset.
+"""
+@inline function GDR(io::IO, RecordSizeType)
+    # Read header
+    header = Header(io, RecordSizeType)
+    @assert header.record_type == 2
+
+    # Read GDR fields
+    rvdr_head, zvdr_head, adr_head, eof = read_be(io, 4, RecordSizeType)
+    nr_vars, num_attr, r_max_rec, r_num_dims, nz_vars = read_be(io, 5, Int32)
+    uir_head = read_be(io, Int64)
+    rfu_c, leap_second_last_updated, rfu_e = read_be(io, 3, Int32)
+    # Read dimension sizes array
+    r_dim_sizes = map(i -> read_uint32_be(io), 1:r_num_dims)
+
+    return GDR(
+        header, rvdr_head, zvdr_head, adr_head, eof, nr_vars, num_attr,
+        r_max_rec, r_num_dims, nz_vars, uir_head, rfu_c,
+        leap_second_last_updated, rfu_e, r_dim_sizes
+    )
+end