#define OPTION_1
#ifdef OPTION_1
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <string.h>
enum {
EXTENSIONTAG_PCX,
EXTENSIONTAG_MNG,
EXTENSIONTAG_SMK
};
int main()
{
constexpr std::array<std::pair<const char*, int>, 4> extensions {{
{"pcx", EXTENSIONTAG_PCX},
{"mng", EXTENSIONTAG_MNG},
{"png", EXTENSIONTAG_MNG},
{"smk", EXTENSIONTAG_SMK}
}};
for(const std::string file_extension : {"pcx", "mng", "png", "smk", "evil"}) {
try {
const auto found = std::find_if(extensions.cbegin(), extensions.cend(), [&file_extension](const std::pair<const char*, int>& p) {
return strcmp(file_extension.c_str(), p.first) == 0;
});
if(found != extensions.cend()) {
//bn_int_tag_set(&extensiontag, found->second);
std::cout << "extension: " << found->first << ", tag: " << found->second << '\n';
} else {
throw std::runtime_error("Unknown file extension (" + file_extension + ")");
}
} catch (const std::exception& e) {
std::cerr << e.what() << '\n';
}
}
}
#else
#include <algorithm>
#include <map>
#include <iostream>
#include <string>
#include <string.h>
enum {
EXTENSIONTAG_PCX,
EXTENSIONTAG_MNG,
EXTENSIONTAG_SMK
};
int main()
{
auto cmp = [](const char* lhs, const char* rhs) { return strcmp(lhs, rhs) < 0; };
const std::map<const char*, int, decltype(cmp)> extensions {{
{"pcx", EXTENSIONTAG_PCX},
{"mng", EXTENSIONTAG_MNG},
{"png", EXTENSIONTAG_MNG},
{"smk", EXTENSIONTAG_SMK}
}, cmp};
for(const std::string file_extension : {"pcx", "mng", "png", "smk", "evil"}) {
try {
// if custom exception is not needed
//bn_int_tag_set(&extensiontag, extensions.at(file_extension.c_str()));
// else
const auto found = extensions.find(file_extension.c_str());
if(found != extensions.cend()) {
//bn_int_tag_set(&extensiontag, found->second);
std::cout << "extension: " << found->first << ", tag: " << found->second << '\n';
} else {
throw std::runtime_error("Unknown file extension (" + file_extension + ")");
}
} catch (const std::exception& e) {
std::cerr << e.what() << '\n';
}
}
}
#endif
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