fn load_observer(module: &String, cfg: &ConfigCore) -> Observer
    {
        match module.as_str() {
            "libraceunlock" => Observer {
                name: module.clone(),
                obs: libraceunlocker::observers(&cfg.raceunlock),
            },
            "libsyncer" => Observer {
                name: module.clone(),
                obs: libsyncer::observers(),
            },
            "libfilter" => Observer {
                name: module.clone(),
                obs: libfilter::observers(&cfg.filter),
            },
            "libsleeper" => Observer {
                name: module.clone(),
                obs: libsleeper::observers(&cfg.sleeper),
            },
            "liblimiter" => Observer {
                name: module.clone(),
                obs: liblimiter::observers(&cfg.limiter),
            },
            "libdebug" => Observer {
                name: module.clone(),
                obs: libdebug::observers(&cfg.debug),
            },
            "libmediator" => Observer {
                name: module.clone(),
                obs: libmediator::observers(&cfg.mediator),
            },
            "libbfl" => Observer {
                name: module.clone(),
                obs: libbfl::observers(&cfg.bfl),
            },
            "libsmb" => Observer {
                name: module.clone(),
                obs: libsmb::observer(),
            },
            _ => Observer {
                name: module.clone(),
                obs: (None, None),
            },
        }
    }
/// anytime new plugin is added must be inserted loading-code here
///
/// - in the future this may be separete dll for better decoupling
///     - adding modules add-hot style ( we just replace/add module but fuzzer remains same )
///     - also thats why we forwarding push_state as static function..
/// - optimal will be, that if new module added no need to recompile fuzzer
///     - aka i can use 3 years old fuzzer with latest new module
///     - though if it really brings some benefits, loosing sources to fuzzer and use it later
///     is problem in its own sense
anytime new plugin is added must be inserted loading-code here
in the future this may be separete dll for better decoupling
adding modules add-hot style ( we just replace/add module but fuzzer remains same )
also thats why we forwarding push_state as static function
optimal will be, that if new module added no need to recompile fuzzer
aka i can use 3 years old fuzzer with latest new module
though if it really brings some benefits, loosing sources to fuzzer and use it later
is problem in its own sense
anytime new plugin is added must be inserted loading - code here in the future this may be separete dll for better decoupling adding modules add - hot style ( we just replace / add module but fuzzer remains same ) also thats why we forwarding push_state as static function optimal will be that if new module added no need to recompile fuzzer aka i can use 3 years old fuzzer with latest new module though if it really brings some benefits loosing sources to fuzzer and use it later is problem in its own sense
fn load_observer(module: &String, cfg: &ConfigCore) -> Observer
    {
        match module.as_str() {
            "libraceunlock" => Observer {
                name: module.clone(),
                obs: libraceunlocker::observers(&cfg.raceunlock),
            },
            "libsyncer" => Observer {
                name: module.clone(),
                obs: libsyncer::observers(),
            },
            "libfilter" => Observer {
                name: module.clone(),
                obs: libfilter::observers(&cfg.filter),
            },
            "libsleeper" => Observer {
                name: module.clone(),
                obs: libsleeper::observers(&cfg.sleeper),
            },
            "liblimiter" => Observer {
                name: module.clone(),
                obs: liblimiter::observers(&cfg.limiter),
            },
            "libdebug" => Observer {
                name: module.clone(),
                obs: libdebug::observers(&cfg.debug),
            },
            "libmediator" => Observer {
                name: module.clone(),
                obs: libmediator::observers(&cfg.mediator),
            },
            "libbfl" => Observer {
                name: module.clone(),
                obs: libbfl::observers(&cfg.bfl),
            },
            "libsmb" => Observer {
                name: module.clone(),
                obs: libsmb::observer(),
            },
            _ => Observer {
                name: module.clone(),
                obs: (None, None),
            },
        }
    }
fn load_observer ( module : & String , cfg : & ConfigCore ) -> Observer { match module . as_str ( ) { " " => Observer { name : module . clone ( ) , obs : libraceunlocker :: observers ( & cfg . raceunlock ) , } , " " => Observer { name : module . clone ( ) , obs : libsyncer :: observers ( ) , } , " " => Observer { name : module . clone ( ) , obs : libfilter :: observers ( & cfg . filter ) , } , " " => Observer { name : module . clone ( ) , obs : libsleeper :: observers ( & cfg . sleeper ) , } , " " => Observer { name : module . clone ( ) , obs : liblimiter :: observers ( & cfg . limiter ) , } , " " => Observer { name : module . clone ( ) , obs : libdebug :: observers ( & cfg . debug ) , } , " " => Observer { name : module . clone ( ) , obs : libmediator :: observers ( & cfg . mediator ) , } , " " => Observer { name : module . clone ( ) , obs : libbfl :: observers ( & cfg . bfl ) , } , " " => Observer { name : module . clone ( ) , obs : libsmb :: observer ( ) , } , _ => Observer { name : module . clone ( ) , obs : ( None , None ) , } , } }
anytime new plugin is added must be inserted loading-code here
 in the future this may be separete dll for better decoupling
 adding modules add-hot style ( we just replace/add module but fuzzer remains same )
 also thats why we forwarding push_state as static function..
 optimal will be, that if new module added no need to recompile fuzzer
 aka i can use 3 years old fuzzer with latest new module
 though if it really brings some benefits, loosing sources to fuzzer and use it later
is problem in its own sense
anytime new plugin is added must be inserted loading - code here in the future this may be separete dll for better decoupling adding modules add - hot style ( we just replace / add module but fuzzer remains same ) also thats why we forwarding push_state as static function .. optimal will be that if new module added no need to recompile fuzzer aka i can use 3 years old fuzzer with latest new module though if it really brings some benefits loosing sources to fuzzer and use it later is problem in its own sense
module
&String
cfg
&ConfigCore
module
&String
cfg
&ConfigCore