remove more unnecessary code

Author: JonasIsensee

docs/make.jl

@@ -20,7 +20,7 @@ makedocs(;
         "Internals & Design" => "internals.md",
         "HDF5 Compatibility" => "hdf5compat.md",
         "Advanced Usage" => "advanced.md",
-        "Dataset Links" => "external_links.md"
+        "Dataset Links" => "external_links.md",
         "Legacy" => "legacy.md",
         "Troubleshooting" => "troubleshooting.md"
     ],

docs/src/external_links.md

@@ -1,6 +1,6 @@
 # External Links and Soft Links in JLD2
 
-JLD2 now supports external links and soft links, enabling cross-file references and flexible file organization patterns. This feature is fully compatible with the HDF5 specification and standard HDF5 tools.
+JLD2 supports external links and soft links, enabling cross-file references and flexible file organization patterns. This feature is fully compatible with the HDF5 specification and standard HDF5 tools.
 
 ## Overview
 
@@ -10,35 +10,6 @@ JLD2 supports three types of links:
 - **Soft Links**: Path-based references resolved at access time within the same file
 - **External Links**: References to objects in different HDF5/JLD2 files
 
-## Quick Start
-
-### Creating External Links
-
-```julia
-using JLD2
-
-# Create an external data file
-jldsave("data.jld2";
-        temperature=[23.5, 24.1, 22.8, 25.3],
-        pressure=[1013.2, 1012.8, 1014.1, 1013.5])
-
-# Create main file with external link
-jldopen("main.jld2", "w") do f
-    f["local_data"] = [1, 2, 3, 4, 5]
-
-    # Create external links
-    create_external_link!(f, "external_temp", "data.jld2", "/temperature")
-    create_external_link!(f, "external_pressure", "data.jld2", "/pressure")
-end
-
-# Access external data transparently
-jldopen("main.jld2", "r") do f
-    local_data = f["local_data"]           # [1, 2, 3, 4, 5]
-    external_temp = f["external_temp"]     # [23.5, 24.1, 22.8, 25.3]
-    external_press = f["external_pressure"] # [1013.2, 1012.8, 1014.1, 1013.5]
-end
-```
-
 ### Creating Soft Links
 
 ```julia
@@ -60,173 +31,29 @@ jldopen("example.jld2", "r") do f
 end
 ```
 
-## API Reference
-
-### External Links
-
-#### `create_external_link!(file_or_group, name, external_file, object_path)`
-
-Create an external link pointing to an object in another file.
-
-**Parameters:**
-- `file_or_group`: JLDFile or Group to create the link in
-- `name`: Name for the new link
-- `external_file`: Path to the external HDF5/JLD2 file
-- `object_path`: Path to the object within the external file (should start with "/")
-
-**Example:**
-```julia
-jldopen("main.jld2", "w") do f
-    create_external_link!(f, "remote_data", "../shared/data.jld2", "/measurements/temperature")
-end
-```
-
-### Soft Links
-
-#### `create_soft_link!(file_or_group, name, target_path)`
-
-Create a soft link pointing to a path within the same file.
-
-**Parameters:**
-- `file_or_group`: JLDFile or Group to create the link in
-- `name`: Name for the new link
-- `target_path`: Path to the target object (absolute path starting with "/")
-
-**Example:**
-```julia
-jldopen("data.jld2", "w") do f
-    f["original_data"] = [1, 2, 3]
-    create_soft_link!(f, "data_shortcut", "/original_data")
-end
-```
-
-## Advanced Usage
-
-### Working with Groups
-
-```julia
-jldopen("structured.jld2", "w") do f
-    # Create nested structure
-    exp_group = JLD2.Group(f, "experiment")
-    data_group = JLD2.Group(exp_group, "data")
-    results_group = JLD2.Group(exp_group, "results")
-
-    data_group["raw"] = collect(1:100)
-    results_group["processed"] = collect(1:100) .^ 2
-
-    # Create soft links for easier access
-    create_soft_link!(f, "raw_data", "/experiment/data/raw")
-    create_soft_link!(f, "final_results", "/experiment/results/processed")
-
-    # External link to shared calibration data
-    create_external_link!(f, "calibration", "calibration.jld2", "/standard_curve")
-end
-```
-
-### Cross-File Data Workflows
+### Creating External Links
 
 ```julia
-# Step 1: Create base data
-jldsave("measurements.jld2";
-        voltage=[1.2, 1.5, 1.8, 2.1],
-        current=[0.1, 0.2, 0.3, 0.4])
-
-# Step 2: Create analysis file with external links
-jldopen("analysis.jld2", "w") do f
-    # Link to external measurements
-    create_external_link!(f, "voltage_data", "measurements.jld2", "/voltage")
-    create_external_link!(f, "current_data", "measurements.jld2", "/current")
-
-    # Process the external data and save results locally
-    voltage = f["voltage_data"]  # Transparently loads from external file
-    current = f["current_data"]
-
-    f["resistance"] = voltage ./ current
-    f["power"] = voltage .* current
-
-    # Create soft links to results
-    create_soft_link!(f, "R", "/resistance")
-    create_soft_link!(f, "P", "/power")
-end
-
-# Step 3: Access everything through high-level API
-results = load("analysis.jld2")
-# results contains: voltage_data, current_data, resistance, power, R, P
-```
+using JLD2
 
-### Error Handling
+# Create an external data file
+jldsave("data.jld2";
+        temperature=[23.5, 24.1, 22.8, 25.3],
+        pressure=[1013.2, 1012.8, 1014.1, 1013.5])
 
-```julia
+# Create main file with external link
 jldopen("main.jld2", "w") do f
-    try
-        # This will fail if the external file doesn't exist
-        create_external_link!(f, "missing", "nonexistent.jld2", "/data")
-    catch e
-        println("External link creation failed: $e")
-    end
-
-    try
-        # This will fail if accessed and the path doesn't exist
-        create_soft_link!(f, "broken", "/nonexistent/path")
-        f["broken"]  # Error occurs here during access
-    catch e
-        println("Soft link resolution failed: $e")
-    end
-end
-```
-
-## Performance Characteristics
-
-- **Hard Links**: ~0.03ms per access (baseline)
-- **Soft Links**: ~0.001ms per access (cached resolution)
-- **External Links**: ~0.2ms per access (with file handle caching)
-- **External File Caching**: 200-300x speedup for repeated access to same external file
-
-## HDF5 Tool Compatibility
-
-Files with external and soft links are fully compatible with standard HDF5 tools:
-
-```bash
-# View file structure showing links
-h5dump -H main.jld2
-
-# Access data through external links
-h5dump -d /external_temp main.jld2
-
-# Validate file structure
-h5debug main.jld2
-```
-
-## Security Considerations
-
-- **Path Validation**: External file paths are validated to prevent directory traversal attacks
-- **Relative Paths**: External links support relative paths resolved from the current file's directory
-- **Access Control**: Optional access policies can be configured for production environments
-
-## Best Practices
-
-1. **Use Relative Paths**: When possible, use relative paths for external links to make file sets portable
-2. **Error Handling**: Always handle potential errors when accessing external links
-3. **File Organization**: Use external links to create modular data workflows
-4. **Performance**: External links are cached automatically - no manual optimization needed
-5. **HDF5 Compatibility**: Files with links can be read by any HDF5-compatible tool
-
-## Migration from Hard Links
-
-Existing JLD2 code continues to work unchanged. To add link features:
+    f["local_data"] = [1, 2, 3, 4, 5]
 
-```julia
-# Before (hard links only)
-jldopen("data.jld2", "w") do f
-    f["dataset"] = data
+    # Create external links
+    create_external_link!(f, "external_temp", "data.jld2", "/temperature")
+    create_external_link!(f, "external_pressure", "data.jld2", "/pressure")
 end
 
-# After (with links for better organization)
-jldopen("data.jld2", "w") do f
-    f["raw_dataset"] = data
-    create_soft_link!(f, "dataset", "/raw_dataset")  # Alias for compatibility
-    create_external_link!(f, "reference", "standards.jld2", "/reference_data")
+# Access external data transparently
+jldopen("main.jld2", "r") do f
+    local_data = f["local_data"]           # [1, 2, 3, 4, 5]
+    external_temp = f["external_temp"]     # [23.5, 24.1, 22.8, 25.3]
+    external_press = f["external_pressure"] # [1013.2, 1012.8, 1014.1, 1013.5]
 end
 ```
-
-External links and soft links provide powerful tools for organizing complex data workflows while maintaining full backward compatibility with existing JLD2 code.

src/JLD2.jl

@@ -184,7 +184,7 @@ function jldopen(fname::AbstractString, wr::Bool, create::Bool, truncate::Bool,
     parallel_read::Bool=false,
     plain::Bool=false
 ) where T<:Union{Type{IOStream},Type{MmapIO}}
-  
+
     mmaparrays && @warn "mmaparrays keyword is currently ignored" maxlog = 1
     filters = Filters.normalize_filters(compress)
 
@@ -510,7 +510,6 @@ end
 
 include("object_headers.jl")
 include("headermessages.jl")
-include("path_resolution.jl")
 include("external_files.jl")
 include("groups.jl")
 include("dataspaces.jl")

src/explicit_datasets.jl

@@ -307,11 +307,8 @@ function get_dataset(g::Group, name::String)
             "Use f[\"", name, "\"] to access the external data directly."
         )))
     elseif isa(link, SoftLink)
-        # For soft links, check if they point to a regular dataset within the same file
-        resolved_path = resolve_soft_link_path(group_path(g), link.path)
-        # Use lookup_link for the resolved path as well to be consistent
-        target_link = lookup_link(f.root_group, resolved_path[2:end])  # Remove leading '/'
-        if target_link !== nothing && isa(target_link, HardLink)
+        target_link = lookup_link(g, link.path)
+        if isa(target_link, HardLink)
             # This is a soft link to a regular dataset within the same file - allow it
             return get_dataset(f, target_link.target, g, name)
         else
@@ -379,23 +376,21 @@ write_header_message(io, f, msg::Pair{String, AbstractLink}, _=nothing) =
 
 Calculate the size of a link message for the given link type.
 """
-function message_size_for_link(name::String, link::AbstractLink)
-    if isa(link, HardLink)
-        return jlsizeof(Val(HmLinkMessage); link_name=name)
-    elseif isa(link, SoftLink)
-        soft_link_data = Vector{UInt8}(link.path)
-        flags = UInt8(0x10 | 0x08 | size_flag(sizeof(name)))  # 0x08 = bit 3 set
-        return jlsizeof(Val(HmLinkMessage); link_name=name, flags=flags,
-                       link_type=UInt8(1), link_info_size=UInt16(length(soft_link_data)),
-                       soft_link=soft_link_data)
+function message_size_for_link(link_name::String, link::AbstractLink)
+    isa(link, HardLink) && return jlsizeof(Val(HmLinkMessage); link_name)
+
+    flags = UInt8(0x10 | 0x08 | size_flag(sizeof(link_name)))
+    if isa(link, SoftLink)
+        return jlsizeof(Val(HmLinkMessage); link_name, flags,
+                       link_type=UInt8(1),
+                       link_info_size=sizeof(link.path),
+                       soft_link=UInt8[])
     elseif isa(link, ExternalLink)
         # External link data: two null-terminated strings
-        external_data = vcat(0x00, Vector{UInt8}(link.file_path), 0x00,
-                            Vector{UInt8}(link.object_path), 0x00)
-        flags = UInt8(0x10 | 0x08 | size_flag(sizeof(name)))  # 0x08 = bit 3 set
-        return jlsizeof(Val(HmLinkMessage); link_name=name, flags=flags,
-                       link_type=UInt8(64), link_info_size=UInt16(length(external_data)),
-                       external_link=external_data)
+        return jlsizeof(Val(HmLinkMessage); link_name, flags,
+                       link_type=UInt8(64),
+                       link_info_size=3+sizeof(link.file_path)+sizeof(link.object_path),
+                       external_link=UInt8[])
     else
         throw(UnsupportedFeatureException("Unsupported link type: $(typeof(link))"))
     end
@@ -406,27 +401,20 @@ end
 
 Write a link message for the given link type to the I/O stream.
 """
-function write_link_message(io, name::String, link::AbstractLink)
+function write_link_message(io, link_name::String, link::AbstractLink)
     if isa(link, HardLink)
-        write_header_message(io, Val(HmLinkMessage); link_name=name, target=link.target)
-    elseif isa(link, SoftLink)
-        soft_link_data = Vector{UInt8}(link.path)
-        # Set flags with bit 3 to indicate link_type is present
-        flags = UInt8(0x10 | 0x08 | size_flag(sizeof(name)))  # 0x08 = bit 3 set
-        write_header_message(io, Val(HmLinkMessage); link_name=name, flags=flags,
-                           link_type=UInt8(1), link_info_size=UInt16(length(soft_link_data)),
-                           soft_link=soft_link_data)
+        return write_header_message(io, Val(HmLinkMessage); link_name, link.target)
+    end
+    flags = UInt8(0x10 | 0x08 | size_flag(sizeof(link_name)))
+    if isa(link, SoftLink)
+        soft_link = Vector{UInt8}(link.path)
+        write_header_message(io, Val(HmLinkMessage); link_name, flags, link_type=1, soft_link)
     elseif isa(link, ExternalLink)
         # External link data: two null-terminated strings
-        external_data = vcat(0x00, Vector{UInt8}(link.file_path), 0x00,
+        external_link = vcat(0x00, Vector{UInt8}(link.file_path), 0x00,
                             Vector{UInt8}(link.object_path), 0x00)
-        # Set flags with bit 3 to indicate link_type is present
-        flags = UInt8(0x10 | 0x08 | size_flag(sizeof(name)))  # 0x08 = bit 3 set
-        write_header_message(io, Val(HmLinkMessage); link_name=name, flags=flags,
-                           link_type=UInt8(64), link_info_size=UInt16(length(external_data)),
-                           external_link=external_data)
-    else
-        throw(UnsupportedFeatureException("Unsupported link type: $(typeof(link))"))
+        write_header_message(io, Val(HmLinkMessage); link_name, flags, link_type=64,
+                           external_link)
     end
 end