flacenc 0.5.1

Pure rust library for embedding FLAC encoder in your application.
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

// Copyright 2023-2024 Google LLC
// Copyright 2025- flacenc-rs developers
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! Utility for loop-unrolling.

use std::convert::Infallible;
use std::error::Error;

use seq_macro::seq;

macro_rules! repeat {
    ($counter:ident to $upto:expr => $body:block) => {
        <crate::repeat::Count<$upto> as crate::repeat::Repeat>::repeat(
            #[inline(always)]
            |$counter| $body,
        );
    };
    ($counter:ident to $upto:expr ; while $cond:expr => $body:block) => {
        <crate::repeat::Count<$upto> as crate::repeat::Repeat>::repeat_while(
            #[inline(always)]
            |$counter| $cond,
            #[inline(always)]
            |$counter| $body,
        )
    };
}
pub(crate) use repeat;

macro_rules! try_repeat {
    ($counter:ident to $upto:expr ; while $cond:expr => $body:block) => {
        <crate::repeat::Count<$upto> as crate::repeat::Repeat>::try_repeat_while(
            #[inline(always)]
            |$counter| $cond,
            #[inline(always)]
            |$counter| $body,
        )
    };
}
pub(crate) use try_repeat;

/// Repeat trait.
pub trait Repeat {
    #[allow(clippy::inline_always)]
    #[inline(always)]
    fn repeat<F: FnMut(usize)>(body_fn: F) {
        Self::repeat_while(
            #[inline(always)]
            |_n| true,
            body_fn,
        );
    }
    #[allow(clippy::inline_always)]
    #[inline(always)]
    fn repeat_while<F: FnMut(usize), C: FnMut(usize) -> bool>(cond_fn: C, mut body_fn: F) {
        Self::try_repeat_while::<Infallible, _, _>(
            cond_fn,
            #[inline(always)]
            |n| {
                body_fn(n);
                Ok(())
            },
        )
        .unwrap();
    }
    fn try_repeat_while<E: Error, F: FnMut(usize) -> Result<(), E>, C: FnMut(usize) -> bool>(
        cond_fn: C,
        body_fn: F,
    ) -> Result<(), E>;
}

pub struct Count<const N: usize>;

seq!(M in 1..=32 {

    impl Repeat for Count<M> {
        #[allow(clippy::inline_always)]
        #[inline(always)]
        fn try_repeat_while<E: Error, F: FnMut(usize) -> Result<(), E>, C: FnMut(usize) -> bool>(mut cond_fn: C, mut body_fn: F) -> Result<(), E> {
            seq!(T in 0..M {
                if !cond_fn(T) {
                    return Ok(())
                }
                body_fn(T)?;
            });
            Ok(())
        }
    }

});