Rust插件库libsw-core的使用：高效轻量级核心功能扩展与模块化开发

Rust插件库libsw-core的使用：高效轻量级核心功能扩展与模块化开发

简介

libsw_core 是一个全面且安全的秒表实现库。该库支持 Rust 的最低版本为 1.61.0。

许可证

采用 MIT 或 Apache 2.0 双重许可。

安装

在项目目录中运行以下 Cargo 命令：

cargo add libsw-core

或者在 Cargo.toml 中添加以下行：

libsw-core = "0.3.2"

示例代码

以下是使用 libsw-core 的完整示例：

use libsw_core::Stopwatch;
use std::time::Duration;
use std::thread;

fn main() {
    // 创建新的秒表实例
    let mut stopwatch = Stopwatch::new();
    
    // 开始计时
    stopwatch.start();
    
    // 模拟一些工作
    thread::sleep(Duration::from_secs(1));
    
    // 获取经过的时间
    let elapsed = stopwatch.elapsed();
    println!("经过时间: {:?}", elapsed);
    
    // 暂停计时
    stopwatch.pause();
    
    // 做一些不计算时间的工作
    thread::sleep(Duration::from_secs(1));
    
    // 继续计时
    stopwatch.resume();
    
    // 更多工作
    thread::sleep(Duration::from_secs(1));
    
    // 最终经过时间
    let total_elapsed = stopwatch.elapsed();
    println!("总经过时间: {:?}", total_elapsed);
    
    // 重置秒表
    stopwatch.reset();
    
    // 检查是否正在运行
    println!("秒表正在运行吗? {}", stopwatch.is_running());
}

特性

  1. 轻量级实现
  2. 支持暂停/继续功能
  3. 精确的时间测量
  4. 无标准库支持(no-std)
  5. 无动态内存分配(no-alloc)

文档

完整文档可查看官方文档。

仓库

项目源代码托管在 GitHub 上。

完整示例demo

以下是一个更完整的示例，展示了libsw-core库的典型使用场景：

use libsw_core::Stopwatch;
use std::time::Duration;
use std::thread;

fn main() {
    // 实例化一个秒表
    let mut sw = Stopwatch::new();
    
    // 场景1：基本计时功能
    println!("=== 基本计时功能演示 ===");
    sw.start();
    thread::sleep(Duration::from_millis(500));
    println!("500ms后的时间: {:?}", sw.elapsed());
    
    // 场景2：暂停/恢复功能
    println!("\n=== 暂停/恢复功能演示 ===");
    sw.pause();
    thread::sleep(Duration::from_millis(300));
    println!("暂停300ms后，时间应为500ms左右: {:?}", sw.elapsed());
    
    sw.resume();
    thread::sleep(Duration::from_millis(200));
    println!("恢复后200ms，时间应为700ms左右: {:?}", sw.elapsed());
    
    // 场景3：重置功能
    println!("\n=== 重置功能演示 ===");
    sw.reset();
    println!("重置后时间: {:?}", sw.elapsed());
    println!("重置后运行状态: {}", sw.is_running());
    
    // 场景4：自动启动计时
    println!("\n=== 自动启动计时演示 ===");
    let sw_auto = Stopwatch::start_new();
    thread::sleep(Duration::from_millis(100));
    println!("自动启动100ms后: {:?}", sw_auto.elapsed());
    
    // 场景5：格式化输出
    println!("\n=== 格式化输出演示 ===");
    let mut sw_fmt = Stopwatch::new();
    sw_fmt.start();
    thread::sleep(Duration::from_secs(2));
    println!("格式化后的时间: {}秒", sw_fmt.elapsed().as_secs());
}

1 回复

以下是基于您提供内容的完整示例demo，展示了libsw-core的完整使用流程：

完整示例：插件化应用开发

// 1. 初始化插件系统
use libsw_core::{Plugin, PluginInfo, PluginManager, Module, Config, Event, EventHandler, EventDispatcher};

// 2. 定义自定义插件
struct LoggerPlugin;

impl Plugin for LoggerPlugin {
    fn info(&self) -> PluginInfo {
        PluginInfo {
            name: "Logger Plugin".to_string(),
            version: "1.0".to_string(),
            author: "System".to_string(),
        }
    }
    
    fn initialize(&mut self) {
        println!("Logger Plugin initialized!");
    }
    
    fn execute(&self) {
        println!("Logging system events...");
    }
}

// 3. 定义数据库模块
struct DatabaseModule;

impl Module for DatabaseModule {
    fn name(&self) -> &str {
        "database"
    }
    
    fn configure(&self, config: &mut Config) {
        config.set("database.url", "postgres://localhost:5432/mydb");
        config.set("database.pool_size", "10");
    }
}

// 4. 定义事件系统
struct UserLoginEvent {
    user_id: u64,
    ip: String,
}

impl Event for UserLoginEvent {}

struct SecurityLogger;

impl EventHandler for SecurityLogger {
    fn handle(&self, event: &dyn Event) {
        if let Some(login_event) = event.as_any().downcast_ref::<UserLoginEvent>() {
            println!("Security log: User {} logged in from {}", 
                    login_event.user_id, login_event.ip);
        }
    }
}

// 主程序
fn main() {
    // 初始化插件管理器
    let mut plugin_manager = PluginManager::new();
    plugin_manager.initialize();
    
    // 手动注册插件（实际场景中可能通过动态加载）
    plugin_manager.register_plugin(Box::new(LoggerPlugin));
    
    // 初始化模块系统
    let mut app = libsw_core::Application::new();
    app.register_module(Box::new(DatabaseModule));
    
    // 获取配置
    let db_url = app.config().get("database.url").unwrap();
    println!("Using database: {}", db_url);
    
    // 初始化事件系统
    let mut event_dispatcher = EventDispatcher::new();
    event_dispatcher.register_handler(Box::new(SecurityLogger));
    
    // 触发事件
    let login_event = UserLoginEvent {
        user_id: 42,
        ip: "192.168.1.100".to_string(),
    };
    event_dispatcher.dispatch(&login_event);
    
    // 运行插件
    plugin_manager.run();
    
    // 使用核心功能扩展
    use libsw_core::utils::AdvancedString;
    let s = AdvancedString::new("libsw-core is awesome!");
    println!("Uppercase: {}", s.to_uppercase());
    println!("Contains 'awesome'? {}", s.contains("awesome"));
}

示例说明

  1. 插件系统：创建了一个LoggerPlugin实现基本的日志功能
  2. 模块系统：DatabaseModule提供了数据库配置管理
  3. 事件系统：当用户登录时触发UserLoginEvent并由SecurityLogger处理
  4. 核心功能：使用了AdvancedString提供的字符串扩展方法

运行结果预期

Logger Plugin initialized!
Using database: postgres://localhost:5432/mydb
Security log: User 42 logged in from 192.168.1.100
Logging system events...
Uppercase: LIBSW-CORE IS AWESOME!
Contains 'awesome'? true

这个完整示例展示了如何将libsw-core的各个功能组件整合到一个应用程序中，实现插件化、模块化和事件驱动的架构。

回到顶部