1
2
3
4
5
6
7
| ...
std::wstring recuperer_Disney_SJ(fs::path const& cheminFichier)
...
std::wstring recuperer_Netflix_SJ(fs::path const& cheminFichier)
...
std::wstring recuperer_SJ(fs::path const& cheminFichier)
... |
Ok, mais attention dans "recuperer_Netflix_SJ", vous avez des typo :
std::wregex sj_pattern{ L"(7\\+|10\\+|13\\+|16\\+|18+\\Tous publics)" };
C'est plutôt :
std::wregex sj_pattern{ L"(7\\+|10\\+|13\\+|16\\+|18\\+|Tous publics)" };
Et essayez de factoriser le code :
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
|
...
std::wstring filter_values( std::wstring const& content, std::vector<std::wstring> const& values)
{
std::wstring pattern;
for (const auto value : values) {
if (pattern.length() > 0) { pattern += L"|"; }
pattern += value;
}
std::wregex value_pattern{ L"(" + pattern + L")" };
std::wsmatch match;
if (std::regex_match(content, match, value_pattern))
{
return match[1];
}
return L"";
}
...
std::wstring recuperer_Disney_SJ(fs::path const& cheminFichier)
{ // Disney+ SJ
auto nomFichier = cheminFichier.wstring();
std::wstring content = lire_fichierTxt(nomFichier);
return filter_values(content, { L"6\\+",L"12\\+",L"14\\+" });
}
...
std::wstring recuperer_Netflix_SJ(fs::path const& cheminFichier)
{ // Netflix SJ
auto nomFichier = cheminFichier.wstring();
std::wstring content = lire_fichierTxt(nomFichier);
return filter_values(content, { L"7\\+",L"10\\+",L"13\\+", L"16\\+", L"18\\+", L"Tous publics"});
}
.... |
Avec la fonction "filter_values", vous factorisez le code.
Mais vous pouvez aussi remarquer que les fonctions "recuperer_Disney_SJ", "recuperer_Netflix_SJ", ou "recuperer_SJ", sont aussi assez proches.
Je pense donc qu'il serait plus simple de fusionner ces fonctions en une seule fonction "filter_signalitique_jeunesse" qui prendrait en paramètre la liste des valeurs possibles en paramètre (comme la fonction "filter_values").
En factorisant le code, vous avez moins de code, donc moins d'erreurs d'étourderie (cf. le "|18+\\Tous publics"), et si vous avez à corriger un bug sur le filtrage ou à l'améliorer, vous ne le ferez qu'à un endroit.
Avec votre code de la fonction "Serie:: Print_Titre()", pour savoir comment est construit l'affichage du titre, vous devez suivre TOUT le code de la fonction.
C'est lourd.
Faites plus simple, par étape :
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
| const void Serie::Print_Titre()
{
if (affichage_titres_actif)
{
std::wstring titres_str;
std::wstring sur_str;
std::wstring sj_str;
std::wstring note_str;
titres_str = keyColor[0] + L"Titre : " + valuesColor + m_titres[0];
if (m_titres.size() > 1)
titres_str += keyColor[1] + m_titres[1] + valuesColor + m_titres[2];
/*if (m_date_Diffusee_a_partir_de_[0] && Date_Diffusee_a_partir_de[0].tm_year != 0)
{
wchar_t date_string[22];
wcsftime(date_string, 15, L"%Y", &Date_Diffusee_a_partir_de[0]);
wstr = date_string;
titres_str += keyColor[0] + L" (" + valuesColor + wstr + keyColor[0] + L')' + valuesColor;
}*/
// sur
if (affichage_sur_actif && m_sur != L"")
{
sur_str += keyColor[0] + L" (sur " + valuesColor + m_sur + keyColor[0] + L" : " + valuesColor;
// Disney+ SJ
if (affichage_disney_sj_actif && m_disney_sj.length() != 0)
sur_str += m_disney_sj;
// Netflix SJ
if (affichage_netflix_sj_actif && m_netflix_sj.length() != 0)
sur_str += m_netflix_sj;
sur_str += keyColor[0] + L')' + valuesColor;
}
else
{
// Disney+ SJ
if (affichage_disney_sj_actif && m_disney_sj.length() != 0)
sur_str += keyColor[0] + L" (" + valuesColor + L"Disney+ : " + m_disney_sj + keyColor[0] + L')' + valuesColor;
// Netflix SJ
if (affichage_netflix_sj_actif && m_netflix_sj.length() != 0)
sur_str += keyColor[0] + L" (" + valuesColor + L"Netflix : " + m_netflix_sj + keyColor[0] + L')' + valuesColor;
}
// La signalétique jeunesse
if (affichage_sj_actif && m_sj.length() != 0)
sj_str += keyColor[0] + L" (" + valuesColor + L"SJ" + keyColor[0] + L" : " + valuesColor + m_sj + keyColor[0] + L')' + valuesColor;
// Note
if (affichage_note_actif)
note_str += Calcul_Note_Affichage();
std::wcout << titres_str << sur_str << sj_str << note_str << std::endl;
}
} |
Pour "Serie::Serie", l'utilisation des "find" rend le code peu clair.
Si l'on considère que le nom du répertoire contient 4 informations (1 obligatoire et 3 autres optionnelles), avec une expression régulière, le code ressemblerait à ceci :
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
| Serie::Serie(std::filesystem::path racine)
{
this->racine = racine;
auto nomDossier = racine.filename().wstring();
assert(nomDossier.length() > 0 && L"Nom de dossier vide");
std::wregex filename_pattern{ L"(xxxx)__(yyyy)?__(zzzz)?__(tttt)?" };
std::wsmatch match;
if (std::regex_match(nomDossier, match, filename_pattern))
{
std::wstring titres = match[1];
m_titres = Dossier_Titres(titres);
m_dates2 = (match[2].matched) ? match[2].str() : L"";
m_sur = (match[3].matched) ? match[3].str() : L"";
std::wstring sous_genre = (match[4].matched) ? match[4].str() : L"";
m_sous_genre = sous_genre;
}
else
{
assert(false==true && "Le nom du répertoire n'est pas un nom valide."));
}
} |
Il faut juste remplacer "(xxxx)__(yyyy)?__(zzzz)?__(tttt)?" par les "bonnes" valeurs.
Que doit valoir "xxxx", "yyyy", "zzzz" et "tttt" pour que cela correspond aux différentes parties qui nous intéressent ?
xxxx : les titres
yyyy : les "dates"
zzzz : le diffuseur
tttt : sous-genre
1
2
3
4
5
6
| Soluce :(.+?)(?:\\.\\[(\\d{4}\\s|\\d{4}\\-\\d{4}\\s|\\d{4}\\-\\s)?([^\\]]*)\\])?(?:\\.(.+))?
(xxxx) = (.+?)
(yyyy) = (\\d{4}\\s|\\d{4}\\-\\d{4}\\s|\\d{4}\\-\\s)
(zzzz) = ([^\\]]*)
(tttt) = (.+) |
Pouvez-vous expliquer pas-à-pas ? Exemple : m_titre2 ou m_titres ou...
Je ne vois pas ce qu'est votre "m_titre2".
1
2
3
| void Serie::initialiser_Titre(fs::path const& cheminFichier, std::vector<std::wstring>& m_titre)
{ ...
std::wregex titre_pattern{ L"(.+?)(\\s:\\s|:\\s|/|\\s-\\s)(.+)" }; |
On voit dans le code que l'on veut découper titre en 3 parties.
Il a ce qui est avant la partie "captée" par le motif "rouge".
C'est la partie en charge de "capter" le séparateur des 2 autres parties
Il a ce qui est après la partie "captée" par le motif "rouge".
Si on décortique la partie "séparateur", elle est composée de 4 parties séparées par des "|" (pipe):
"\\s", c'est pour un espace ou une tabulation.
N'y reconnaissez-vous pas les différents appels à find(" : "), etc... de votre code original ?
serie.cpp
1
2
3
4
5
6
7
8
9
10
11
12
| Serie::Serie(std::filesystem::path racine)
{
...
m_titres = Dossier_Titres(titres);
...
}
...
std::vector<std::wstring> Serie::Dossier_Titres(std::wstring titre)
{
...
}
... |
"Dossier_Titres" comme nom, c'est vraiment pas terrible.
En utilisant une expression régulière très proche de celle utilisée dans la fonction "Serie::initialiser_Titre", la fonction "Dossier_Titres" serait bien plus simple et compacte.
-------------------------
Nom du répertoire : Azertyuiop - qsdfghjklm.[2021-2023 Netflix].Manga
Contenu du fichier titre.txt : Azertyuiop/qsdfghjklm
C'est les mêmes titres, mais les séparateurs sont différents.
Je vous avais déjà indiqué que mettre le séparateur dans le "std::vector<std::wstring>>" m_titres, c'était pas "logiques".
Si vous ne mettez pas ces séparateurs dans le champ et la variable locale, vous n'avez qu'à comparer les 2 std::vector "m_titres" et "titre2".
bool found = (titres2==m_titres);
(l'opérateur "==" compare le contenu de chacun des éléments du std::vector)
ou mieux
assert(titres2==m_titre && "Le contenu du fichier ne correspond pas au nom du répertoire");
(erreur de programmation)
std::vector<std::wstring> titre = lire_fichierTxt(cheminFichier.wstring(), { L"\n" });
"titre", c'est vraiment pas terrible, car cela ne contient pas que le titre.
"content" ou "contenu" serait des noms plus "correctes".
Que faire ?
#include <???>
m_titres[0] = titres2 ???
C'est quoi la question ???
Répondre avec citation
(Mardi !!!)
Partager