Descargar Stroika - Descargar código fuente de Stroika

Stroika

Datos del sitio web

v2.1.15)

Descargar

Stroika V3 - Modern C ++ hecho fácil

Stroika es un marco de aplicaciones moderno, portátil, C ++. Hace que escribir aplicaciones C ++ sea más fácil al proporcionar bloques de construcción seguros, flexibles, así como envoltorios en otras bibliotecas útiles que los ayudan a trabajar juntos más sin problemas.

Fragmentos de código / ejemplos

La clase de cadena facilita 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 cadenas, formato C ++ 20, funciona con tipos de stroika y más fácil de usar

 // 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 - API funcionales fáciles de usar en todos los iterables, similar a 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 " }));

Contenedores

Vaca (la copia en la escritura a menudo mejora significativamente el rendimiento para la mayoría de los casos comunes)
API definidas por el patrón de acceso, como stack = push/pop, secuence = array-like access, map = {de: a}, etc.

Transparencia representativa

Stroika proporciona un rico conjunto de arcos de contenedores e implicaciones de estructura de datos.

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

Consulte la muestra de contenedores para más detalles

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

Ver muestra de serialización para más detalles

Cree servidores web en su aplicación

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

Consulte la muestra de WebServices para obtener más detalles.

Transmisión de la abstracción

Hacer compresión, cifrado, IO, redes, procesamiento de datos, todo un ajuste de forma sin sentido

 // @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 proporciona una capa además de la biblioteca C ++ estándar, con clases más simples de usar (de nivel superior), más garantías de verificación de seguridad (en construcciones de depuración) y abordando áreas no estandarizadas (como redes). Pero esas clases de Stroika se integran sin problemas con las clases estándar de C ++, y su código puede usar fácilmente la mayor cantidad de biblioteca como lo dicten las preferencias.

Estilísticamente, Stroika difiere de la biblioteca estándar de C ++, Boost y muchas otras bibliotecas de C ++, en el sentido de que (relativamente) abarca abstracciones orientadas a objetos sobre la genericidad basada en plantillas (ver Stroika-Aprecar a rendimiento.md). La abstracción de las jerarquías de tipo es más adecuada para cómo razonan las personas, y las plantillas y conceptos, aunque potentes, pueden ser intenciones de programador complementarias y oscuras. Además, Stroika enfatiza la separación de la interfaz de la implementación: documentar cuidadosamente la interfaz en los encabezados y separar la implementación a otros archivos.

Stroika se compone de 2 capas: la base, que proporciona clases de bloques de construcción aplicables a la mayoría de las aplicaciones, y una serie de marcos específicos de dominio que proporcionan una rica colección de código en diferentes dominios.

alt text

Los marcos dependen de la base; Los módulos de base frecuentemente dependen unos de otros; Pero el código de capa de la base no contiene dependencias fuera de la base (excepto en la biblioteca C ++ estándar, y varias bibliotecas de componentes de terceros opcionalmente incluidas o referenciadas, como OpenSSL).

Comienzo rápido

No quiero leer, solo quiero codificar. Instrucciones paso a paso para construir su primera aplicación basada en Stroika en su máquina, en minutos (menos descargas/tiempos de compilación, que varía).

Start.md

Calidad

Casi todas las interfaces y métodos públicos están bien documentados; Las implementaciones son claras y bien comentadas.
Las afirmaciones completamente integradas (incluidas las afirmaciones de seguridad de hilos) ayudan al documento y hacen cumplir los patrones de uso (sin costos de rendimiento en las compilaciones de producción).
Cada lanzamiento se prueba con Valgrind (MemCheck), Google Sanitizers (TSAN, UBSAN, Leak y Asan), GitHub CodeQL y una variedad de plataformas y compiladores, así como un gran cuerpo de pruebas de regresión (incluidos los ejemplos de documentación) para ayudar a asegurar la corrección de la biblioteca.
Las aplicaciones de muestra ayudan a mostrar casos de uso comunes (como construir un servidor web en su aplicación para entregar contenido y API de servicio web).
Comience rápidamente con los contenedores Docker pre-construidos (para Windows y Linux).

Stroika Foundation proporciona

Clases de caché (una variedad de diferentes estrategias de almacenamiento en caché/memorando directamente compatibles).
Clases de caracteres (más sencillo de usar, especialmente con una clase de cadenas unicode, con mapeos de estilo funcional y utilidad toString () para la mayoría de los objetos stroika).
Clases de contenedores (colección, cola, mapeo, secuencia, conjunto y mucho más, cada una con rica variedad de implementaciones de backend).
DataExchange (VariantValue, rica recopilación de serializador/deserializadores de formato de datos, como JSON, XML, Objeto hacia/desde asignaciones de serialización y mucho más).
Clases de patrones de ejecución (corredor de procesos externos, patrones de sincronización, cola de bloqueo, grupos de subprocesos y mucho más).
Soporte de redes (envoltorios de socket de alto nivel, obtención de clientes web).
Biblioteca de transmisiones simples y elegantes, con adaptadores para criptografía, compresión, transformaciones de texto, etc.
Integración perfecta (envoltorios orientados a objetos que respetan las reglas de seguridad y adaptador de Stroika) con muchas bibliotecas importantes, que incluyen: Boost, LibCurl, LZMA SDK, OpenSSL, SQLite, Xerces, ZLIB (por ejemplo, envolver un flujo de compresión, utilizando por ejemplo ZLIB).
y más ...

Stroika Frameworks proporciona

medición de red
SSDP/UPNP
monitoreo del rendimiento del sistema
Edición de texto/procesador de textos
servidor web
servicios web
y más ...

Compensaciones

La mayor fortaleza de Stroika también es su mayor debilidad:

Hay bibliotecas más pequeñas y más centradas que hacen muchas de las cosas que hace Stroika. Ser un solo propósito es una forma de modularidad (buena) y permite una fácil adopción/integración. Pero las bibliotecas que hacen cualquier cosa de cualquier complejidad deben crear su propia infraestructura para una amplia variedad de problemas de bloques de construcción (por ejemplo, Xerces tiene sus propias clases de flujo, clases de fechas de pistache, etc.). Y si tiene dos de estas bibliotecas, es poco probable que interactúen sin sentido, y sus clases de soporte (para cosas como la fecha y las transmisiones anteriores) ciertamente no lo harán.
Stroika adopta el enfoque de construir su funcionalidad en capas, aprovechando otros componentes (por ejemplo, transmisiones y contenedores) en capas inferiores (así como bibliotecas C ++ estandarizadas). Esto aumenta ligeramente el costo de adoptar Stroika para algo pequeño (porque atraer una cosa atrae a muchas cosas), pero luego paga dividendos a medida que lo usa para lograr una segunda o tercera tarea.

Versiones (ramas principales)

Stroika V3 en desarrollo activo ( no estable ), y requiere C ++ 20 o posterior.
Stroika v2.1 es estable (en mantenimiento) y requiere C ++ 17 o posterior. La versión 2.1 también admite condicionalmente muchas características de C ++ 20 (como comparación de tres vías, etc., si está disponible).
Stroika v2.0 es muy estable y requiere C ++ 14 o posterior. Stroika v2.0 se utiliza para alimentar una amplia variedad de aplicaciones comerciales y de código abierto.

Compiladores / plataformas probadas / compatibles regularmente

Linux, macOS, Windows
Stroika v3
TBD, pero hasta ahora se ve como VS2K22 (17.9) o más tarde en Windows, Xcode 15 (.2) o más tarde en macOS, y G ++ 11 o posterior, y Clang ++ 15 o posterior.
Stroika v2.1
Probado en X86, ARM (+M1), GCC 8 a través de GCC 12, Clang 6 a través de Clang 14, Visual Studio.net 2017, Visual Studio.net 2019 y Visual Studio.net 2022, Xcode 13, 14, 15.
Stroika v2.0
Probado en x86, brazo, GCC 5 a través de GCC 8, clang 3 a través de clang 6, xcode 8 a 9.