Unduh Stroika - Unduh Kode Sumber Stroika

Stroika

Data situs web

v2.1.15)

Unduh

Stroika V3 - C ++ modern menjadi mudah

Stroika adalah kerangka aplikasi C ++ yang modern, portabel,. Itu membuat penulisan aplikasi C ++ lebih mudah dengan menyediakan blok bangunan yang aman, fleksibel, serta pembungkus di perpustakaan bermanfaat lainnya yang membantu mereka semua bekerja bersama lebih tanpa tampaknya.

Cuplikan / contoh kode

Kelas string membuat unicode lebih mudah

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 string, format C ++ 20, bekerja dengan jenis stroika, dan lebih mudah digunakan

 // 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 fungsi yang mudah digunakan di semua iterables, mirip dengan 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 " }));

Wadah

Sapi (copy-on-write sering secara signifikan meningkatkan kinerja untuk sebagian besar kasus umum)
API Ditentukan oleh Pola Akses, Seperti Stack = Push/Pop, Sequence = Akses seperti array, peta = {from: to}, dll

Transparansi Representasional

Stroika menyediakan serangkaian arktipe kontainer yang kaya, dan impmentasi struktur data.

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

Lihat sampel wadah untuk lebih jelasnya

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

Lihat sampel serialisasi untuk lebih jelasnya

Bangun webservies ke dalam aplikasi Anda

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

Lihat sampel layanan web untuk lebih jelasnya.

Aliran abstraksi

Membuat kompresi, enkripsi, IO, jaringan, pemrosesan data, semua cocok bersama -sama

 // @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 menyediakan lapisan di atas pustaka C ++ standar, dengan kelas yang lebih sederhana untuk digunakan (tingkat yang lebih tinggi), lebih banyak jaminan pemeriksaan keselamatan (dalam pembuatan debug), dan area pengalamatan yang tidak distandarisasi (seperti jaringan). Tetapi kelas -kelas Stroika tersebut dengan mulus yang terintegrasi dengan kelas C ++ standar, dan kode Anda dapat dengan mudah menggunakan sebanyak mungkin perpustakaan seperti yang ditentukan oleh preferensi.

Secara gaya, Stroika berbeda dari perpustakaan C ++ standar, Boost, dan banyak perpustakaan C ++ lainnya, dalam hal itu (relatif) mencakup abstraksi yang berorientasi pada objek atas pendikal berbasis templat (lihat stroika-approach-to-peperformance.md). Abstraksi hierarki tipe lebih cocok untuk bagaimana orang beralasan, dan templat dan konsep - sementara kuat - dapat menjadi niat programmer yang fiddly dan tidak jelas. Juga, Stroika menekankan pemisahan antarmuka dari implementasi: dengan hati -hati mendokumentasikan antarmuka di header, dan memisahkan implementasi ke file lain.

Stroika terdiri dari 2 lapisan: Yayasan, yang menyediakan kelas blok bangunan yang berlaku untuk sebagian besar aplikasi, dan serangkaian kerangka kerja khusus domain yang menyediakan koleksi kode yang kaya di berbagai domain.

alt text

Kerangka kerja bergantung pada fondasi; Modul fondasi sering bergantung satu sama lain; Tetapi kode lapisan fondasi tidak mengandung dependensi di luar yayasan (kecuali pada pustaka C ++ standar, dan berbagai pustaka komponen pihak ketiga secara opsional disertakan atau direferensikan, seperti OpenSSL).

Awal yang cepat

Tidak ingin membaca - hanya ingin kode. Instruksi langkah demi langkah untuk membangun aplikasi berbasis Stroika pertama Anda di mesin Anda, dalam hitungan menit (lebih sedikit unduhan/kompilasi waktu - yang bervariasi).

Quick-start.md

Kualitas

Hampir semua antarmuka dan metode publik didokumentasikan dengan baik; Implementasi jelas dan dikomentari dengan baik.
Pernyataan terintegrasi secara menyeluruh (termasuk pernyataan keselamatan utas) membantu mendokumentasikan dan menegakkan pola penggunaan (tanpa biaya kinerja dalam pembuatan produksi).
Setiap rilis diuji dengan Valgrind (MemCheck), Google Sanitizers (TSAN, UBSAN, BEAK, dan ASAN), GitHub CodeQL, dan berbagai platform dan kompiler, serta sejumlah besar tes regresi (termasuk sebagian besar contoh dokumentasi) untuk membantu memastikan kebenaran perpustakaan.
Contoh aplikasi membantu menunjukkan kasus penggunaan umum (seperti membangun server web ke dalam aplikasi Anda untuk mengirimkan konten layanan web dan API).
Mulailah dengan cepat menggunakan wadah Docker yang sudah dibangun (untuk Windows, dan Linux).

Stroika Foundation menyediakan

Kelas cache (berbagai strategi caching/memoisasi yang berbeda secara langsung didukung).
Kelas karakter (lebih sederhana untuk digunakan - terutama dengan kelas unicode - string, dengan pemetaan gaya fungsional, dan utilitas tostring () untuk sebagian besar objek Stroika).
Kelas kontainer (koleksi, antrian, pemetaan, urutan, set, dan banyak lagi, masing -masing dengan beragam implementasi backend).
DataExchange (VarianValue, Kumpulan Serializer Format Data/Deserializers yang kaya - seperti JSON, XML, objek ke/dari pemetaan serialisasi, dan banyak lagi).
Kelas pola eksekusi (pelari proses eksternal, pola sinkronisasi, memblokir antrian, kumpulan benang, dan banyak lagi).
Dukungan jaringan (pembungkus soket tingkat tinggi, pengambilan klien web).
Perpustakaan Aliran Sederhana dan Elegan, dengan adaptor untuk kriptografi, kompresi, transformasi teks, dll.
Integrasi yang mulus (pembungkus berorientasi objek yang menghormati aturan keselamatan dan adaptor Stroika) dengan banyak perpustakaan penting, termasuk: Boost, LibCurl, LZMA SDK, OpenSSL, SQLite, Xerces, Zlib (misalnya membungkus aliran kompresi - menggunakan misalnya Zlib).
Dan lebih banyak ...

Kerangka kerja Stroika menyediakan

Pengukuran Jaringan
SSDP/UPNP
Pemantauan Kinerja Sistem
pengeditan teks/pengolah kata
server web
Layanan Web
Dan lebih banyak ...

Trade-off

Kekuatan terbesar Stroika juga merupakan kelemahan terbesarnya:

Ada perpustakaan yang lebih kecil dan lebih fokus yang melakukan banyak hal yang dilakukan Stroika. Menjadi tujuan tunggal adalah bentuk modularitas (baik) dan memungkinkan adopsi/integrasi yang mudah. Tetapi perpustakaan yang melakukan apa pun dari kompleksitas apa pun harus membuat infrastruktur mereka sendiri untuk berbagai masalah blok bangunan (misalnya Xerces memiliki kelas aliran sendiri, kelas tanggal pistache, dll). Dan jika Anda memiliki dua perpustakaan seperti itu, mereka tidak mungkin berinteraksi tanpa tampaknya, dan kelas dukungan mereka (untuk hal -hal seperti tanggal dan stream di atas) tentu saja tidak.
Stroika mengambil pendekatan membangun fungsinya di lapisan, memanfaatkan komponen lain (misalnya aliran dan wadah) di lapisan bawah (serta perpustakaan C ++ standar). Ini sedikit meningkatkan biaya mengadopsi Stroika untuk sesuatu yang kecil (karena menarik satu hal dalam menarik banyak hal), tetapi kemudian membayar dividen saat Anda menggunakannya untuk menyelesaikan tugas kedua atau ketiga.

Versi (cabang utama)

Stroika V3 dalam pengembangan aktif ( tidak stabil ), dan membutuhkan C ++ 20 atau lebih baru.
Stroika v2.1 stabil (dalam pemeliharaan), dan membutuhkan C ++ 17 atau lebih baru. Versi 2.1 juga secara kondisional mendukung banyak fitur C ++ 20 (seperti komparis tiga arah dll, jika tersedia).
Stroika v2.0 sangat stabil, dan membutuhkan C ++ 14 atau lebih baru. Stroika V2.0 digunakan untuk memberi daya pada berbagai macam aplikasi open source dan komersial.

Kompiler / platform yang diuji / didukung secara teratur

Linux, MacOS, Windows
Stroika v3
TBD, tetapi sejauh ini terlihat seperti VS2K22 (17.9) atau lebih baru di Windows, Xcode 15 (.2) atau lebih baru pada MacOS, dan G ++ 11 atau lebih, dan Clang ++ 15 atau lebih baru.
Stroika v2.1
Diuji pada x86, ARM (+M1), GCC 8 melalui GCC 12, Clang 6 Thru Clang 14, Visual Studio.net 2017, Visual Studio.net 2019 dan Visual Studio.net 2022, Xcode 13, 14, 15.
Stroika v2.0
Diuji pada x86, lengan, GCC 5 melalui GCC 8, dentang 3 melalui dentang 6, xcode 8 melalui 9.