v0.1.43

• add task pool

v0.1.42

• add task pool

v0.1.41

• fix syncmap/syncvec drop method

v0.1.40

• SyncHashmap,SyncBtreemap use transmute_copy replace *const T
• add SyncVec struct

v0.1.39

• defer use FnMut, and use $(;)? on block

v0.1.38

• Time return self replace &mut self

v0.1.37

• rename project

v0.1.36

• fix mpsc_list_v1 error

v0.1.35

• use AtomicCell replace AtomicPtr. so, don't need Wrapped trait
• remove cancel method unsafe tag.

v0.1.33

• add spawn_blocking method Used to handle blocking operations, such as reading and writing files, and busy CPU calculations for example:

    let v = cogo::spawn_blocking!(|| {
        return 1;
    });
    assert_eq!(v.unwrap(), 1);

v0.1.32

• fix sync-btree-map insert's bug
• time add sub method

v0.1.31

• add rustls example
• fix chan!() more than length
• chan!() add method try_send()
• coroutine remove many unsafe method
• error remove trait ToString
• select{} macro don't need ;, and add support match Some()/None/Ok()/Err()
• add err!() macro

v0.1.30

• impl std error for cogo's error

v0.1.29

• change go! to use spawn local

v0.1.28

• move mpmc,mpsc to channel mod
• Condvar use SegQueue replace Mutex WaitList

v0.1.27

• add sync/Once
• add queue/ArrayQueue

v0.1.26

• Modify and copy crossBeam's SegQueue implementation to reduce a lot of stack space for channels

v0.1.24

• SyncHashMap Each value takes a very small amount of time

test bench_sync_hash_map_read   ... bench:           8 ns/iter (+/- 0)

• make SyncHashMap and SyncBtreeMap Read and write separation, space for time, suitable for the scenario of more reading and less writing

v0.1.23

• Complete stable Time
• Add err_warp! macro
• Add Ticker

let mut t = Arc::new(Ticker::new(Duration::from_secs(1)));
        let tclone = t.clone();
        go!(move ||{
             for x in tclone.as_ref() {
               println!("tick {}", x);
            }
        });
        sleep(Duration::from_secs(3));
        t.stop();

v0.1.22

• fix unix Time local

v0.1.21

• fix unix Time local time

v0.1.20

add time impl just like golang for example:

use std::time::Duration;
use cogo::std::time::time::Time;

fn main() {
    let mut t = Time::now();
    println!("{}", t);
    let js = serde_json::to_string(&t).unwrap();
    println!("{}", js);
    let from_js = serde_json::from_str::<Time>(&js).unwrap();
    assert_eq!(from_js, t);

    t.add(1 * 24 * Duration::from_secs(3600));// add one day
    println!("add one day:{}", t);
    assert_ne!(from_js, t);

    assert_eq!(true, t.before(&Time::now())); //befor

    assert_eq!(true, Time::now().after(&t)); //after

    let formated = t.format("[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour sign:mandatory]:[offset_minute]:[offset_second]");
    println!("{}", formated);
}

2022-01-14T00:55:38.276807+08:00
"2022-01-14T00:55:38.276807+08:00"
add one day:2022-01-15T00:55:38.276807+08:00
2022-01-15 00:55:38 +08:00:00

v0.1.19

• cogo/std/map Provides the same concurrency map as Golang, with SyncHashMap and SyncBtreeMap.It is suitable for concurrent environments with too many reads and too few writes.

v0.1.17

• Use a safe way to break the IO thread limit( May limits the number of CPU/IO threads to 64 ) . now you can use it for Workstations with more than 64 cpus or other scenarios. with no limit

v0.1.16

• Add multiple ways to write defer, such as defer! {}
• Fixing performance

v0.1.15

• Optimize the scheduler，Efficiency without theft
• Fixed panic caused by std::panic::set_hook() befor add if thread::panicking() { return;}

v0.1.12

• add defer!(||{ }) macro
• add chan!() macro
• optimize ChanStream
• fix take_hook panic

v0.1.9

• mpsc channel support buffer(If the buffered message exceeds the limit, the sender blocks until the message is consumed)
• mpmc channel support buffer(If the buffered message exceeds the limit, the sender blocks until the message is consumed)

v0.1.8

• channel support buffer(If the buffered message exceeds the limit, the sender blocks until the message is consumed)

v0.1.2

• Reduce the delay