# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
##@cooked nocomments
module: base.arr base_ "Fonctions de base: gestion des variables tableaux"
require: base.core base.str

function: base_array_count "retourner le nombre d'éléments du tableau \$1"
function base_array_count() {
    eval "echo \${#$1[*]}"
}

function: base_array_isempty "tester si le tableau \$1 est vide"
function base_array_isempty() {
    eval "[ \${#$1[*]} -eq 0 ]"
}

function: base_array_new "créer un tableau vide dans la variable \$1"
function base_array_new() {
    eval "$1=()"
}

function: base_array_copy "copier le contenu du tableau \$2 dans le tableau \$1"
function base_array_copy() {
    eval "$1=(\"\${$2[@]}\")"
}

function: base_array_add "ajouter les valeurs \$2..@ à la fin du tableau \$1"
function base_array_add() {
    local __aa_a="$1"; shift
    eval "$__aa_a=(\"\${$__aa_a[@]}\" \"\$@\")"
}

function: base_array_ins "insérer les valeurs \$2..@ au début du tableau \$1"
function base_array_ins() {
    local __aa_a="$1"; shift
    eval "$__aa_a=(\"\$@\" \"\${$__aa_a[@]}\")"
}

function: base_array_del "supprimer *les* valeurs \$2 du tableau \$1"
function base_array_del() {
    local __ad_v
    local -a __ad_vs
    eval '
for __ad_v in "${'"$1"'[@]}"; do
  if [ "$__ad_v" != "$2" ]; then
    __ad_vs=("${__ad_vs[@]}" "$__ad_v")
  fi
done'
    base_array_copy "$1" __ad_vs
}

function: base_array_addu "ajouter la valeur \$2 au tableau \$1, si la valeur n'y est pas déjà

Retourner vrai si la valeur a été ajoutée"
function base_array_addu() {
    local __as_v
    eval '
for __as_v in "${'"$1"'[@]}"; do
  [ "$__as_v" == "$2" ] && return 1
done'
    base_array_add "$1" "$2"
    return 0
}

function: base_array_insu "insérer la valeur \$2 au début du tableau tableau \$1, si la valeur n'y est pas déjà

Retourner vrai si la valeur a été ajoutée."
function base_array_insu() {
    local __as_v
    eval '
for __as_v in "${'"$1"'[@]}"; do
  [ "$__as_v" == "$2" ] && return 1
done'
    base_array_ins "$1" "$2"
    return 0
}

function: base_array_fillrange "Initialiser le tableau \$1 avec les nombres de \$2(=1) à \$3(=10) avec un step de \$4(=1)"
function base_array_fillrange() {
    local -a __af_vs
    local __af_i="${2:-1}" __af_to="${3:-10}" __af_step="${4:-1}"
    while [ "$__af_i" -le "$__af_to" ]; do
        __af_vs=("${__af_vs[@]}" "$__af_i")
        __af_i=$(($__af_i + $__af_step))
    done
    base_array_copy "$1" __af_vs
}

function: base_array_eq "tester l'égalité des tableaux \$1 et \$2"
function base_array_eq() {
    local -a __ae_a1 __ae_a2
    base_array_copy __ae_a1 "$1"
    base_array_copy __ae_a2 "$2"
    [ ${#__ae_a1[*]} -eq ${#__ae_a2[*]} ] || return 1
    local __ae_v __ae_i=0
    for __ae_v in "${__ae_a1[@]}"; do
        [ "$__ae_v" == "${__ae_a2[$__ae_i]}" ] || return 1
        __ae_i=$(($__ae_i + 1))
    done
    return 0
}

function: base_array_contains "tester si le tableau \$1 contient la valeur \$2"
function base_array_contains() {
    local __ac_v
    eval '
for __ac_v in "${'"$1"'[@]}"; do
  [ "$__ac_v" == "$2" ] && return 0
done'
    return 1
}

function: base_array_icontains "tester si le tableau \$1 contient la valeur \$2, sans tenir compte de la casse"
function base_array_icontains() {
    local __ac_v
    eval '
for __ac_v in "${'"$1"'[@]}"; do
  [ "${__ac_v,,} == "${2,,}" ] && return 0
done'
    return 1
}

function: base_array_find "si le tableau \$1 contient la valeur \$2, afficher l'index de la valeur. Si le tableau \$3 est spécifié, afficher la valeur à l'index dans ce tableau"
function base_array_find() {
    local __af_i __af_v
    __af_i=0
    eval '
for __af_v in "${'"$1"'[@]}"; do
  if [ "$__af_v" == "$2" ]; then
    if [ -n "$3" ]; then
      recho "${'"$3"'[$__af_i]}"
    else
      echo "$__af_i"
    fi
    return 0
  fi
  __af_i=$(($__af_i + 1))
done'
    return 1
}

function: base_array_reverse "Inverser l'ordre des élément du tableau \$1"
function base_array_reverse() {
    local -a __ar_vs
    local __ar_v
    base_array_copy __ar_vs "$1"
    base_array_new "$1"
    for __ar_v in "${__ar_vs[@]}"; do
        base_array_ins "$1" "$__ar_v"
    done
}

function: base_array_replace "dans le tableau \$1, remplacer toutes les occurences de \$2 par \$3..*"
function base_array_replace() {
    local __ar_sn="$1"; shift
    local __ar_f="$1"; shift
    local -a __ar_s __ar_d
    local __ar_v
    base_array_copy __ar_s "$__ar_sn"
    for __ar_v in "${__ar_s[@]}"; do
        if [ "$__ar_v" == "$__ar_f" ]; then
            __ar_d=("${__ar_d[@]}" "$@")
        else
            __ar_d=("${__ar_d[@]}" "$__ar_v")
        fi
    done
    base_array_copy "$__ar_sn" __ar_d
}

function: base_array_each "Pour chacune des valeurs ITEM du tableau \$1, appeler la fonction \$2 avec les arguments (\$3..@ ITEM)"
function base_array_each() {
    local __ae_v
    local -a __ae_a
    base_array_copy __ae_a "$1"; shift
    for __ae_v in "${__ae_a[@]}"; do
        "$@" "$__ae_v"
    done
}

function: base_array_map "Pour chacune des valeurs ITEM du tableau \$1, appeler la fonction \$2 avec les arguments (\$3..@ ITEM), et remplacer la valeur par le résultat de la fonction"
function base_array_map() {
    local __am_v
    local -a __am_a __am_vs
    local __am_an="$1"; shift
    local __am_f="$1"; shift
    base_array_copy __am_a "$__am_an"
    for __am_v in "${__am_a[@]}"; do
        __am_vs=("${__am_vs[@]}" "$("$__am_f" "$@" "$__am_v")")
    done
    base_array_copy "$__am_an" __am_vs
}

function: base_array_first "afficher la première valeur du tableau \$1"
function base_array_first() {
    eval "recho \"\${$1[@]:0:1}\""
}

function: base_array_last "afficher la dernière valeur du tableau \$1"
function base_array_last() {
    eval "recho \"\${$1[@]: -1:1}\""
}

function: base_array_copy_firsts "copier toutes les valeurs du tableau \$2(=\$1) dans le tableau \$1, excepté la dernière"
function base_array_copy_firsts() {
    eval "$1=(\"\${${2:-$1}[@]:0:\$((\${#${2:-$1}[@]}-1))}\")"
}

function: base_array_copy_lasts "copier toutes les valeurs du tableau \$2(=\$1) dans le tableau \$1, excepté la première"
function base_array_copy_lasts() {
    eval "$1=(\"\${${2:-$1}[@]:1}\")"
}

function: base_array_extend "ajouter le contenu du tableau \$2 au tableau \$1"
function base_array_extend() {
    eval "$1=(\"\${$1[@]}\" \"\${$2[@]}\")"
}

function: base_array_extendu "ajouter chacune des valeurs du tableau \$2 au tableau \$1, si ces valeurs n'y sont pas déjà

Retourner vrai si au moins une valeur a été ajoutée"
function base_array_extendu() {
    local __ae_v __ae_s=1
    eval '
for __ae_v in "${'"$2"'[@]}"; do
  base_array_addu "$1" "$__ae_v" && __ae_s=0
done'
    return "$__ae_s"
}

function: base_array_extend_firsts "ajouter toutes les valeurs du tableau \$2 dans le tableau \$1, excepté la dernière"
function base_array_extend_firsts() {
    eval "$1=(\"\${$1[@]}\" \"\${$2[@]:0:\$((\${#$2[@]}-1))}\")"
}

function: base_array_extend_lasts "ajouter toutes les valeurs du tableau \$2 dans le tableau \$1, excepté la première"
function base_array_extend_lasts() {
    eval "$1=(\"\${$1[@]}\" \"\${$2[@]:1}\")"
}

function: base_array_xsplit "créer le tableau \$1 avec chaque élément de \$2 (un ensemble d'éléments séparés par \$3, qui vaut ':' par défaut)"
function base_array_xsplit() {
    eval "$1=($(recho_ "$2" | lawk -v RS="${3:-:}" '
{
    gsub(/'\''/, "'\'\\\\\'\''")
    print "'\''" $0 "'\''"
}'))" #"
}

function: base_array_xsplitc "variante de base_array_xsplit() où le séparateur est ',' par défaut"
function base_array_xsplitc() {
    base_array_xsplit "$1" "$2" "${3:-,}"
}

function: base_array_split "créer le tableau \$1 avec chaque élément de \$2 (un ensemble d'éléments séparés par \$3, qui vaut ':' par défaut)

Les éléments vides sont ignorés. par exemple \"a::b\" est équivalent à \"a:b\""
function base_array_split() {
    eval "$1=($(recho_ "$2" | lawk -v RS="${3:-:}" '
/^$/ { next }
{
    gsub(/'\''/, "'\'\\\\\'\''")
    print "'\''" $0 "'\''"
}'))" #"
}

function: base_array_splitc "variante de base_array_split() où le séparateur est ',' par défaut"
function base_array_splitc() {
    base_array_split "$1" "$2" "${3:-,}"
}

function: base_array_xsplitl "créer le tableau \$1 avec chaque ligne de \$2"
function base_array_xsplitl() {
    eval "$1=($(recho_ "$2" | strnl2lf | lawk '
{
    gsub(/'\''/, "'\'\\\\\'\''")
    print "'\''" $0 "'\''"
}'))" #"
}

function: base_array_splitl "créer le tableau \$1 avec chaque ligne de \$2

Les lignes vides sont ignorés."
function base_array_splitl() {
    eval "$1=($(recho_ "$2" | strnl2lf | lawk '
/^$/ { next }
{
    gsub(/'\''/, "'\'\\\\\'\''")
    print "'\''" $0 "'\''"
}'))" #"
}

function: base_array_join "afficher le contenu du tableau \$1 sous forme d'une liste de valeurs séparées par \$2 (qui vaut ':' par défaut)

* Si \$1==\"@\", alors les éléments du tableaux sont les arguments de la fonction à partir de \$3
* Si \$1!=\"@\" et que le tableau est vide, afficher \$3
* Si \$1!=\"@\", \$4 et \$5 sont des préfixes et suffixes à rajouter à chaque élément"
function base_array_join() {
    local __aj_an __aj_l __aj_j __aj_s="${2:-:}" __aj_pf __aj_sf
    if [ "$1" == "@" ]; then
        __aj_an="\$@"
        shift; shift
    else
        __aj_an="\${$1[@]}"
        __aj_pf="$4"
        __aj_sf="$5"
    fi
    eval '
for __aj_l in "'"$__aj_an"'"; do
  __aj_j="${__aj_j:+$__aj_j'"$__aj_s"'}$__aj_pf$__aj_l$__aj_sf"
done'
    if [ -n "$__aj_j" ]; then
        recho "$__aj_j"
    elif [ "$__aj_an" != "\$@" -a -n "$3" ]; then
        recho "$3"
    fi
}

function: base_array_joinc "afficher les éléments du tableau \$1 séparés par ','"
function base_array_joinc() {
    base_array_join "$1" , "$2" "$3" "$4"
}

function: base_array_joinl "afficher les éléments du tableau \$1 à raison d'un élément par ligne"
function base_array_joinl() {
    base_array_join "$1" "
" "$2" "$3" "$4"
}

function: base_array_mapjoin "map le tableau \$1 avec la fonction \$2, puis afficher le résultat en séparant chaque élément par \$3

Les arguments et la sémantique sont les mêmes que pour base_array_join() en
tenant compte de l'argument supplémentaire \$2 qui est la fonction pour
base_array_map() (les autres arguments sont décalés en conséquence)"
function base_array_mapjoin() {
    local __amj_src="$1" __amj_func="$2" __amj_sep="$3"
    shift; shift; shift
    if [ "$__amj_src" == "@" ]; then
        local -a __amj_tmpsrc
        __amj_tmpsrc=("$@")
        __amj_src=__amj_tmpsrc
        set --
    fi
    local -a __amj_tmp
    base_array_copy __amj_tmp "$__amj_src"
    base_array_map __amj_tmp "$__amj_func"
    base_array_join __amj_tmp "$__amj_sep" "$@"
}

function: base_array_fix_paths "Corriger les valeurs du tableau \$1. Les valeurs contenant le séparateur \$2(=':') sont séparées en plusieurs valeurs.

Par exemple avec le tableau input=(a b:c), le résultat est input=(a b c)"
function base_array_fix_paths() {
    local __afp_an="$1" __afp_s="${2:-:}"
    local -a __afp_vs
    local __afp_v
    base_array_copy __afp_vs "$__afp_an"
    base_array_new "$__afp_an"
    for __afp_v in "${__afp_vs[@]}"; do
        base_array_split __afp_v "$__afp_v" "$__afp_s"
        base_array_extend "$__afp_an" __afp_v
    done
}