DarkFenX

pub struct Parent<'a> {
    source: Option<Src>,
    children: ic::Unordered<'a, Child>,
}
impl Parent {
    pub fn new(src: Option<Src>) -> Parent {
        Parent { src, children: ic::Unordered::new(???) }
}

DarkFenX

    /// Add new data source with custom alias, and optionally make it default.
    pub fn add(
        &self,
        alias: &str,
        data_handler: Box<dyn DataHandler>,
        mut cache_handler: Box<dyn CacheHandler>,
        make_default: bool,
        callback: Option<mpsc::Sender<SrcAddStatus>>,
    ) -> Result<()> {
        log::info!("adding source with alias \"{}\", default={}", alias, make_default);

DarkFenX

trait Fk {
    fn get_fks<T>(&self, remote: T) -> Vec<i32>;
}

struct Item {}
struct ItemGroup {}

impl Fk for Item {
    fn get_fks<T>(&self, remote: T) -> Vec<i32> {
        let mut vec = Vec::new();

DarkFenX

pub fn generate_cache(data_handler: Box<dyn DataHandler>) {
    let mut data = Data::new();
    fill_data(&data_handler, DataHandler::get_items, &mut data.items);
}

fn fill_data<S, F, T>(handler: &S, func: F, vec: &mut Vec<T>)
where
    S: DataHandler,
    F: FnOnce(&S) -> dh::Result<dh::Container<T>>,
{

DarkFenX

#[derive(Debug, serde::Deserialize)]
pub(super) struct ItemFighterAbilData {
    #[serde(rename = "abilityID")]
    pub(super) abil_id: ReeInt,
    #[serde(rename = "cooldownSeconds")]
    pub(super) cooldown: Option<ReeFloat>,
    pub(super) charges: Option<ItemFighterAbilChargeData>,
}
#[derive(Debug, serde::Deserialize)]
pub(super) struct ItemFighterAbilChargeData {

DarkFenX

fn flatten_l1(json: serde_json::Value, key_name: &'static str) -> Result<Flattened> {
    match json {
        serde_json::Value::Object(outer_map) => {
            let mut data = HashMap::new();
            let mut failed: u32 = 0;
            for (k, v) in outer_map.into_iter() {
                match (v, k.parse::<ReeInt>()) {
                    (serde_json::Value::Object(mut inner_map), Ok(id)) => {
                        insert_int(&mut inner_map, key_name, id);
                        data.insert(id, serde_json::Value::Object(inner_map));

DarkFenX

error[E0277]: the trait bound `std::option::Option<main::Extras>: std::convert::From<std::option::Option<main::JsonExtras>>` is not satisfied
  --> src/main.rs:19:62
   |
19 |             Data { some_id: self.someID, extras: self.extras.into() }
   |                                                              ^^^^ the trait `std::convert::From<std::option::Option<main::JsonExtras>>` is not implemented for `std::option::Option<main::Extras>`
   |
   = help: the following implementations were found:
             <std::option::Option<&'a T> as std::convert::From<&'a std::option::Option<T>>>
             <std::option::Option<&'a mut T> as std::convert::From<&'a mut std::option::Option<T>>>
             <std::option::Option<T> as std::convert::From<T>>

DarkFenX

    fn convert_fsdlite<'a, T, U>(decomposed: Vec<serde_json::Value>) -> dh::Result<U>
    where
        T: serde::Deserialize<'a> + Into<U>,
    {
        let mut data = Vec::new();
        let mut errors: u32 = 0;
        for value in decomposed {
            match serde_json::from_value::<T>(value) {
                Ok(v) => data.push(v.into()),
                Err(_) => errors += 1,

DarkFenX

error[E0277]: the trait bound `for<'de> T: dh_impls::phobos::data::_IMPL_DESERIALIZE_FOR_EveType::_serde::Deserialize<'de>` is not satisfied
    --> core/src/dh_impls/phobos/handler.rs:56:44
     |
56   |             match serde_json::from_value::<T>(value) {
     |                                            ^ the trait `for<'de> dh_impls::phobos::data::_IMPL_DESERIALIZE_FOR_EveType::_serde::Deserialize<'de>` is not implemented for `T`
     | 
    ::: /home/dfx/.cargo/registry/src/github.com-1ecc6299db9ec823/serde_json-1.0.53/src/value/mod.rs:1004:8
     |
1004 |     T: DeserializeOwned,
     |        ---------------- required by this bound in `serde_json::value::from_value`

DarkFenX

    fn check_map<'a>(&self, addr: &PhobosAddress, json: &'a JsonValue) -> PhobosResult<&'a JsonMap<String, JsonValue>> {
        match json.as_object() {
            Some(json) => return Ok(json),
            None => {
                return Err(PhobosHandlerError::new(format!(
                    "{} conversion failed: highest-level structure is not a map",
                    addr.get_full_str(&self.base_path)
                )))
            }
        }