FlowBridge

✨ Features

📦 Installation

dependencies: [
 .package(url: "https://github.com/danrom11/FlowBridge.git", from: "2.1.0")
]

🔧 Usage

1. Define a signal in C++

#include "FlowBridge.hpp"
FLOW_SIGNAL(tick_score);

2. Emit from C++

FlowBridge::emit(tick_score, "Hello from C++");

3. Connect in Swift

import FlowBridge
struct FlowSignals {
 static let tick_score = "tick_score"
}
FlowBridge.connect(FlowSignals.tick_score) { data in
 if let text = data as? String {
 print("Received:", text)
 }
}

import FlowBridge
struct FlowSignals {
 static let tick_score = "tick_score"
}
 
@objc func test(_ data: Any?) {
 print("Data: \(data ?? "none")")
 
 if let stringData = data as? String {
 DispatchQueue.main.async {
 self.nameLabel.text = stringData
 }
 }
}
override func viewDidLoad() {
 super.viewDidLoad()
 nameLabel.text = "0"
 
 FlowBridge.connect(FlowSignals.tick_score, target: self, slot: #selector(test(_:)))
 
 let manager = ManagerWrapper.shared
 manager().start(withInterval: 1000)
}

📦 Passing Complex Structures with TLV

Example: Sending a Document from C++ to Swift

#include "FlowBridge.hpp"
#include "tlv.hpp"
// Create a document structure
tlv::Map document{
 {"user_id", int64_t(42)},
 {"name", std::string("Alice")},
 {"role", std::string("developer")},
 {"skills", tlv::Array{
 std::string("C++"),
 std::string("Swift"),
 std::string("Objective-C")
 }},
 {"active", true},
 {"rating", 4.8}
};
// Emit signal with TLV-encoded data
FlowBridge::emit("user_profile", tlv::encode(tlv::Value(document)));

import FlowBridge
FlowBridge.connect("user_profile") { data in
 // Receive automatically decoded dictionary
 if let profile = data as? [String: Any] {
 let userId = profile["user_id"] as? Int ?? 0
 let name = profile["name"] as? String ?? ""
 let role = profile["role"] as? String ?? ""
 let skills = profile["skills"] as? [String] ?? []
 let active = profile["active"] as? Bool ?? false
 let rating = profile["rating"] as? Double ?? 0.0
 
 print("User: \(name) (ID: \(userId))")
 print("Role: \(role)")
 print("Skills: \(skills.joined(separator: ", "))")
 print("Active: \(active), Rating: \(rating)")
 }
}

Example: Sending Data from Swift to C++

import FlowBridge
// Send a request with parameters
FlowBridge.emit("api_request", data: [
 "endpoint": "/users",
 "method": "GET",
 "params": [
 "page": 1,
 "limit": 20,
 "sort": "name"
 ],
 "headers": [
 "Authorization": "Bearer token123",
 "Accept": "application/json"
 ]
])

#include "FlowBridge.hpp"
#include "tlv.hpp"
// Connect to signal with TLV handling
static FlowBridge::Connection connection = 
 FlowBridge::connect<std::vector<uint8_t>>("api_request",
 [](const std::vector<uint8_t>& buffer) {
 try {
 tlv::Value value = tlv::decode(buffer);
 
 // Check if we received a dictionary
 if (auto request = std::get_if<tlv::Map>(&value)) {
 
 // Extract endpoint
 auto endpoint_it = request->find("endpoint");
 if (endpoint_it != request->end()) {
 if (auto endpoint = std::get_if<std::string>(&endpoint_it->second)) {
 std::cout << "Endpoint: " << *endpoint << std::endl;
 }
 }
 
 // Extract parameters
 auto params_it = request->find("params");
 if (params_it != request->end()) {
 if (auto params = std::get_if<tlv::Map>(&params_it->second)) {
 auto page_it = params->find("page");
 if (page_it != params->end()) {
 if (auto page = std::get_if<int64_t>(&page_it->second)) {
 std::cout << "Page: " << *page << std::endl;
 }
 }
 }
 }
 }
 } catch (const std::exception& e) {
 std::cerr << "Failed to decode TLV: " << e.what() << std::endl;
 }
 });

Supported Types

TLV Advantages

📂 Examples