Download de Stroika - Download de código fonte de Stroika

Stroika

Dados do site

v2.1.15)

Baixar

Stroika v3 - C ++ moderno facilitado

Stroika é uma estrutura de aplicativos C ++ moderna, portátil. Ele facilita a redação de aplicativos C ++, fornecendo blocos de construção seguros, flexíveis, bem como embalagens em outras bibliotecas úteis que os ajudam a trabalhar juntos de maneira mais aparentemente.

Trechos / exemplos de código

A classe de string facilita o 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, formato c ++ 20, trabalha com tipos stroika e mais 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 - fácil de usar APIs funcacionais em todos os iteáveis, semelhante 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 " }));

Contêineres

A vaca (cópia-on-write geralmente melhora significativamente o desempenho para os casos mais comuns)
APIs definidas pelo padrão de acesso, como pilha = push/pop, sequence = acesso do tipo Array, mapa = {de: a}, etc.

Transparência representacional

Stroika fornece um rico conjunto de arquitetos de contêineres e implementações da estrutura de dados.

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

Veja a amostra de contêineres para mais detalhes

Fluxos e objectVarianMapper

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

Veja a amostra de serialização para obter mais detalhes

Crie vistos na sua aplicação

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 a amostra de serviços da web para obter mais detalhes.

Fluxos abstração

Faz compressão, criptografia, IO, networking, processamento de dados, todos se encaixam em

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

O Stroika fornece uma camada na parte superior da biblioteca C ++ padrão, com classes mais simples de usar (de nível superior), mais garantias de verificação de segurança (nas compilações de depuração) e abordando áreas não padronizadas (como a rede). Mas essas classes Stroika se integram perfeitamente às classes C ++ padrão, e seu código pode usar facilmente o máximo de qualquer uma das preferências que as preferências ditem.

Estilisticamente, o STOIKA difere da biblioteca C ++ padrão, Boost e muitas outras bibliotecas C ++, na medida em que (relativamente) abrange abstrações orientadas a objetos sobre a genicidade baseada em modelos (consulte Stroika-abordagem para desempenho.md). A abstração das hierarquias do tipo é mais adequada para a forma como as pessoas raciocinam, e modelos e conceitos - embora poderosos - podem ser cometidos complicados e obscuros. Além disso, Stroika enfatiza a separação da interface da implementação: documentando cuidadosamente a interface nos cabeçalhos e separando a implementação para outros arquivos.

Stroika é composto por 2 camadas: a fundação, que fornece classes de blocos de construção aplicáveis à maioria dos aplicativos e uma série de estruturas específicas de domínio que fornecem uma rica coleção de código em diferentes domínios.

alt text

As estruturas dependem da fundação; Os módulos de fundação frequentemente dependem um do outro; Mas o código da camada de fundação não contém dependências fora da fundação (exceto na biblioteca C ++ padrão, e várias bibliotecas de componentes de terceiros opcionalmente incluídos ou referenciados, como o OpenSSL).

Início rápido

Não quero ler - apenas quero codificar. Instruções passo a passo para criar seu primeiro aplicativo baseado em Stroika em sua máquina, em minutos (menos tempos de download/compilação - isso varia).

Quick-start.md

Qualidade

Quase todas as interfaces e métodos públicos estão bem documentados; As implementações são claras e bem comentadas.
As afirmações completamente integradas (incluindo asserções de segurança de encadeamentos) ajudam a documentar e aplicar padrões de uso (sem custo de desempenho nas compilações de produção).
Cada lançamento é testado com Valgrind (Memcheck), os desinfetantes do Google (Tsan, Ubsan, Leak e Asan), Github CodeQL e uma variedade de plataformas e compiladores, bem como um grande corpo de testes de regressão (incluindo a maioria dos exemplos de documentação) para ajudar a garantir a correção da biblioteca.
Os aplicativos de exemplo ajudam a mostrar casos de uso comuns (como criar um servidor da web em seu aplicativo para fornecer conteúdo e APIs de serviço da Web).
Comece rápido usando recipientes do Docker pré-construído (para Windows e Linux).

A Fundação Stroika fornece

Aulas de cache (uma variedade de estratégias diferentes de armazenamento em cache/memórias diretamente suportadas).
Classes de caracteres (mais simples de usar - especialmente com a classe Unicode - Strings, com mapeamentos de estilo funcional e utilitário tostring () para a maioria dos objetos de Stroika).
Classes de contêineres (coleta, fila, mapeamento, sequência, conjunto e muito mais, cada uma com rica variedade de implementações de back -end).
DataExchange (VariantValue, rica coleção de serializadores de formato de dados/Deserializadores - como JSON, XML, objeto de/a partir de mapeamentos de serialização e muito mais).
Classes de padrões de execução (corredor de processo externo, padrões de sincronização, fila de bloqueio, pools de threads e muito mais).
Suporte de rede (invólucros de soquete de alto nível, busca de clientes da web).
Biblioteca simples e elegante de fluxos, com adaptadores para criptografia, compressão, transformações de texto, etc.
Integração perfeita (invólucros orientados a objetos respeitando as regras de segurança e adaptador de Stroika) com muitas bibliotecas importantes, incluindo: Boost, Libcurl, LZMA SDK, OpenSSL, SQLite, Xerces, Zlib (por exemplo, embrulhe um fluxo de compressão - usando o exemplo Zlib).
E mais ...

O Stroika Frameworks fornece

Medição de rede
SSDP/UPNP
Monitoramento do desempenho do sistema
Edição de texto/processador de texto
servidor da web
Serviços da Web
E mais ...

Trade-offs

A maior força de Stroika também é sua maior fraqueza:

Existem bibliotecas menores e mais focadas que fazem muitas das coisas que Stroika faz. Ser um único objetivo é uma forma de modularidade (boa) e permite fácil adoção/integração. Mas as bibliotecas que fazem qualquer coisa de qualquer complexidade devem criar sua própria infraestrutura para uma ampla variedade de problemas de bloco de construção (por exemplo, Xerces tem suas próprias classes de fluxo, classes de data de pistache, etc.). E se você tiver duas dessas bibliotecas, é improvável que elas interajam com aparentemente, e suas aulas de suporte (para coisas como data e fluxos acima) certamente não o farão.
A Stroika adota a abordagem de construir sua funcionalidade em camadas, alavancando outros componentes (por exemplo, fluxos e contêineres) em camadas mais baixas (além de bibliotecas C ++ padronizadas). Isso aumenta um pouco o custo de adotar Stroika para algo pequeno (porque puxar uma coisa para atrair muitas coisas), mas paga dividendos ao usar para realizar uma segunda ou terceira tarefa.

Versões (maiores ramificações)

Stroika V3 no desenvolvimento ativo ( não estável ) e requer C ++ 20 ou posterior.
Stroika v2.1 é estável (em manutenção) e requer C ++ 17 ou posterior. A versão 2.1 também suporta condicionalmente muitos recursos C ++ 20 (como comparação de três vias etc, se disponível).
Stroika v2.0 é muito estável e requer C ++ 14 ou posterior. O Stroika v2.0 é usado para alimentar uma ampla variedade de aplicações comerciais e de código aberto.

Compiladores / plataformas testadas regularmente

Linux, macOS, Windows
Stroika v3
TBD, mas até agora se parece com vs2k22 (17,9) ou posteriormente nas janelas, xcode 15 (.2) ou posteriormente no macOS e G ++ 11 ou posterior e Clang ++ 15 ou posterior.
Stroika v2.1
Testado em x86, braço (+m1), GCC 8 a GCC 12, Clang 6 através de Clang 14, Visual Studio.net 2017, Visual Studio.net 2019 e Visual Studio.net 2022, Xcode 13, 14, 15.
Stroika v2.0
Testado em x86, braço, GCC 5 a GCC 8, Clang 3 através de Clang 6, Xcode 8 a 9.