semantic-cpp

KO | EN

gitlite — search

#python #hacktoberfest #llm #go #android #rust #deep-learning #linux #docker #kubernetes #awesome-list #pytorch #mcp #openai

(★ 9)

Semantic-Cpp is a completely redesigned modern C++ stream processing library, built upon a "multi-header, zero external dependency" modular architecture. Each header file has a clear, single responsibility and can be tested independently, together forming a complete stream processing ecosystem.

semantic-cpp 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 🚀 Semantic-Cpp: A Future-Oriented Intelligent Stream Processing Framework for C++

Semantic-Cpp is a modern C++ stream processing library, completely redesigned from the ground up, featuring a **"multiple headers, zero external dependencies"** modular architecture. Each header file has a clear, singular responsibility and is independently testable, together forming a complete stream processing ecosystem. This library innovatively blends the essence of multiple programming paradigms:

*   **The Elegance and Fluidity of Java Stream API**: Chain calls, declarative programming, making code as graceful as poetry ✨
*   **The Laziness and Flexibility of JavaScript Generators**: Lazy evaluation, on-demand generation, memory-friendly 🌱
*   **The Efficiency and Order of Database Indexing**: Intelligent sorting, index-driven, a powerful tool for time-series data processing ⏱️
*   **The Batch Processing Philosophy of "Container-as-Element"**: Vectors, lists, maps... Any container can be a first-class citizen in the stream, flowing freely 📦

Are you tired of writing `for` loops to iterate over a `vector`, nesting an `if` for filtering, and manually `push_back` to another container? 😩
Have you ever debugged an off-by-one index bug late at night, just because you wanted the "third from the end" element while iterating backwards? 😵💫
Do you yearn to manipulate data like a database—pinpointing by index, analysing with sliding windows, completing the entire journey from data to statistics with a single chain of calls? 🤔

**Semantic-Cpp was born for this purpose. 🔧**

It abstracts data processing as operations on "elements" and their "logical positions (indices)"—much like "rows" and "primary keys" in a database. You can freely rearrange, offset, and reverse indices without touching the data itself; you can also pass any container (`vector`, `map`, `array`...) as an indivisible whole within the stream, and "unpack" it back to the element level at any time. This ability to freely switch between two granularities is absent in traditional stream frameworks. 🎯

---

## 🏗️ Project Architecture: Seven-Layer Modular Design

Semantic-Cpp consists of seven core header files, layered progressively. Each file has a single responsibility and is independently testable. Five namespaces, each with its own remit, work together to form a complete pipeline from data source to final result:

```
┌─────────────────────────────────────────────────┐
│               🌊 semantics.h                     │
│   Namespace: semantic                           │
│   Stream Construction Factories: numeric ranges, │
│   containers, text, Unicode                     │
├─────────────────────────────────────────────────┤
│                 📦 semantic.h                   │
│   Namespace: semantic / collectable            │
│   Stream Intermediate Operations, Collectable  │
│   system, container unwrapping support         │
├─────────────────────────────────────────────────┤
│                ⚙️ collector.h                   │
│   Namespace: collector                          │
│   Collector Framework + Factories: matching,   │
│   finding, aggregation, statistics, DFT/FFT   │
├─────────────────────────────────────────────────┤
│                🔤 charsequence.h               │
│   Namespace: charsequence                      │
│   Unicode character sequences, multi-encoding  │
│   conversion, Builder, Buffer                  │
├─────────────────────────────────────────────────┤
│                🧵 pool.h                        │
│   Namespace: pool                              │
│   Global Thread Pool: task submission,         │
│   emergency shutdown, exception propagation    │
├─────────────────────────────────────────────────┤
│                📄 function.h                    │
│   Namespace: function                          │
│   Type Definitions: aliases for Generator,     │
│   Supplier, Consumer, etc.                    │
├─────────────────────────────────────────────────┤
│               🔐 hash.h / less.h               │
│   Namespace: std (extensions)                  │
│   Standard Library Container Hash & Comparison │
│   specialisations, supporting arbitrary nesting│
└─────────────────────────────────────────────────┘
```

### 🧩 Dependency Graph
The dependency chain is clear and logical, like a meticulously designed circuit diagram: current flows from the foundational type definitions upwards, with each layer depending only on the layers beneath it. Ultimately, all paths converge at `semantic.h` and `semantics.h`, forming the complete stream processing capability.

```
function.h          ← No dependencies, the type foundation
pool.h              ← Depends on function.h
charsequence.h      ← Independent module, Unicode processing
collector.h         ← Depends on function.h, pool.h
hash.h / less.h     ← Independent modules, standard library extensions
semantic.h          ← Depends on all of the above
semantics.h         ← Depends on semantic.h
```

---

## 🌍 Namespace Overview

Semantic-Cpp meticulously designs five namespaces, each like an independent "department", with distinct responsibilities yet closely collaborating:

### 🔁 Namespace Collaboration Flow
Data flow between namespaces is like an assembly line in a factory—raw material enters from `semantic`, undergoes processing layer by layer, and is finally packaged and shipped from `collector`. Each step has a clear boundary of responsibility:

```cpp
semantic::useRange(0, 100)          // ← semantic namespace: create stream
    .map(int x { return x * 2; })   // ← semantic namespace: intermediate transform
    .filter(int x { return x > 50; }) // ← semantic namespace: intermediate filter
    .toUnordered()                  // ← Convert to collectable namespace
    .toVector();                    // ← Invoke collector from collector namespace
```

---

## 📦 Layer 1: function.h — Type Foundation

`function.h` defines the type system for the entire framework, the common foundation for all modules. 🔑

```cpp
namespace function {
    using Timestamp = long long;           // Index type, the "timestamp" of data in the stream
    using Module = unsigned long long;     // Module/count type
    
    template <typename T>
    using Generator = std::function<void(
        std::function<void(T, Timestamp)>,      // accept — receive an element
        std::function<bool(T, Timestamp)>       // interrupt — should we stop?
    )>;
}
```

`Generator` is the core abstraction of the entire stream system. 🌀 It does not return data; instead, it accepts two callbacks—`accept` ("I'm ready, please accept this element") and `interrupt` ("should we stop?"). This inversion of control design means the data producer has no knowledge of the consumer; it simply "pushes" data at the appropriate moment. This is the essence of lazy evaluation: data only truly "flows" when `accept` is called; before that, everything is merely a description.

---

## 🧵 Layer 2: pool.h — Concurrency Foundation

`pool.h` provides the global thread pool `pool::pool`, the concurrency engine for the entire framework. 🚀 It employs a **declarative parallelism** design—when you write `.parallel(4)`, it does not immediately launch four threads to start processing. This line of code is merely a "declaration": telling the framework "I intend to use 4 threads for parallel processing". Actual parallel execution occurs when a terminal operation is invoked—that is, when you call collection methods like `toVector()`, `findFirst()`, `count()`, etc.

---

## 🔤 Layer 3: charsequence.h — Unicode Character Sequences

`charsequence.h` is a complete Unicode processing module, providing functionality for creating, converting, and manipulating character sequences. 🌍 It supports various encodings like UTF-8, UTF-16 (LE/BE), UTF-32 (LE/BE), ASCII, and Latin1. It correctly detects and handles surrogate pairs, returning the standard U+FFFD replacement character for invalid code points.

| Type/Function    | Description                                                                 |
| :--------------- | :-------------------------------------------------------------------------- |
| charset          | Enum: ascii, utf8, utf16, utf16be, utf16le, utf32, utf32be, utf32le, latin1 |
| Meta             | Metadata wrapper, stores unsigned integer values                            |
| Point            | Unicode code point, supports surrogate pair detection and validity checks   |
| Charsequence     | Immutable character sequence: split, replace, indexOf, lastIndexOf, sub, trim, toUpperCase, toLowerCase, reverse, startsWith, endsWith, contains, compare, getBytes, getPoints, getMetas, getCharacters, repeat, concat, count, join |
| Builder          | Mutable byte builder: prepend, insert, append (supports primitives, Point, Charsequence, string_view) |
| Buffer           | Thread-safe ring buffer: write, read, peek, prepend, append, clear, shrinkToFit, data, size, capacity, atomic |
| PointIterator    | Bidirectional iterator for traversing Unicode code points                   |
| encode()         | Encode a single code point to a byte sequence of the specified encoding    |
| decode()         | Decode the next code point from a byte sequence, auto-advancing pointer     |
| convert()        | Encoding conversion (supports string, vector, deque output)                 |

---

## ⚙️ Layer 4: collector.h — Collector Framework & Factories

`collector.h` is the core collector module of Semantic-Cpp, combining the collector framework with factory functions.

### 🧩 Five-Stage Model
```
Identity → Accumulator → Combiner → Finisher
              ↑
           Interrupt (optional short-circuit)
```

### Collector Factory Functions

---

## 📦 Layer 5: semantic.h — Stream Intermediate Operations & Collection System

### 🧩 Core Design: Three-Stage Pipeline
```
Semantic<E> (Construction & Transformation)
    ↓ toUnordered() / toOrdered() / sort() / toWindow() / toStatistics()
Collectable<E> (Materialisation & Collection)
    ↓ toVector() / findFirst() / count() / summate() / ...
Final Result
```

**Key Rule**: A `Semantic<E>` must first be converted to a `Collectable<E>` via `toUnordered()`, `toOrdered()`, `toWindow()`, `toStatistics()`, or `sort()` before terminal methods can be called.

All the above methods also support an optional `mapper` parameter version.

---

## 🔧 Layer 6: semantics.h — Stream Construction Factories

### 📦 Container & Element Construction
| Method                    | Description                     |
| :------------------------ | :----------------------------- |
| `useEmpty()`              | Create an empty stream         |
| `useOf(element)`          | Create stream from a single element |
| `useOf(e1, e2)`           | Create stream from two elements |
| `useOf(e1, e2, e3)`       | Create stream from three elements |
| `useOf({...})`            | Create stream from initialiser list |
| `useFrom(container)`      | Create stream from standard container |
| `useFrom({...})`          | Create stream from initialiser list |
| `useRepeat(element, count)` | Repeat element n times         |

---

## 🔐 Layer 7: hash.h / less.h — The Universal Language of the Container World

Provides complete hash and comparison support for all standard library containers (including nested containers), `pair`, `tuple`, `optional`, `variant`, `chrono` time types, `complex` numbers, and more. Containers nested to any depth and in any combination can now be used as keys in `unordered_set` or elements in `set`. 🌉

---

## 🚀 Performance Optimisation Tips

1.  **Choose the Right Container**: Use `toUnordered()` if order doesn't matter, `toOrdered()` or `sort()` if sorting is needed.
2.  **Leverage Parallelism**: Use `parallel()` for large datasets.
3.  **Optimise Operation Order**: Filter early, sort wisely.
4.  **Utilise Lazy Evaluation**: `takeWhile` and `limit` can terminate early.

---

Semantic-Cpp — Building efficient, clear data processing pipelines with modern C++. 🚀🎯✨

semantic-cpp

semantic-cpp 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

semantic-cpp

semantic-cpp 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README