Stroika Download - Stroika Quellcode Download

Stroika

Website-Daten

v2.1.15)

Herunterladen

Stroika V3 - Modernes C ++ leicht gemacht

Stroika ist ein modernes, tragbares C ++ -Anwendung -Framework. Das Schreiben von C ++ - Anwendungen erleichtert die Bereitstellung von sicheren, flexiblen Bausteinen sowie Verpackungen in anderen nützlichen Bibliotheken, die ihnen helfen, alle scheinbaren zusammenzuarbeiten.

Code -Ausschnitte / Beispiele

String -Klasse erleichtert Unicode

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 Strings, C ++ 20 Format, funktioniert mit Stroika -Typen und leichter zu bedienen

 // 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)

Iterable - einfach zu verwendende Funktionen für alle iterablen, ähnlich wie 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 " }));

Behälter

Kuh (Kopie auf dem Schreiben verbessert in den meisten häufigen Fällen häufig signifikant)
APIs definiert durch Zugriffsmuster, wie Stack = Push/Pop, Sequence = Array-ähnlicher Zugriff, MAP = {von: bis} usw.

Repräsentative Transparenz

Stroika bietet eine Reihe von Container -Archtypen und Datenstruktur -Auswirkungen.

 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 });

Weitere Informationen finden Sie unter Behälter

Streams und 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);
}

Weitere Informationen finden Sie in der Serialisierungsprobe

Erstellen Sie Webservies in Ihre Anwendung

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); }}},

Weitere Informationen finden Sie unter Webservices Beispiel.

Streams Abstraktion

Macht Komprimierung, Verschlüsselung, IO, Netzwerk, Datenverarbeitung, alle scheinbar zusammenpassen

 // @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 bietet eine Ebene über der Standard -C ++ - Bibliothek mit einfacheren Verwendung (höhere Stufe), mehr Sicherheitsüberprüfungsgarantien (in Debug -Builds) und adressierende Bereiche, die nicht standardisiert sind (z. B. Networking). Aber diese Stroika -Klassen integrieren sich nahtlos in Standard -C ++ - Klassen, und Ihr Code kann leicht so viel von beiden Bibliotheken verwenden, wie die Einstellungen vorliegen.

Stylistisch unterscheidet sich Stroika von der Standard-C ++-Bibliothek, dem Boost und vielen anderen C ++-Bibliotheken, da sie (relativ) objektorientierte Abstraktionen über die vorlagenbasierte Generatität umfasst (siehe Stroika-Ansatz-zu-Performance.md). Die Abstraktion von Typhierarchien ist besser dazu geeignet, wie Menschen die Vernunft haben, und Vorlagen und Konzepte - obwohl mächtig - können fummelige und dunkle Programmiererabsichten sein. Außerdem betont Stroika die Trennung der Schnittstelle von der Implementierung: sorgfältig die Schnittstelle in den Headern dokumentieren und die Implementierung in andere Dateien trennen.

Stroika besteht aus 2 Ebenen: der Stiftung, die Gebäudeblockungsklassen für die meisten Anwendungen und eine Reihe von domänenspezifischen Frameworks anbietet, die eine umfassende Sammlung von Code in verschiedenen Domänen bieten.

alt text

Die Rahmenbedingungen hängen von der Fundament ab; Fundamentmodule hängen häufig voneinander ab; Der Foundation Layer Code enthält jedoch keine Abhängigkeiten außerhalb der Fundament (außer in der Standard -C ++ - Bibliothek und verschiedenen Bibliotheken von ThirdPartyComponent enthalten optional enthalten oder referenziert, wie OpenSSL).

Schneller Start

Ich möchte nicht lesen - möchte nur codieren. Schritt -für -Schritt -Anweisungen zum Erstellen Ihrer ersten Stroika -basierten Anwendung auf Ihrem Computer (weniger Download/Kompilierzeiten -, die variieren).

Schnellstart.md

Qualität

Fast alle öffentlichen Schnittstellen und Methoden sind gut dokumentiert. Implementierungen sind klar und gut kommentiert.
Gründlich integrierte Behauptungen (einschließlich Behauptungen der Thread-Sicherheitsbeschäftigungen) helfen dabei, Nutzungsmuster zu dokumentieren und durchzusetzen (ohne Leistungskosten in Produktionsbauten).
Jede Veröffentlichung wird mit Valgrind (Memcheck), Google -Sanitärs (Tsan, Ubsan, Leak und Asan), Github Codesql und einer Vielzahl von Plattformen und Compilern sowie einer großen Gruppe von Regressionstests (einschließlich der meisten Dokumentationsbeispiele) getestet, um die Korrektheit der Bibliothek zu gewährleisten.
Beispielanwendungen zeigen gemeinsame Anwendungsfälle (z. B. das Erstellen eines Webservers in Ihre App, um Web-Service-Inhalte und APIs bereitzustellen).
Schnelle Start mit vorgefertigten Docker-Containern (für Windows und Linux).

Die Stroika Foundation bietet

Cache -Klassen (eine Vielzahl verschiedener Caching-/Memoisierungsstrategien, die direkt unterstützt werden).
Zeichenklassen (einfacher zu verwenden - insbesondere bei Unicode - Saiten -Klasse, mit funktionalen Style -Zuordnungen und für die meisten Stroika -Objekte toString () Dienstprogramm).
Containerklassen (Sammlung, Warteschlange, Zuordnung, Sequenz, Set und vieles mehr mit einer Vielzahl von Backend -Implementierungen).
DataExchange (VariantValue, Reiches Sammlung von Datenformat -Serializer/Deserialisierern - wie JSON, XML, Objekt zu/aus Serialisierungszuordnungen und vieles mehr).
Ausführungsmusterklassen (externer Prozessläufer, Synchronisationsmuster, Blockierung der Warteschlange, Threadpools und vieles mehr).
Networking -Support (hochrangige Socket -Wrapper, Web -Client -Abrufen).
Einfache, elegante Streams -Bibliothek mit Adaptern für Kryptographie, Komprimierung, Texttransformationen usw.
Nahlose Integration (objektorientierte Verpackungen, die Stroikas Sicherheits- und Adapterregeln respektieren) mit vielen wichtigen Bibliotheken, darunter: Boost, libcurl, LZMA SDK, OpenSSL, SQLite, Xerces, ZLIB (z.
Und mehr ...

Stroika Frameworks bietet

Netzwerkmessung
SSDP/UPNP
Systemleistung Überwachung
Textbearbeitung/Textverarbeitung
Webserver
Webdienste
Und mehr ...

Kompromisse

Stroikas größte Stärke ist auch die größte Schwäche:

Es gibt kleinere, fokussiertere Bibliotheken, die viele der Dinge tun, die Stroika tut. Einer Zweck zu sein ist eine Form der Modularität (gut) und ermöglicht eine einfache Einführung/Integration. Bibliotheken, die irgendetwas von jeder Komplexität ausführen, müssen jedoch eine eigene Infrastruktur für eine Vielzahl von Bausteinproblemen erstellen (z. B. Xerces verfügt über eigene Stream -Klassen, Pistache -Datumsklassen usw.). Und wenn Sie zwei solcher Bibliotheken haben, ist es unwahrscheinlich, dass sie scheinlos interagieren, und ihre Unterstützungskurse (für Dinge wie Datum und Streams oben) werden es sicherlich nicht tun.
Stroika nähert sich den Ansatz, seine Funktionalität in Schichten aufzubauen und andere Komponenten (z. B. Streams und Container) in unteren Schichten (sowie standardisierte C ++ - Bibliotheken) zu nutzen. Dies erhöht die Kosten für die Einführung von Stroika für etwas Kleines (weil das Ziehen eines in viele Dinge einzieht), zahlt sich dann jedoch Dividenden aus, wenn Sie sie verwenden, um eine zweite oder dritte Aufgabe zu erfüllen.

Versionen (Hauptzweige)

Stroika V3 in der aktiven Entwicklung ( nicht stabil ) und benötigt C ++ 20 oder später.
Stroika v2.1 ist stabil (in Wartung) und erfordert C ++ 17 oder höher. Version 2.1 unterstützt auch konditionell viele C ++ 20-Funktionen (z. B. Drei-Wege-Vergleich usw., falls verfügbar).
Stroika v2.0 ist sehr stabil und benötigt C ++ 14 oder höher. Stroika v2.0 wird verwendet, um eine Vielzahl von Open Source- und kommerziellen Anwendungen zu versorgen.

Compiler / Plattformen regelmäßig getestet / unterstützt

Linux, MacOS, Windows
Stroika V3
TBD, aber bisher sieht es aus wie VS2K22 (17,9) oder später auf Windows, Xcode 15 (.2) oder später auf MacOS und G ++ 11 oder höher sowie Clang ++ 15 oder höher.
Stroika v2.1
Getestet an x86, arm (+m1), gcc 8 bis gcc 12, clang 6 bis clang 14, visual studio.net 2017, visual studio.net 2019 und visual studio.net 2022, xcode 13, 14, 15.
Stroika v2.0
Getestet auf x86, Arm, GCC 5 bis GCC 8, Klang 3 bis Klang 6, Xcode 8 bis 9.