Byl vydán Mozilla Firefox 143.0. Přehled novinek v poznámkách k vydání a poznámkách k vydání pro vývojáře. Nově se Firefox při ukončování anonymního režimu zeptá, zda chcete smazat stažené soubory. Dialog pro povolení přístupu ke kameře zobrazuje náhled. Obzvláště užitečné při přepínání mezi více kamerami. Řešeny jsou rovněž bezpečnostní chyby. Nový Firefox 143 bude brzy k dispozici také na Flathubu a Snapcraftu.
Byla vydána betaverze Fedora Linuxu 43 (ChangeSet), tj. poslední zastávka před vydáním finální verze, která je naplánována na úterý 21. října.
Multiplatformní emulátor terminálu Ghostty byl vydán ve verzi 1.2 (𝕏, Mastodon). Přehled novinek, vylepšení a nových efektů v poznámkách k vydání.
Byla vydána nová verze 4.5 (𝕏, Bluesky, Mastodon) multiplatformního open source herního enginu Godot (Wikipedie, GitHub). Přehled novinek i s náhledy v příspěvku na blogu.
Byla vydána verze 3.0 (Mastodon) nástroje pro záznam a sdílení terminálových sezení asciinema (GitHub). S novou verzí formátu záznamu asciicast v3, podporou live streamingu a především kompletním přepisem z Pythonu do Rustu.
Canonical oznámil, že bude podporovat a distribuovat toolkit NVIDIA CUDA (Wikipedie) v Ubuntu.
Tržní hodnota americké společnosti Alphabet, která je majitelem internetového vyhledávače Google, dnes poprvé překonala hranici tří bilionů dolarů (62,1 bilionu Kč). Alphabet se připojil k malé skupině společností, které tuto hranici pokořily. Jsou mezi nimi zatím americké firmy Nvidia, Microsoft a Apple.
Spojené státy a Čína dosáhly dohody ohledně pokračování populární čínské platformy pro sdílení krátkých videí TikTok v USA. V příspěvku na síti Truth Social to dnes naznačil americký prezident Donald Trump. Dosažení rámcové dohody o TikToku vzápětí oznámil americký ministr financí Scott Bessent, který v Madridu jedná s čínskými představiteli o vzájemných obchodních vztazích mezi USA a Čínou. Bessentova slova později potvrdila také čínská strana.
MKVToolNix, tj. sada nástrojů pro práci s formátem (medialnym kontajnerom) Matroska, byl vydán ve verzi 95.0. Podpora přehrávání formátu Matroska míří do Firefoxu [Bug 1422891, Technický popis]. Přehrávání lze již testovat ve Firefoxu Nightly.
Spolek OpenAlt zve příznivce otevřených řešení a přístupu na 211. sraz, který proběhne v pátek 19. září od 18:00 ve Studentském klubu U Kachničky na Fakultě informačních technologií Vysokého učení technického na adrese Božetěchova 2/1. Na srazu proběhne přednáška Jiřího Eischmanna o nové verzi prostředí GNOME 49. Nemáte-li možnost se zúčastnit osobně, přednáškový blok bude opět streamován živě na server VHSky.cz a následně i zpřístupněn záznam.
Class Data
{
public:
...
std::vector<u8> readU8(Info i);
std::vector<float> readFloat(Info i);
std::vector<std::vector<float>> readFloatVector(Info i);
...
}
Ve třídě Info je hromada informací podle kterých ty data získávám + jejich datový typ uložený jako enum class
enum class DatovyTyp : u8 {U8,Float,FloatVector,...}
class Info
{
public:
...
std::string jmeno;
DatovyTyp typ;
...
}
Celé použití je dost nešikovné, protože když chci získat všechny data a pak je zase dál použít, musím mít IF pro každý datový typ:
(navazující metody už jsou teplate nebo přetížené, takže umí pracovat se všemi datovými typy, které potřebuju)
Data d(...);
for(...)
{
Info i(...);
if(i.typ == DatovyTyp::Float)
{
std::vector<float> tmp = d.readFloat(i);
nějakáPřetíženáFunkceNeboTemplate(tmp,...);
}
else if(i.typ == VariableType::U8)
{
nějakáPřetíženáFunkceNeboTemplate(d.readU8(i),...);
}
}
Použití template ve smyslu:
template <typename T>
T read(Info i)
{
...
mě sice sjednotí všechny readXY do jedné šablony, ale pořád budu muset mít IF pro každý datový typ
if(i.typ == DatovyTyp::Float)
{
std::vector<float> tmp = d.read<float>(i);
nějakáPřetíženáFunkceNeboTemplate(tmp,...);
}
else if(i.typ == VariableType::U8)
{
nějakáPřetíženáFunkceNeboTemplate(d.read<u8>(i),...);
}
Chtěl bych idálně mít nějaký kouzelný template, který vrací datový typ podle toho enum class DatovyTyp
- což pokud vím nejde.
Takže se ptám, jestli existuje nějaká možnost jak uložit informaci o datovém typu tak, abych to potom mohl použít k určení návratového datového typu v template? Zatím jsem nic nenašel a co se pamatuju, tak tohle template neumožňují - existuje nějaká možnost jak to obejít?
Nebo jak to celé upravit nějak jinak, abych se vyhnul IF pro každý datový typ?
Díky.
Data
získat. To se čistě templaty vyřešit nedá, protože templaty v C++ se řeší pouze při překladu. Nějaké runtimové logice s větvením se tedy nevyhneš. Dá se to ale částečně zjednodušit tím, že logiku, která za běhu zjistí požadovaný datový typ a podle toho zavolá příslušnou obsluhu přesuneš do jedné flexibilní funkce. Nějaký nástin, jak na to můžeš najít třeba tady: https://pastebin.com/XUvcSJUr. Vtip je v tom, že to, co se předává dispatcheru jako templatový parameter P lze naimplemetovat libovolně, zatímco dispatcher bude vždy jen jeden.
Dalo by se to samozřejmě rozšířit i pro případy, že by měl dispatcher něco vracet apod. ale princip by byl stejný...
read()
:
https://pastebin.com/5GuZk4m5
P
, která s budou používat nejčastěji můžeš implementovat ty jako autor rozhraní s tím, že coder monkey prostě zavolá nějaký wrapper okolo dispatcher
u a nebude řešit, co se vevnitř děje. std::variant
v kódu není nejspíš proto, že je to věcička až z C++17 a starší překladače to nezbaští.
std::get<float>(variant)
... jestli mi teda zase něco neuniklo std::variant
? Tam se to řeší přes visitor patern.
Data
data vždy jen jednoho typu nebo zda je možné zavolat d.readFloat()
a d.readU8()
na jedné instanci té třídy. To by se variantem myslím řešit nedalo. Aspoň trochu flexibilní logika, jak řešit ten druhý případ by mohla vypadat třeba takto:
#include <iostream> #include <vector> enum class TypeID { String, Float, Integer }; template <TypeID> struct TypeIdentifier { }; template <> struct TypeIdentifier<TypeID::String> { typedef std::string type; }; template <> struct TypeIdentifier<TypeID::Float> { typedef float type; }; template <> struct TypeIdentifier<TypeID::Integer> { typedef int32_t type; }; struct Data { template <typename T> std::vector<T> read(); }; template <> std::vector<std::string> Data::read() { return std::vector<std::string>{ "Zero", "One", "Two" }; } template <> std::vector<float> Data::read() { return std::vector<float>{ 0.1, 0.2, 0.3 }; } template <> std::vector<int32_t> Data::read() { return std::vector<int32_t>{ 10, 20, 30 }; } template <typename T> void print(const T &t) { for (auto && i : t) std::cout << i << " "; std::cout << "\n"; } template <typename T> void printReverse(const T &t) { for (auto it = t.rbegin(); it != t.rend(); it++) std::cout << *it << " "; std::cout << "\n"; } template <template <typename> class P, typename S, typename... Args> void dispatcher(const TypeID id, S &s, Args... args) { switch (id) { case TypeID::String: P<TypeIdentifier<TypeID::String>::type>::call(s, std::forward<Args>(args)...); break; case TypeID::Float: P<TypeIdentifier<TypeID::Float>::type>::call(s, std::forward<Args>(args)...); break; case TypeID::Integer: P<TypeIdentifier<TypeID::Integer>::type>::call(s, std::forward<Args>(args)...); break; } } template <typename T> struct Proc { static void call(Data &d) { auto v = d.read<T>(); print(v); } }; template <> struct Proc<int32_t> { static void call(Data &d) { std::cout << "Specialization for int32_t\n"; auto v = d.read<int32_t>(); print(v); } }; template <typename T> struct ProcTwo { template <typename... Args> static void call(Data &d, Args ...) { auto v = d.read<T>(); printReverse(v); } }; template <> struct ProcTwo<float> { static void call(Data &d, int i) { std::cout << "Specialization for float: " << i << "\n"; auto v = d.read<float>(); printReverse(v); } template <typename... Args> static void call(Data &, Args...) { throw std::runtime_error("Function called with invalid parameters"); } }; int main() { Data d; dispatcher<Proc>(TypeID::String, d); dispatcher<Proc>(TypeID::Float, d); dispatcher<Proc>(TypeID::Integer, d); dispatcher<ProcTwo>(TypeID::String, d); dispatcher<ProcTwo>(TypeID::Float, d, 66); //dispatcher<ProcTwo>(TypeID::Float, d); /* Throws at runtime */ dispatcher<ProcTwo>(TypeID::Integer, d); return 0; }
template<int N, class Head, class... Tail> struct Dispatch { static void dispatch(const Info& i, const Data& d) { if (i.typ == N) perform<Head>(i, d); else Dispatch<N+1, Tail...>::dispatch(i, d); } };
Tiskni
Sdílej: