Téléchargement Stroika - Téléchargement du code source Stroika

Stroika

Données du site Web

v2.1.15)

Télécharger

Stroika V3 - C ++ moderne a rendu facile

Stroika est un cadre d'application C ++ moderne et portable. Il facilite l'écriture C ++ en fournissant des blocs de construction sûrs et flexibles, ainsi que des emballages sur d'autres bibliothèques utiles qui les aident à travailler ensemble plus apparemment.

Extraits de code / exemples

La classe de chaîne rend Unicode plus facile

String a = u8" abc " ;
String b = u32 " abc " ;
CallFunction (a+b);
// trim whitespace, and convert to u16string for some legacy API
std::u16string uuu = (a+b).Trim ().As<u16string>();
// tokenize
String t{ " ABC DEF G " };
Assert (t.Tokenize ()[1] == "DEF");

_F Les chaînes, le format C ++ 20, fonctionnent avec les types Stroika et plus facile à utiliser

 // most Stroika types automatically support formattable<>
DbgTrace ( " v = {} " _f, v);   // to a tracelog file, or debugger
cerr << " v = {} " _f (v) << endl;   // OR iostreams (unicode mapped automatically)

ITable - API Funcalation facile à utiliser sur toutes les itérables, similaire à C # linq

 // nb: String is an Iterable<Character>, 
// despite internally representing the characters very differently
bool IsAllWhitespace (String s) const
{
  return not s. Find ([] (Character c) -> bool { return not c. IsWhitespace (); });
}

Iterable< int > c { 1 , 2 , 2 , 5 , 9 , 4 , 5 , 6 };
EXPECT_TRUE (c.Distinct ().SetEquals ({ 1 , 2 , 4 , 5 , 6 , 9 }));

Iterable< int > c { 3 , 4 , 7 };
// Map iterates over 'c' and produces the template argument container
// automatically by appending the result of each lambda application
EXPECT_EQ ((c.Map<vector<String>> ([] ( int i) { return " {} " _f (i); }), vector<String>{ " 3 " , " 4 " , " 7 " }));

Conteneurs

La vache (la copie-écriture améliore souvent les performances pour les cas les plus courants)
API définies par le modèle d'accès, comme pile = push / pop, séquence = accès de type tableau, map = {de: à: à}, etc.

Transparence de représentation

Stroika fournit un riche ensemble d'archtypes de conteneurs et des impléments de structure de données.

 extern void f (Set< int >);
// use the default Set<> representation - the best for type 'int'
Set< int > s{ 1 , 2 , 3 };
f (s);  // data not actually copied - Stroika containers use 'copy-on-write (COW)'
s = Concrete::SortedSet_SkipList< int >{s}; // Use a skiplist to represent the set
f (s);  // call f the same way regardless of data structure used for implementation
// set equality not order dependent (regardless of data structure)
Assert (s == { 2 , 3 , 1 });

Voir échantillon de conteneurs pour plus de détails

Streams et ObjectVariantMapper

MyClass someObject = ...;
VariantValue v = mapper.FromObject (someObject);   // Map object to a VariantValue

// Serialize using any serialization writer defined in 
// Stroika::Foundation::DataExchange::Variant (we selected JSON)
Streams::MemoryStream:: Ptr <byte> tmpStream = Streams::MemoryStream::New<byte> ();
Variant::JSON::Writer{}.Write (v, tmpStream);

// You can persist these to file if you wish
{
    using namespace IO ::FileSystem ;
    FileOutputStream:: Ptr tmpFileStream =
        FileOutputStream::New ( WellKnownLocations::GetTemporary () / " t.txt " );
    Variant::JSON::Writer{}. Write (v, tmpFileStream);
}

Voir échantillon de sérialisation pour plus de détails

Créez des sites Web dans votre application

Route{ " variables/(.+) " _RegEx,
      // explicit message handler
      [ this ] (Message& m, const String& varName) {
          WriteResponse (m. rwResponse (), kVariables_ , kMapper . FromObject ( fWSImpl_ -> Variables_GET (varName)));
      }},
  Route{HTTP::MethodsRegEx:: kPost , " plus " _RegEx,
      // automatically map high level functions via ObjectVariantMapper
      ObjectRequestHandler::Factory{ kBinaryOpObjRequestOptions_ ,
                                    [ this ] (Number arg1, Number arg2) { return fWSImpl_ -> plus (arg1, arg2); }}},

Voir l'échantillon de serviettes Web pour plus de détails.

Abstraction des ruisseaux

Fait la compression, le chiffrement, l'EMI, le réseautage, le traitement des données, tous s'adaptent sans ensemble

 // @todo INCOMPLETE - BAD EXAMPLE---
const OpenSSL::DerivedKey kDerivedKey =
     OpenSSL::EVP_BytesToKey{ OpenSSL::CipherAlgorithms::kAES_256_CBC (), OpenSSL::DigestAlgorithms:: kMD5 , " password " };
const Memory::BLOB srcText =
  Memory::BLOB::FromHex ( " 2d ... " ); // ...
// EncodeAES takes a stream, and produces a stream
// which can be chained with the gzip Transformer, which takes a stream, and produces a
Compression::GZip::Compress::New ().Transform (EncodeAES ( kDerivedKey , srcText.As<Streams::InputStream:: Ptr <byte>> (), AESOptions::e256_CBC))

Stroika fournit une couche au-dessus de la bibliothèque C ++ standard, avec des classes plus simples à utiliser (de niveau supérieur), plus de garanties de vérification de la sécurité (dans les versions de débogage) et des zones d'adressage non standardisées (comme le réseautage). Mais ces classes Stroika s'intègrent parfaitement aux classes C ++ standard, et votre code peut facilement utiliser autant de bibliothèque que les préférences dictent.

Stylistiquement, Stroika diffère de la bibliothèque C ++ standard, Boost et de nombreuses autres bibliothèques C ++, en ce qu'elle, il embrasse (relativement) des abstractions orientées objet sur la généricité basée sur les modèles (voir Stoika-Approach-to-performance.md). L'abstraction des hiérarchies de type est mieux adaptée à la façon dont les gens raisonnent, et les modèles et les concepts - bien que puissants - peuvent être avec une intention de programmeur avec délicatesse et obscure. De plus, Stroika met l'accent sur la séparation de l'interface de la mise en œuvre: documenter soigneusement l'interface dans les en-têtes et séparer l'implémentation à d'autres fichiers.

Stroika comprend 2 couches: la fondation, qui fournit des classes de blocs de construction applicables à la plupart des applications, et une série de cadres spécifiques au domaine qui fournissent une riche collection de code dans différents domaines.

alt text

Les cadres dépendent de la fondation; Les modules de fondation dépendent fréquemment les uns des autres; Mais le code de couche de fondation ne contient aucune dépendance en dehors de la fondation (sauf sur la bibliothèque C ++ standard et diverses bibliothèques ThirdPartyComponent éventuellement incluses ou référencées, comme OpenSSL).

Démarrage rapide

Je ne veux pas lire - je veux juste coder. Instructions étape par étape pour créer votre première application basée sur Stroka sur votre machine, en quelques minutes (moins de temps de téléchargement / compilation - qui varie).

Start.md

Qualité

Presque toutes les interfaces et méthodes publiques sont bien documentées; Les implémentations sont claires et bien commentées.
Les affirmations en profondeur intégrées (y compris les assertions de sécurité thréaux) aident à documenter et à appliquer les modèles d'utilisation (sans coût de performance dans les versions de production).
Chaque version est testée avec Valgrind (Memcheck), Google Sanitizers (Tsan, Ubsan, Leak et Asan), GitHub CodeQL et une variété de plates-formes et de compilateurs, ainsi que d'un grand corps de tests de régression (y compris la plupart des exemples de documentation) pour aider à assurer l'entraînement de la bibliothèque.
Les exemples d'applications aident à afficher des cas d'utilisation courants (comme la construction d'un serveur Web dans votre application pour fournir du contenu et des API de service Web).
Commencez rapidement à l'aide de conteneurs Docker prédéfinis (pour Windows et Linux).

La Fondation Stoika fournit

Classes de cache (une variété de différentes stratégies de mise en cache / mémorisation directement soutenues).
Classes de caractères (plus simples à utiliser - en particulier avec Unicode - Class Strings, avec des mappages de style fonctionnel, et l'utilitaire toString () pour la plupart des objets Stroika).
Classes de conteneurs (collection, file d'attente, cartographie, séquence, ensemble et bien plus encore, chacune avec une riche variété d'implémentations backend).
DataExchange (variantValue, riche collection de sérialiseurs de format de données / désérialiseurs - comme JSON, XML, objet vers / à partir des mappages de sérialisation, et bien plus encore).
Classes de motifs d'exécution (coureur de processus externe, modèles de synchronisation, blocage de file d'attente, pools de threads et bien plus encore).
Prise en charge de la mise en réseau (emballages de socket de haut niveau, récupération du client Web).
Bibliothèque de flux simples et élégants, avec des adaptateurs pour la cryptographie, la compression, les transformations de texte, etc.
Intégration transparente (emballages orientés objet concernant les règles de sécurité et d'adaptateur de Stroka) avec de nombreuses bibliothèques importantes, notamment: boost, libcurl, LZMA SDK, OpenSSL, SQLite, Xerces, Zlib (par exemple un flux de compression - en utilisant par exemple ZLIB).
Et plus ...

Stoika Frameworks fournit

mesure du réseau
SSDP / UPNP
Surveillance des performances du système
Édition de texte / traitement de texte
serveur Web
services Web
Et plus ...

Compromis

La plus grande force de Stroika est également sa plus grande faiblesse:

Il y a des bibliothèques plus petites et plus ciblées qui font beaucoup de choses que fait Stroka. Être un objectif unique est une forme de modularité (bonne) et permet une adoption / intégration facile. Mais les bibliothèques qui font n'importe quoi de complexité doivent créer leur propre infrastructure pour une grande variété de problèmes de blocs de construction (par exemple, Xerces a ses propres classes de flux, ses classes de date de pistache, etc.). Et si vous avez deux de ces bibliothèques, ils sont peu susceptibles d'interagir nettement, et leurs cours de soutien (pour des trucs comme la date et les flux ci-dessus) ne le feront certainement pas.
Stroika adopte l'approche de la construction de ses fonctionnalités en couches, en tirant parti d'autres composants (par exemple, les flux et les conteneurs) dans les couches inférieures (ainsi que les bibliothèques C ++ standardisées). Cela augmente légèrement le coût de l'adoption de Stroika pour quelque chose de petit (car tirer une chose dans beaucoup de choses), mais verse ensuite des dividendes lorsque vous l'utilisez pour accomplir une deuxième ou une troisième tâche.

Versions (branches majeures)

Stroika V3 en développement actif ( non stable ), et nécessite C ++ 20 ou version ultérieure.
Stroika V2.1 est stable (en maintenance) et nécessite C ++ 17 ou version ultérieure. La version 2.1 prend également en charge conditionnellement de nombreuses fonctionnalités C ++ 20 (telles que la comparaison à trois voies, etc., si disponible).
Stoika v2.0 est très stable et nécessite C ++ 14 ou version ultérieure. Stoika V2.0 est utilisé pour alimenter une grande variété d'applications open source et commerciales.

Compilateurs / plateformes régulièrement testées / prises en charge

Linux, macOS, Windows
Stroika v3
TBD, mais jusqu'à présent ressemble à VS2K22 (17.9) ou ultérieure sur Windows, Xcode 15 (.2) ou ultérieure sur macOS et G ++ 11 ou version ultérieure, et Clang ++ 15 ou ultérieure.
Stroika v2.1
Testé sur x86, ARM (+ M1), GCC 8 à GCC 12, Clang 6 à Clang 14, Visual Studio.net 2017, Visual Studio.net 2019 et Visual Studio.net 2022, Xcode 13, 14, 15.
Stroika v2.0
Testé sur x86, bras, gcc 5 à gcc 8, clang 3 à Clang 6, xcode 8 à 9.