[−][src]Trait df_st_db::DBObject

pub trait DBObject<C, D> where
    C: Fillable + Filler<C, D> + Default + Debug + Clone,
    D: PartialEq<C> + Debug + Clone, {
    fn match_field_by(field: String) -> String;
    fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld);
    fn insert_into_db(conn: &DbConnection, db_list: &[D]);
    fn get_count_from_db(
        conn: &DbConnection, 
        id_filter: HashMap<String, i32>, 
        string_filter: HashMap<String, String>, 
        offset: u32, 
        limit: u32, 
        group_by_opt: Option<String>, 
        id_list: Option<Vec<i32>>
    ) -> Result<Vec<ItemCount>, Error>;
    fn find_db_item(
        conn: &DbConnection, 
        id_filter: HashMap<String, i32>
    ) -> Result<Option<D>, Error>;
    fn find_db_list(
        conn: &DbConnection, 
        id_filter: HashMap<String, i32>, 
        string_filter: HashMap<String, String>, 
        offset: i64, 
        limit: i64, 
        order: Option<OrderTypes>, 
        order_by: Option<String>, 
        id_list: Option<Vec<i32>>
    ) -> Result<Vec<D>, Error>;
    fn add_nested_items(
        conn: &DbConnection, 
        db_list: &[D], 
        core_list: Vec<C>
    ) -> Result<Vec<C>, Error>;

    fn get_order(
        order: Option<OrderTypes>, 
        order_by: Option<String>
    ) -> (String, bool) { ... }
    fn match_field_by_opt(field: Option<String>) -> Option<String> { ... }
    fn insert_into_db_chunked(conn: &DbConnection, db_list: &[D]) { ... }
    fn insert_into_db_chunked_indexmap(
        conn: &DbConnection, 
        db_list: &IndexMap<u64, D>
    ) { ... }
    fn indexmap_chunks(
        indexmap: &IndexMap<u64, D>, 
        chunk_size: usize, 
        offset: usize
    ) -> Vec<D> { ... }
    fn get_list_from_db(
        conn: &DbConnection, 
        id_filter: HashMap<String, i32>, 
        string_filter: HashMap<String, String>, 
        offset: u32, 
        limit: u32, 
        order: Option<OrderTypes>, 
        order_by: Option<String>, 
        id_list: Option<Vec<i32>>, 
        add_nested_items: bool
    ) -> Result<Vec<C>, Error> { ... }
    fn get_from_db(
        conn: &DbConnection, 
        id_filter: HashMap<String, i32>, 
        add_nested_items: bool
    ) -> Result<Option<C>, Error> { ... }
}

Required methods

`fn match_field_by(field: String) -> String`

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`

Add other items to the world that are part of DB Object, but are still part of the Core object.

`fn insert_into_db(conn: &DbConnection, db_list: &[D])`

Insert the DB object into the database

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`

Get the amount of items that would be returned when using these filters. The fields can optionally be grouped using the group_by_opt.

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<D>, Error>`

The database call for an item by id If item not found returns None

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<D>, Error>`

The database call for the list of items given some limit Limit: the maximum amount of items in the list that are returned.

`fn add_nested_items( conn: &DbConnection, db_list: &[D], core_list: Vec<C> ) -> Result<Vec<C>, Error>`

Add additional data to the list of objects This can call additional DB requests

Loading content...

Provided methods

`fn get_order( order: Option<OrderTypes>, order_by: Option<String> ) -> (String, bool)`

`fn match_field_by_opt(field: Option<String>) -> Option<String>`

`fn insert_into_db_chunked(conn: &DbConnection, db_list: &[D])`

Inserts the DB objects into the database. If the list is to long to insert in 1 database call it will split it up in chunks and insert them in multiple calls. See #46

`fn insert_into_db_chunked_indexmap( conn: &DbConnection, db_list: &IndexMap<u64, D> )`

Inserts the DB objects into the database. If the list is to long to insert in 1 database call it will split it up in chunks and insert them in multiple calls. See #46

`fn indexmap_chunks( indexmap: &IndexMap<u64, D>, chunk_size: usize, offset: usize ) -> Vec<D>`

`fn get_list_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>>, add_nested_items: bool ) -> Result<Vec<C>, Error>`

Get a list of all the Core items from that database given some parameters Limit: the maximum amount of items in the list that are returned.

`fn get_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, add_nested_items: bool ) -> Result<Option<C>, Error>`

Get a Core item from the database, search by id If item is not found it will return None

Loading content...

Implementors

`impl DBObject<Artifact, Artifact> for Artifact`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, artifacts: &[Artifact])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Artifact>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Artifact>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Artifact], core_list: Vec<Artifact> ) -> Result<Vec<Artifact>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, Creature> for Creature`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures: &[Creature])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Creature>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Creature>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[Creature], _core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureAG> for CreatureAG`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_a_g: &[CreatureAG])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureAG>, Error>`[src]

Get a list of CreatureAG from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureAG>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureAG], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureHH1> for CreatureHH1`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_h_h_1: &[CreatureHH1])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureHH1>, Error>`[src]

Get a list of CreatureHH1 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureHH1>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureHH1], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureHH2> for CreatureHH2`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_h_h_2: &[CreatureHH2])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureHH2>, Error>`[src]

Get a list of CreatureHH2 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureHH2>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureHH2], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureLZ> for CreatureLZ`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_l_z: &[CreatureLZ])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureLZ>, Error>`[src]

Get a list of CreatureLZ from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureLZ>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureLZ], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<CreatureBiome, CreatureBiome1> for CreatureBiome1`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creature_biomes_1: &[CreatureBiome1])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureBiome1>, Error>`[src]

Get a list of CreatureBiome1 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureBiome1>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureBiome1], core_list: Vec<CreatureBiome> ) -> Result<Vec<CreatureBiome>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<CreatureBiome, CreatureBiome2> for CreatureBiome2`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creature_biomes_2: &[CreatureBiome2])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureBiome2>, Error>`[src]

Get a list of CreatureBiome2 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureBiome2>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureBiome2], core_list: Vec<CreatureBiome> ) -> Result<Vec<CreatureBiome>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<DanceForm, DanceForm> for DanceForm`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, dance_forms: &[DanceForm])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<DanceForm>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<DanceForm>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[DanceForm], core_list: Vec<DanceForm> ) -> Result<Vec<DanceForm>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Entity, Entity> for Entity`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entities: &[Entity])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Entity>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Entity>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[Entity], _core_list: Vec<Entity> ) -> Result<Vec<Entity>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityHonor, EntityHonor> for EntityHonor`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_honors: &[EntityHonor])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityHonor>, Error>`[src]

Get a list of EntityHonor from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityHonor>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityHonor], core_list: Vec<EntityHonor> ) -> Result<Vec<EntityHonor>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityLink, EntityLink> for EntityLink`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_links: &[EntityLink])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityLink>, Error>`[src]

Get a list of EntityLink from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityLink>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityLink], core_list: Vec<EntityLink> ) -> Result<Vec<EntityLink>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityOccasion, EntityOccasion> for EntityOccasion`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_occasions: &[EntityOccasion])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityOccasion>, Error>`[src]

Get a list of EntityOccasion from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityOccasion>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityOccasion], core_list: Vec<EntityOccasion> ) -> Result<Vec<EntityOccasion>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityOccasionSchedule, EntityOccasionSchedule> for EntityOccasionSchedule`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, entity_occasion_schedules: &[EntityOccasionSchedule] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityOccasionSchedule>, Error>`[src]

Get a list of EntityOccasionSchedule from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityOccasionSchedule>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityOccasionSchedule], core_list: Vec<EntityOccasionSchedule> ) -> Result<Vec<EntityOccasionSchedule>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityOccasionScheduleFeature, EntityOccasionScheduleFeature> for EntityOccasionScheduleFeature`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, entity_occasion_schedule_features: &[EntityOccasionScheduleFeature] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityOccasionScheduleFeature>, Error>`[src]

Get a list of EntityOccasionScheduleFeature from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityOccasionScheduleFeature>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityOccasionScheduleFeature], core_list: Vec<EntityOccasionScheduleFeature> ) -> Result<Vec<EntityOccasionScheduleFeature>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityPosition, EntityPosition> for EntityPosition`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_positions: &[EntityPosition])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityPosition>, Error>`[src]

Get a list of EntityPosition from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityPosition>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityPosition], core_list: Vec<EntityPosition> ) -> Result<Vec<EntityPosition>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityPositionAssignment, EntityPositionAssignment> for EntityPositionAssignment`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, entity_position_assignments: &[EntityPositionAssignment] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityPositionAssignment>, Error>`[src]

Get a list of EntityPositionAssignment from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityPositionAssignment>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityPositionAssignment], core_list: Vec<EntityPositionAssignment> ) -> Result<Vec<EntityPositionAssignment>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityPopulation, EntityPopulation> for EntityPopulation`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_populations: &[EntityPopulation])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityPopulation>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<EntityPopulation>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[EntityPopulation], core_list: Vec<EntityPopulation> ) -> Result<Vec<EntityPopulation>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEra, HistoricalEra> for HistoricalEra`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, historical_eras: &[HistoricalEra])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEra>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEra>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEra], core_list: Vec<HistoricalEra> ) -> Result<Vec<HistoricalEra>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECircumstance, HECircumstance> for HECircumstance`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_circumstances: &[HECircumstance])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECircumstance>, Error>`[src]

Get a list of HECircumstance from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECircumstance>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECircumstance], core_list: Vec<HECircumstance> ) -> Result<Vec<HECircumstance>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEReason, HEReason> for HEReason`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_reasons: &[HEReason])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEReason>, Error>`[src]

Get a list of HEReason from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEReason>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEReason], core_list: Vec<HEReason> ) -> Result<Vec<HEReason>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEvent> for HistoricalEvent`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, historical_events: &[HistoricalEvent])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEvent>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[HistoricalEvent], _core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventAA> for HistoricalEventAA`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_a_a: &[HistoricalEventAA] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventAA>, Error>`[src]

Get a list of HistoricalEventAA from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventAA>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventAA], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventBB> for HistoricalEventBB`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_b_b: &[HistoricalEventBB] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventBB>, Error>`[src]

Get a list of HistoricalEventBB from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventBB>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventBB], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventCC> for HistoricalEventCC`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_c_c: &[HistoricalEventCC] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventCC>, Error>`[src]

Get a list of HistoricalEventCC from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventCC>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventCC], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventDD1> for HistoricalEventDD1`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_d_d1: &[HistoricalEventDD1] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventDD1>, Error>`[src]

Get a list of HistoricalEventDD1 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventDD1>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventDD1], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventDD2> for HistoricalEventDD2`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_d_d2: &[HistoricalEventDD2] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventDD2>, Error>`[src]

Get a list of HistoricalEventDD2 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventDD2>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventDD2], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventEG> for HistoricalEventEG`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_e_g: &[HistoricalEventEG] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventEG>, Error>`[src]

Get a list of HistoricalEventEG from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventEG>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventEG], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventHH> for HistoricalEventHH`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_h_h: &[HistoricalEventHH] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventHH>, Error>`[src]

Get a list of HistoricalEventHH from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventHH>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventHH], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventII> for HistoricalEventII`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_i_i: &[HistoricalEventII] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventII>, Error>`[src]

Get a list of HistoricalEventII from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventII>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventII], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventJM> for HistoricalEventJM`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_j_m: &[HistoricalEventJM] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventJM>, Error>`[src]

Get a list of HistoricalEventJM from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventJM>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventJM], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventNO> for HistoricalEventNO`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_n_o: &[HistoricalEventNO] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventNO>, Error>`[src]

Get a list of HistoricalEventNO from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventNO>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventNO], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventPP> for HistoricalEventPP`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_p_p: &[HistoricalEventPP] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventPP>, Error>`[src]

Get a list of HistoricalEventPP from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventPP>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventPP], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventQR> for HistoricalEventQR`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_q_r: &[HistoricalEventQR] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventQR>, Error>`[src]

Get a list of HistoricalEventQR from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventQR>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventQR], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventSS1> for HistoricalEventSS1`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_s_s1: &[HistoricalEventSS1] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventSS1>, Error>`[src]

Get a list of HistoricalEventSS1 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventSS1>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventSS1], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventSS2> for HistoricalEventSS2`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_s_s2: &[HistoricalEventSS2] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventSS2>, Error>`[src]

Get a list of HistoricalEventSS2 from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventSS2>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventSS2], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventTT> for HistoricalEventTT`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_t_t: &[HistoricalEventTT] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventTT>, Error>`[src]

Get a list of HistoricalEventTT from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventTT>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventTT], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEvent, HistoricalEventUW> for HistoricalEventUW`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_events_u_w: &[HistoricalEventUW] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventUW>, Error>`[src]

Get a list of HistoricalEventUW from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventUW>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventUW], core_list: Vec<HistoricalEvent> ) -> Result<Vec<HistoricalEvent>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEventCollection, HistoricalEventCollection> for HistoricalEventCollection`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_event_collections: &[HistoricalEventCollection] )`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventCollection>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventCollection>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[HistoricalEventCollection], _core_list: Vec<HistoricalEventCollection> ) -> Result<Vec<HistoricalEventCollection>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEventCollection, HistoricalEventCollectionAC> for HistoricalEventCollectionAC`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_event_collections_a_c: &[HistoricalEventCollectionAC] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventCollectionAC>, Error>`[src]

Get a list of HistoricalEventCollectionAC from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventCollectionAC>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventCollectionAC], core_list: Vec<HistoricalEventCollection> ) -> Result<Vec<HistoricalEventCollection>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalEventCollection, HistoricalEventCollectionDZ> for HistoricalEventCollectionDZ`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, historical_event_collections_d_z: &[HistoricalEventCollectionDZ] )`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalEventCollectionDZ>, Error>`[src]

Get a list of HistoricalEventCollectionDZ from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalEventCollectionDZ>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HistoricalEventCollectionDZ], core_list: Vec<HistoricalEventCollection> ) -> Result<Vec<HistoricalEventCollection>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFEntityLink, HFEntityLink> for HFEntityLink`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_entity_links: &[HFEntityLink])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFEntityLink>, Error>`[src]

Get a list of HFEntityLink from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFEntityLink>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFEntityLink], core_list: Vec<HFEntityLink> ) -> Result<Vec<HFEntityLink>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFEntityPositionLink, HFEntityPositionLink> for HFEntityPositionLink`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hf_entity_position_links: &[HFEntityPositionLink] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFEntityPositionLink>, Error>`[src]

Get a list of HFEntityPositionLink from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFEntityPositionLink>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFEntityPositionLink], core_list: Vec<HFEntityPositionLink> ) -> Result<Vec<HFEntityPositionLink>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFEntityReputation, HFEntityReputation> for HFEntityReputation`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hf_entity_reputations: &[HFEntityReputation] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFEntityReputation>, Error>`[src]

Get a list of HFEntityReputation from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFEntityReputation>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFEntityReputation], core_list: Vec<HFEntityReputation> ) -> Result<Vec<HFEntityReputation>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFEntitySquadLink, HFEntitySquadLink> for HFEntitySquadLink`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hf_entity_squad_links: &[HFEntitySquadLink] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFEntitySquadLink>, Error>`[src]

Get a list of HFEntitySquadLink from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFEntitySquadLink>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFEntitySquadLink], core_list: Vec<HFEntitySquadLink> ) -> Result<Vec<HFEntitySquadLink>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFHonorEntity, HFHonorEntity> for HFHonorEntity`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_honor_entities: &[HFHonorEntity])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFHonorEntity>, Error>`[src]

Get a list of HFHonorEntity from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFHonorEntity>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFHonorEntity], core_list: Vec<HFHonorEntity> ) -> Result<Vec<HFHonorEntity>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFIntrigueActor, HFIntrigueActor> for HFIntrigueActor`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_intrigue_actors: &[HFIntrigueActor])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFIntrigueActor>, Error>`[src]

Get a list of HFIntrigueActor from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFIntrigueActor>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFIntrigueActor], core_list: Vec<HFIntrigueActor> ) -> Result<Vec<HFIntrigueActor>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFIntriguePlot, HFIntriguePlot> for HFIntriguePlot`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_intrigue_plots: &[HFIntriguePlot])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFIntriguePlot>, Error>`[src]

Get a list of HFIntriguePlot from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFIntriguePlot>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFIntriguePlot], core_list: Vec<HFIntriguePlot> ) -> Result<Vec<HFIntriguePlot>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFLink, HFLink> for HFLink`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_links: &[HFLink])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFLink>, Error>`[src]

Get a list of HFLink from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFLink>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFLink], core_list: Vec<HFLink> ) -> Result<Vec<HFLink>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFPlotActor, HFPlotActor> for HFPlotActor`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_plot_actors: &[HFPlotActor])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFPlotActor>, Error>`[src]

Get a list of HFPlotActor from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFPlotActor>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFPlotActor], core_list: Vec<HFPlotActor> ) -> Result<Vec<HFPlotActor>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFRelationshipProfileHF, HFRelationshipProfileHF> for HFRelationshipProfileHF`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hf_relationship_profile_hf: &[HFRelationshipProfileHF] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFRelationshipProfileHF>, Error>`[src]

Get a list of HFRelationshipProfileHF from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFRelationshipProfileHF>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFRelationshipProfileHF], core_list: Vec<HFRelationshipProfileHF> ) -> Result<Vec<HFRelationshipProfileHF>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFSiteLink, HFSiteLink> for HFSiteLink`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_site_links: &[HFSiteLink])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFSiteLink>, Error>`[src]

Get a list of HFSiteLink from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFSiteLink>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFSiteLink], core_list: Vec<HFSiteLink> ) -> Result<Vec<HFSiteLink>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFSiteProperty, HFSiteProperty> for HFSiteProperty`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_site_properties: &[HFSiteProperty])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFSiteProperty>, Error>`[src]

Get a list of HFSiteProperty from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFSiteProperty>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFSiteProperty], core_list: Vec<HFSiteProperty> ) -> Result<Vec<HFSiteProperty>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFSkill, HFSkill> for HFSkill`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_skills: &[HFSkill])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFSkill>, Error>`[src]

Get a list of HFSkill from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFSkill>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFSkill], core_list: Vec<HFSkill> ) -> Result<Vec<HFSkill>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFVagueRelationship, HFVagueRelationship> for HFVagueRelationship`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hf_vague_relationships: &[HFVagueRelationship] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFVagueRelationship>, Error>`[src]

Get a list of HFVagueRelationship from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFVagueRelationship>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFVagueRelationship], core_list: Vec<HFVagueRelationship> ) -> Result<Vec<HFVagueRelationship>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HistoricalFigure, HistoricalFigure> for HistoricalFigure`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, historical_figures: &[HistoricalFigure])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HistoricalFigure>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<HistoricalFigure>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[HistoricalFigure], _core_list: Vec<HistoricalFigure> ) -> Result<Vec<HistoricalFigure>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Identity, Identity> for Identity`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, identities: &[Identity])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Identity>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Identity>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Identity], core_list: Vec<Identity> ) -> Result<Vec<Identity>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Landmass, Landmass> for Landmass`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, landmasses: &[Landmass])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Landmass>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Landmass>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[Landmass], core_list: Vec<Landmass> ) -> Result<Vec<Landmass>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<LinkHEHF, LinkHEHF> for LinkHEHF`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, link_he_hf: &[LinkHEHF])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<LinkHEHF>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<LinkHEHF>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[LinkHEHF], core_list: Vec<LinkHEHF> ) -> Result<Vec<LinkHEHF>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<MountainPeak, MountainPeak> for MountainPeak`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, mountain_peaks: &[MountainPeak])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<MountainPeak>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<MountainPeak>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[MountainPeak], core_list: Vec<MountainPeak> ) -> Result<Vec<MountainPeak>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<MusicalForm, MusicalForm> for MusicalForm`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, musical_forms: &[MusicalForm])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<MusicalForm>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<MusicalForm>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[MusicalForm], core_list: Vec<MusicalForm> ) -> Result<Vec<MusicalForm>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<PoeticForm, PoeticForm> for PoeticForm`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, poetic_forms: &[PoeticForm])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<PoeticForm>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<PoeticForm>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[PoeticForm], core_list: Vec<PoeticForm> ) -> Result<Vec<PoeticForm>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Region, Region> for Region`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

Add Coordinates to the world that are part of Region

`fn insert_into_db(conn: &DbConnection, regions: &[Region])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Region>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Region>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[Region], _core_list: Vec<Region> ) -> Result<Vec<Region>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<River, River> for River`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, rivers: &[River])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<River>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<River>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[River], core_list: Vec<River> ) -> Result<Vec<River>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Site, Site> for Site`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, site: &[Site])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Site>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Site>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[Site], core_list: Vec<Site> ) -> Result<Vec<Site>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<SiteProperty, SiteProperty> for SiteProperty`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, sites_properties: &[SiteProperty])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<SiteProperty>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<SiteProperty>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[SiteProperty], core_list: Vec<SiteProperty> ) -> Result<Vec<SiteProperty>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Structure, Structure> for Structure`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, sites_structures: &[Structure])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<Structure>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Structure>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Structure], core_list: Vec<Structure> ) -> Result<Vec<Structure>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<UndergroundRegion, UndergroundRegion> for UndergroundRegion`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

Add Coordinates to the world that are part of UndergroundRegion

`fn insert_into_db(conn: &DbConnection, ug_regions: &[UndergroundRegion])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<UndergroundRegion>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<UndergroundRegion>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[UndergroundRegion], _core_list: Vec<UndergroundRegion> ) -> Result<Vec<UndergroundRegion>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<WorldConstruction, WorldConstruction> for WorldConstruction`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

Add Coordinates to the world that are part of WorldConstruction

`fn insert_into_db( conn: &DbConnection, world_constructions: &[WorldConstruction] )`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<WorldConstruction>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<WorldConstruction>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[WorldConstruction], _core_list: Vec<WorldConstruction> ) -> Result<Vec<WorldConstruction>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<DFWorldInfo, DFWorldInfo> for DFWorldInfo`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, worlds: &[DFWorldInfo])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<DFWorldInfo>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<DFWorldInfo>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[DFWorldInfo], core_list: Vec<DFWorldInfo> ) -> Result<Vec<DFWorldInfo>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<WCReference, WCReference> for WCReference`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, wc_reference: &[WCReference])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<WCReference>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<WCReference>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[WCReference], core_list: Vec<WCReference> ) -> Result<Vec<WCReference>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<WCStyle, WCStyle> for WCStyle`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, wc_style: &[WCStyle])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<WCStyle>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<WCStyle>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[WCStyle], core_list: Vec<WCStyle> ) -> Result<Vec<WCStyle>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<WrittenContent, WrittenContent> for WrittenContent`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, written_contents: &[WrittenContent])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<WrittenContent>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<WrittenContent>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[WrittenContent], _core_list: Vec<WrittenContent> ) -> Result<Vec<WrittenContent>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Coordinate, Coordinate> for Coordinate`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, coordinates: &[Coordinate])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Coordinate>, Error>`[src]

Get a filtered list of coordinates from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Coordinate>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Coordinate], core_list: Vec<Coordinate> ) -> Result<Vec<Coordinate>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Path, Path> for Path`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, paths: &[Path])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Path>, Error>`[src]

Get a filtered list of paths from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Path>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Path], core_list: Vec<Path> ) -> Result<Vec<Path>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Rectangle, Rectangle> for Rectangle`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, rectangles: &[Rectangle])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Rectangle>, Error>`[src]

Get a filtered list of rectangles from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Rectangle>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Rectangle], core_list: Vec<Rectangle> ) -> Result<Vec<Rectangle>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<SiteMapImage, SiteMapImage> for SiteMapImage`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, site_map_images: &[SiteMapImage])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<SiteMapImage>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<SiteMapImage>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[SiteMapImage], core_list: Vec<SiteMapImage> ) -> Result<Vec<SiteMapImage>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<MapImage, MapImage> for MapImage`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, map_images: &[MapImage])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<MapImage>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<MapImage>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[MapImage], core_list: Vec<MapImage> ) -> Result<Vec<MapImage>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityChildENID, EntityChildENID> for EntityChildENID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_child_en_ids: &[EntityChildENID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityChildENID>, Error>`[src]

Get a list of EntityChildENID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityChildENID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityChildENID], core_list: Vec<EntityChildENID> ) -> Result<Vec<EntityChildENID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityHFID, EntityHFID> for EntityHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_hf_ids: &[EntityHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityHFID>, Error>`[src]

Get a list of EntityHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityHFID], core_list: Vec<EntityHFID> ) -> Result<Vec<EntityHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityPopulationRace, EntityPopulationRace> for EntityPopulationRace`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, entity_population_races: &[EntityPopulationRace] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityPopulationRace>, Error>`[src]

Get a list of entity_population_races from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityPopulationRace>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityPopulationRace], core_list: Vec<EntityPopulationRace> ) -> Result<Vec<EntityPopulationRace>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityProfession, EntityProfession> for EntityProfession`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_professions: &[EntityProfession])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityProfession>, Error>`[src]

Get a list of EntityProfession from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityProfession>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityProfession], core_list: Vec<EntityProfession> ) -> Result<Vec<EntityProfession>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityWeapon, EntityWeapon> for EntityWeapon`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_weapons: &[EntityWeapon])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityWeapon>, Error>`[src]

Get a list of EntityWeapon from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityWeapon>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityWeapon], core_list: Vec<EntityWeapon> ) -> Result<Vec<EntityWeapon>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<EntityWorshipID, EntityWorshipID> for EntityWorshipID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, entity_worship_ids: &[EntityWorshipID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<EntityWorshipID>, Error>`[src]

Get a list of EntityWorshipID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<EntityWorshipID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[EntityWorshipID], core_list: Vec<EntityWorshipID> ) -> Result<Vec<EntityWorshipID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEAHFID, HEAHFID> for HEAHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_a_hf_ids: &[HEAHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEAHFID>, Error>`[src]

Get a list of HEAHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEAHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEAHFID], core_list: Vec<HEAHFID> ) -> Result<Vec<HEAHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEBodiesHFID, HEBodiesHFID> for HEBodiesHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_bodies_hf_ids: &[HEBodiesHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEBodiesHFID>, Error>`[src]

Get a list of HEBodiesHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEBodiesHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEBodiesHFID], core_list: Vec<HEBodiesHFID> ) -> Result<Vec<HEBodiesHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECASupportMercHFID, HECASupportMercHFID> for HECASupportMercHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hec_a_support_merc_hf_ids: &[HECASupportMercHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECASupportMercHFID>, Error>`[src]

Get a list of HECASupportMercHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECASupportMercHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECASupportMercHFID], core_list: Vec<HECASupportMercHFID> ) -> Result<Vec<HECASupportMercHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECAttackingHFID, HECAttackingHFID> for HECAttackingHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hec_attacking_hf_ids: &[HECAttackingHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECAttackingHFID>, Error>`[src]

Get a list of HECAttackingHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECAttackingHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECAttackingHFID], core_list: Vec<HECAttackingHFID> ) -> Result<Vec<HECAttackingHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECDSupportMercHFID, HECDSupportMercHFID> for HECDSupportMercHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hec_d_support_merc_hf_ids: &[HECDSupportMercHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECDSupportMercHFID>, Error>`[src]

Get a list of HECDSupportMercHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECDSupportMercHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECDSupportMercHFID], core_list: Vec<HECDSupportMercHFID> ) -> Result<Vec<HECDSupportMercHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECDefendingHFID, HECDefendingHFID> for HECDefendingHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hec_defending_hf_ids: &[HECDefendingHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECDefendingHFID>, Error>`[src]

Get a list of HECDefendingHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECDefendingHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECDefendingHFID], core_list: Vec<HECDefendingHFID> ) -> Result<Vec<HECDefendingHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECHEID, HECHEID> for HECHEID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hec_he_ids: &[HECHEID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECHEID>, Error>`[src]

Get a list of HECHEID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECHEID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECHEID], core_list: Vec<HECHEID> ) -> Result<Vec<HECHEID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECIndividualMerc, HECIndividualMerc> for HECIndividualMerc`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hec_individual_mercs: &[HECIndividualMerc] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECIndividualMerc>, Error>`[src]

Get a list of HECIndividualMerc from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECIndividualMerc>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECIndividualMerc], core_list: Vec<HECIndividualMerc> ) -> Result<Vec<HECIndividualMerc>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECNoncomHFID, HECNoncomHFID> for HECNoncomHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hec_noncom_hf_ids: &[HECNoncomHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECNoncomHFID>, Error>`[src]

Get a list of HECNoncomHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECNoncomHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECNoncomHFID], core_list: Vec<HECNoncomHFID> ) -> Result<Vec<HECNoncomHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECOutcome, HECOutcome> for HECOutcome`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hec_outcomes: &[HECOutcome])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECOutcome>, Error>`[src]

Get a list of HECOutcome from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECOutcome>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECOutcome], core_list: Vec<HECOutcome> ) -> Result<Vec<HECOutcome>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECRelatedID, HECRelatedID> for HECRelatedID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hec_related_ids: &[HECRelatedID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECRelatedID>, Error>`[src]

Get a list of HECRelatedID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECRelatedID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECRelatedID], core_list: Vec<HECRelatedID> ) -> Result<Vec<HECRelatedID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HECompetitorHFID, HECompetitorHFID> for HECompetitorHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, he_competitor_hf_ids: &[HECompetitorHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HECompetitorHFID>, Error>`[src]

Get a list of HECompetitorHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HECompetitorHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HECompetitorHFID], core_list: Vec<HECompetitorHFID> ) -> Result<Vec<HECompetitorHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEConspiratorHFID, HEConspiratorHFID> for HEConspiratorHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, he_conspirator_hf_ids: &[HEConspiratorHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEConspiratorHFID>, Error>`[src]

Get a list of HEConspiratorHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEConspiratorHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEConspiratorHFID], core_list: Vec<HEConspiratorHFID> ) -> Result<Vec<HEConspiratorHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEDHFID, HEDHFID> for HEDHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_d_hf_ids: &[HEDHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEDHFID>, Error>`[src]

Get a list of HEDHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEDHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEDHFID], core_list: Vec<HEDHFID> ) -> Result<Vec<HEDHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEExpelledCreature, HEExpelledCreature> for HEExpelledCreature`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, he_expelled_creatures: &[HEExpelledCreature] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEExpelledCreature>, Error>`[src]

Get a list of HEExpelledCreature from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEExpelledCreature>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEExpelledCreature], core_list: Vec<HEExpelledCreature> ) -> Result<Vec<HEExpelledCreature>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEExpelledHFID, HEExpelledHFID> for HEExpelledHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_expelled_hf_ids: &[HEExpelledHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEExpelledHFID>, Error>`[src]

Get a list of HEExpelledHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEExpelledHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEExpelledHFID], core_list: Vec<HEExpelledHFID> ) -> Result<Vec<HEExpelledHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEExpelledNumber, HEExpelledNumber> for HEExpelledNumber`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_expelled_numbers: &[HEExpelledNumber])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEExpelledNumber>, Error>`[src]

Get a list of HEExpelledNumber from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEExpelledNumber>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEExpelledNumber], core_list: Vec<HEExpelledNumber> ) -> Result<Vec<HEExpelledNumber>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEExpelledPopID, HEExpelledPopID> for HEExpelledPopID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_expelled_pop_ids: &[HEExpelledPopID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEExpelledPopID>, Error>`[src]

Get a list of HEExpelledPopID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEExpelledPopID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEExpelledPopID], core_list: Vec<HEExpelledPopID> ) -> Result<Vec<HEExpelledPopID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEGroupsHFID, HEGroupsHFID> for HEGroupsHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_groups_hf_ids: &[HEGroupsHFID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEGroupsHFID>, Error>`[src]

Get a list of HEGroupsHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEGroupsHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEGroupsHFID], core_list: Vec<HEGroupsHFID> ) -> Result<Vec<HEGroupsHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEImplicatedHFID, HEImplicatedHFID> for HEImplicatedHFID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, he_implicated_hf_ids: &[HEImplicatedHFID] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEImplicatedHFID>, Error>`[src]

Get a list of HEImplicatedHFID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEImplicatedHFID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEImplicatedHFID], core_list: Vec<HEImplicatedHFID> ) -> Result<Vec<HEImplicatedHFID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEJoiningENID, HEJoiningENID> for HEJoiningENID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_joining_en_ids: &[HEJoiningENID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEJoiningENID>, Error>`[src]

Get a list of HEJoiningENID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEJoiningENID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEJoiningENID], core_list: Vec<HEJoiningENID> ) -> Result<Vec<HEJoiningENID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HEPet, HEPet> for HEPet`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, he_pets: &[HEPet])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HEPet>, Error>`[src]

Get a list of HEPet from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HEPet>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HEPet], core_list: Vec<HEPet> ) -> Result<Vec<HEPet>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFHonorID, HFHonorID> for HFHonorID`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_honor_ids: &[HFHonorID])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFHonorID>, Error>`[src]

Get a list of HFHonorID from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFHonorID>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFHonorID], core_list: Vec<HFHonorID> ) -> Result<Vec<HFHonorID>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFInteractionKnowledge, HFInteractionKnowledge> for HFInteractionKnowledge`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db( conn: &DbConnection, hf_interaction_knowledges: &[HFInteractionKnowledge] )`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFInteractionKnowledge>, Error>`[src]

Get a list of HFInteractionKnowledge from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFInteractionKnowledge>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFInteractionKnowledge], core_list: Vec<HFInteractionKnowledge> ) -> Result<Vec<HFInteractionKnowledge>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFJourneyPets, HFJourneyPets> for HFJourneyPets`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_journey_pets: &[HFJourneyPets])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFJourneyPets>, Error>`[src]

Get a list of HFJourneyPets from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFJourneyPets>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFJourneyPets], core_list: Vec<HFJourneyPets> ) -> Result<Vec<HFJourneyPets>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<HFSpheres, HFSpheres> for HFSpheres`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, hf_spheres: &[HFSpheres])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<HFSpheres>, Error>`[src]

Get a list of HFSpheres from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<HFSpheres>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[HFSpheres], core_list: Vec<HFSpheres> ) -> Result<Vec<HFSpheres>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<RegionForce, RegionForce> for RegionForce`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, regions_forces: &[RegionForce])`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<RegionForce>, Error>`[src]

Get a list of RegionForce from the database

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<RegionForce>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[RegionForce], core_list: Vec<RegionForce> ) -> Result<Vec<RegionForce>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

Loading content...

[−][src]Trait df_st_db::DBObject

Required methods

fn match_field_by(field: String) -> String

fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)

fn insert_into_db(conn: &DbConnection, db_list: &[D])

fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<D>, Error>

fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>>) -> Result<Vec<D>, Error>

fn add_nested_items( conn: &DbConnection, db_list: &[D], core_list: Vec<C>) -> Result<Vec<C>, Error>

Provided methods

fn get_order( order: Option<OrderTypes>, order_by: Option<String>) -> (String, bool)

fn match_field_by_opt(field: Option<String>) -> Option<String>

fn insert_into_db_chunked(conn: &DbConnection, db_list: &[D])

fn insert_into_db_chunked_indexmap( conn: &DbConnection, db_list: &IndexMap<u64, D>)

fn indexmap_chunks( indexmap: &IndexMap<u64, D>, chunk_size: usize, offset: usize) -> Vec<D>

fn get_list_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>>, add_nested_items: bool) -> Result<Vec<C>, Error>

fn get_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, add_nested_items: bool) -> Result<Option<C>, Error>

Implementors

impl DBObject<Artifact, Artifact> for Artifact[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, artifacts: &[Artifact])[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<Artifact>, Error>[src]

fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>>) -> Result<Vec<Artifact>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( _conn: &DbConnection, _db_list: &[Artifact], core_list: Vec<Artifact>) -> Result<Vec<Artifact>, Error>[src]

fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<Creature, Creature> for Creature[src]

fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creatures: &[Creature])[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<Creature>, Error>[src]

fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>>) -> Result<Vec<Creature>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( conn: &DbConnection, db_list: &[Creature], _core_list: Vec<Creature>) -> Result<Vec<Creature>, Error>[src]

fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<Creature, CreatureAG> for CreatureAG[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creatures_a_g: &[CreatureAG])[src]

fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<CreatureAG>, Error>[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<CreatureAG>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureAG], core_list: Vec<Creature>) -> Result<Vec<Creature>, Error>[src]

fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<Creature, CreatureHH1> for CreatureHH1[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creatures_h_h_1: &[CreatureHH1])[src]

fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<CreatureHH1>, Error>[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<CreatureHH1>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureHH1], core_list: Vec<Creature>) -> Result<Vec<Creature>, Error>[src]

fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<Creature, CreatureHH2> for CreatureHH2[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creatures_h_h_2: &[CreatureHH2])[src]

fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<CreatureHH2>, Error>[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<CreatureHH2>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureHH2], core_list: Vec<Creature>) -> Result<Vec<Creature>, Error>[src]

fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<Creature, CreatureLZ> for CreatureLZ[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creatures_l_z: &[CreatureLZ])[src]

fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<CreatureLZ>, Error>[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<CreatureLZ>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureLZ], core_list: Vec<Creature>) -> Result<Vec<Creature>, Error>[src]

fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<CreatureBiome, CreatureBiome1> for CreatureBiome1[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creature_biomes_1: &[CreatureBiome1])[src]

fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<CreatureBiome1>, Error>[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<CreatureBiome1>, Error>[src]

fn match_field_by(field: String) -> String[src]

fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureBiome1], core_list: Vec<CreatureBiome>) -> Result<Vec<CreatureBiome>, Error>[src]

fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<ItemCount>, Error>[src]

impl DBObject<CreatureBiome, CreatureBiome2> for CreatureBiome2[src]

fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)[src]

fn insert_into_db(conn: &DbConnection, creature_biomes_2: &[CreatureBiome2])[src]

fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>>) -> Result<Vec<CreatureBiome2>, Error>[src]

fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32>) -> Result<Option<CreatureBiome2>, Error>[src]

fn match_field_by(field: String) -> String[src]

`fn match_field_by(field: String) -> String`

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`

`fn insert_into_db(conn: &DbConnection, db_list: &[D])`

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<D>, Error>`

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<D>, Error>`

`fn add_nested_items( conn: &DbConnection, db_list: &[D], core_list: Vec<C> ) -> Result<Vec<C>, Error>`

`fn get_order( order: Option<OrderTypes>, order_by: Option<String> ) -> (String, bool)`

`fn match_field_by_opt(field: Option<String>) -> Option<String>`

`fn insert_into_db_chunked(conn: &DbConnection, db_list: &[D])`

`fn insert_into_db_chunked_indexmap( conn: &DbConnection, db_list: &IndexMap<u64, D> )`

`fn indexmap_chunks( indexmap: &IndexMap<u64, D>, chunk_size: usize, offset: usize ) -> Vec<D>`

`fn get_list_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, string_filter: HashMap<String, String>, offset: u32, limit: u32, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>>, add_nested_items: bool ) -> Result<Vec<C>, Error>`

`fn get_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, add_nested_items: bool ) -> Result<Option<C>, Error>`

`impl DBObject<Artifact, Artifact> for Artifact`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, artifacts: &[Artifact])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Artifact>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Artifact>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[Artifact], core_list: Vec<Artifact> ) -> Result<Vec<Artifact>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, Creature> for Creature`[src]

`fn add_missing_data_advanced(core_world: &DFWorld, world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures: &[Creature])`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<Creature>, Error>`[src]

`fn find_db_list( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: i64, limit: i64, order: Option<OrderTypes>, order_by: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<Creature>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( conn: &DbConnection, db_list: &[Creature], _core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( conn: &DbConnection, id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, offset: u32, limit: u32, group_by_opt: Option<String>, id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureAG> for CreatureAG`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_a_g: &[CreatureAG])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureAG>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureAG>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureAG], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureHH1> for CreatureHH1`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_h_h_1: &[CreatureHH1])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureHH1>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureHH1>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureHH1], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureHH2> for CreatureHH2`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_h_h_2: &[CreatureHH2])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureHH2>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureHH2>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureHH2], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<Creature, CreatureLZ> for CreatureLZ`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creatures_l_z: &[CreatureLZ])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureLZ>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureLZ>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureLZ], core_list: Vec<Creature> ) -> Result<Vec<Creature>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<CreatureBiome, CreatureBiome1> for CreatureBiome1`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creature_biomes_1: &[CreatureBiome1])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureBiome1>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureBiome1>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureBiome1], core_list: Vec<CreatureBiome> ) -> Result<Vec<CreatureBiome>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<CreatureBiome, CreatureBiome2> for CreatureBiome2`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]

`fn insert_into_db(conn: &DbConnection, creature_biomes_2: &[CreatureBiome2])`[src]

`fn find_db_list( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: i64, _limit: i64, _order: Option<OrderTypes>, _order_by: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<CreatureBiome2>, Error>`[src]

`fn find_db_item( conn: &DbConnection, id_filter: HashMap<String, i32> ) -> Result<Option<CreatureBiome2>, Error>`[src]

`fn match_field_by(field: String) -> String`[src]

`fn add_nested_items( _conn: &DbConnection, _db_list: &[CreatureBiome2], core_list: Vec<CreatureBiome> ) -> Result<Vec<CreatureBiome>, Error>`[src]

`fn get_count_from_db( _conn: &DbConnection, _id_filter: HashMap<String, i32>, _string_filter: HashMap<String, String>, _offset: u32, _limit: u32, _group_by_opt: Option<String>, _id_list: Option<Vec<i32>> ) -> Result<Vec<ItemCount>, Error>`[src]

`impl DBObject<DanceForm, DanceForm> for DanceForm`[src]

`fn add_missing_data_advanced(_core_world: &DFWorld, _world: &mut DBDFWorld)`[src]