sux 0.12.3

A pure Rust implementation of succinct and compressed data structures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

/*
 * SPDX-FileCopyrightText: 2025 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
 */

use std::fs;

use anyhow::Result;
use clap::Parser;
use common_traits::UnsignedInt;
use epserde::{deser::Deserialize, ser::Serialize};
use sux::{init_env_logger, prelude::*};
use value_traits::slices::SliceByValueMut;

#[derive(Parser, Debug)]
#[command(about = "Serializes a mapped rear-coded list starting from a rear-coded list and a mapping.", long_about = None)]
struct Args {
    /// A file containing an ε-serde serialized rear-coded list.
    rcl: String,
    /// An ASCII file containing the mapping, one value per line.
    map: String,
    /// A name for the ε-serde serialized mapped rear-coded list.
    dest: String,
    /// The rear-coded list is not sorted.
    #[arg(short, long, default_value_t = false)]
    unsorted: bool,
    /// Assume the map is a permutation and invert it.
    #[arg(short, long, default_value_t = false)]
    invert: bool,
}

fn main() -> Result<()> {
    init_env_logger()?;

    let args = Args::parse();

    let file = fs::read_to_string(args.map)?;

    if args.unsorted {
        unsafe {
            let rcl = <RearCodedListStr<false>>::load_full(&args.rcl)?;
            let width = rcl.len().len() as usize;

            let mut map = bit_field_vec![width => 0; rcl.len()];
            for (i, line) in file.lines().enumerate() {
                map.set_value(i, line.trim().parse::<usize>()?);
            }

            if args.invert {
                let mut inv_map = bit_field_vec![width => 0; rcl.len()];
                for (i, v) in map.iter().enumerate() {
                    inv_map.set_value(v, i);
                }

                map = inv_map;
            }

            <MappedRearCodedListStr<false>>::from_parts(rcl, map).store(&args.dest)?;
        }
    } else {
        unsafe {
            let rcl = <RearCodedListStr<true>>::load_full(&args.rcl)?;
            let width = rcl.len().len() as usize;

            let mut map = bit_field_vec![width => 0; rcl.len()];
            for (i, line) in file.lines().enumerate() {
                map.set_value(i, line.trim().parse::<usize>()?);
            }

            if args.invert {
                let mut inv_map = bit_field_vec![width => 0; rcl.len()];
                for (i, v) in map.iter().enumerate() {
                    inv_map.set_value(v, i);
                }

                map = inv_map;
            }

            <MappedRearCodedListStr<true>>::from_parts(rcl, map).store(&args.dest)?;
        }
    }

    Ok(())
}