Weighted list improvements (#82773)

Author: ShnitzelX2

src/anatomy.cpp

@@ -237,8 +237,8 @@ bodypart_id anatomy::select_body_part( int min_hit, int max_hit, bool can_attack
     }
 
     // Debug for seeing weights.
-    for( const weighted_object<double, bodypart_id> &pr : hit_weights ) {
-        add_msg_debug( debugmode::DF_ANATOMY_BP, "%s = %.3f", pr.obj.obj().name, pr.weight );
+    for( const std::pair<bodypart_id, double> &pr : hit_weights ) {
+        add_msg_debug( debugmode::DF_ANATOMY_BP, "%s = %.3f", pr.first.obj().name, pr.second );
     }
 
     const bodypart_id *ret = hit_weights.pick();
@@ -303,8 +303,8 @@ bodypart_id anatomy::select_blocking_part( const Creature *blocker, bool arm, bo
     }
 
     // Debug for seeing weights.
-    for( const weighted_object<double, bodypart_id> &pr : block_scores ) {
-        add_msg_debug( debugmode::DF_MELEE, "%s = %.3f", pr.obj.obj().name, pr.weight );
+    for( const std::pair<bodypart_id, double > &pr : block_scores ) {
+        add_msg_debug( debugmode::DF_MELEE, "%s = %.3f", pr.first.obj().name, pr.second );
     }
 
     const bodypart_id *ret = block_scores.pick();

src/cata_tiles.cpp

@@ -1011,23 +1011,23 @@ void tileset_cache::loader::process_variations_after_loading(
     // loop through all of the variations
     for( auto &v : vs ) {
         // in a given variation, erase any invalid sprite ids
-        v.obj.erase(
+        v.first.erase(
             std::remove_if(
-                v.obj.begin(),
-                v.obj.end(),
+                v.first.begin(),
+                v.first.end(),
         [&]( int id ) {
             return id >= offset || id < 0;
         } ),
-        v.obj.end()
+        v.first.end()
         );
     }
     // erase any variations with no valid sprite ids left
     vs.erase(
         std::remove_if(
             vs.begin(),
             vs.end(),
-    [&]( const weighted_object<int, std::vector<int>> &o ) {
-        return o.obj.empty();
+    [&]( const std::pair<std::vector<int>, int> &o ) {
+        return o.first.empty();
     }
         ),
     vs.end()

src/generic_factory.h

@@ -36,6 +36,7 @@
 #include "string_formatter.h"
 #include "string_id.h"
 #include "units.h"
+#include "weighted_list.h"
 
 class quantity;
 
@@ -1253,6 +1254,78 @@ struct handler<std::vector<T>> {
     static constexpr bool is_container = true;
 };
 
+template<typename T>
+struct handler<weighted_int_list<T>> {
+    void clear( weighted_int_list<T> &container ) const {
+        container.clear();
+    }
+    bool insert( weighted_int_list<T> &container, const std::pair<T, int> &data ) const {
+        container.add( data );
+        return true;
+    }
+    bool relative( weighted_int_list<T> &, const std::pair<T, int> & ) const {
+        return false;
+    }
+    template<typename E>
+    bool erase( weighted_int_list<T> &container, const E &data ) const {
+        const auto pred = [&data]( const std::pair<T, int> &e ) {
+            return e.first == data.first;
+        };
+        if( !erase_if( container, pred ) ) {
+            debugmsg( "Did not remove %s in delete", data_string( data ) );
+            return false;
+        }
+        return true;
+    }
+    template<typename P>
+    bool erase_if( weighted_int_list<T> &container, P &predicate ) const {
+        const auto iter = std::find_if( container.begin(), container.end(), predicate );
+        if( iter != container.end() ) {
+            container.remove( iter->first );
+        } else {
+            return false;
+        }
+        return true;
+    }
+    static constexpr bool is_container = true;
+};
+
+template<typename T, typename W>
+struct handler<weighted_list<T, W>> {
+    void clear( weighted_list<T, W> &container ) const {
+        container.clear();
+    }
+    bool insert( weighted_list<T, W> &container, const std::pair<T, W> &data ) const {
+        container.add( data );
+        return true;
+    }
+    bool relative( weighted_list<T, W> &, const std::pair<T, W> & ) const {
+        return false;
+    }
+    template<typename E>
+    bool erase( weighted_list<T, W> &container, const E &data ) const {
+        const auto pred = [&data]( const T & e ) {
+            return e == data;
+        };
+        if( !erase_if( container, pred ) ) {
+            debugmsg( "Did not remove %s in delete", data_string( data ) );
+            return false;
+        }
+        return true;
+    }
+    template<typename P>
+    bool erase_if( weighted_list<T, W> &container, P &predicate ) const {
+        const auto iter = std::find_if( container.begin(), container.end(), predicate );
+        if( iter != container.end() ) {
+            container.remove( *iter.obj );
+        } else {
+            return false;
+        }
+        return true;
+    }
+    static constexpr bool is_container = true;
+};
+
 template<typename Key, typename Val>
 struct handler<std::map<Key, Val>> {
     void clear( std::map<Key, Val> &container ) const {

src/item.cpp

@@ -2605,10 +2605,10 @@ void item::debug_info( std::vector<iteminfo> &info, const iteminfo_query *parts,
             }
 
             std::string faults;
-            for( const weighted_object<int, fault_id> &fault : type->faults ) {
-                const int weight_percent = static_cast<float>( fault.weight ) / type->faults.get_weight() * 100;
-                faults += colorize( fault.obj.str() + string_format( " (%d, %d%%)\n", fault.weight,
-                                    weight_percent ), has_fault( fault.obj ) ? c_yellow : c_white );
+            for( const std::pair<fault_id, int> &fault : type->faults ) {
+                const int weight_percent = static_cast<float>( fault.second ) / type->faults.get_weight() * 100;
+                faults += colorize( fault.first.str() + string_format( " (%d, %d%%)\n", fault.second,
+                                    weight_percent ), has_fault( fault.first ) ? c_yellow : c_white );
             }
             info.emplace_back( "BASE", string_format( "faults: %s", faults ) );
         }
@@ -7878,9 +7878,9 @@ void item::set_random_fault_of_type( const std::string &fault_type, bool force,
     }
 
     weighted_int_list<fault_id> faults_by_type;
-    for( const weighted_object<int, fault_id> &f : type->faults ) {
-        if( f.obj.obj().type() == fault_type && can_have_fault( f.obj ) ) {
-            faults_by_type.add( f.obj, f.weight );
+    for( const std::pair<fault_id, int> &f : type->faults ) {
+        if( f.first.obj().type() == fault_type && can_have_fault( f.first ) ) {
+            faults_by_type.add( f.first, f.second );
         }
 
     }
@@ -10439,18 +10439,18 @@ int item::wind_resist() const
 std::set<fault_id> item::faults_potential() const
 {
     std::set<fault_id> res;
-    for( const weighted_object<int, fault_id> &fault_pair : type->faults ) {
-        res.insert( fault_pair.obj );
+    for( const std::pair<fault_id, int> &fault_pair : type->faults ) {
+        res.insert( fault_pair.first );
     }
     return res;
 }
 
 std::set<fault_id> item::faults_potential_of_type( const std::string &fault_type ) const
 {
     std::set<fault_id> res;
-    for( const weighted_object<int, fault_id> &some_fault : type->faults ) {
-        if( some_fault.obj->type() == fault_type ) {
-            res.emplace( some_fault.obj );
+    for( const std::pair<fault_id, int> &some_fault : type->faults ) {
+        if( some_fault.first->type() == fault_type ) {
+            res.emplace( some_fault.first );
         }
     }
     return res;

src/item_factory.cpp

@@ -925,12 +925,13 @@ void Item_factory::finalize_post( itype &obj )
             const int weight_add = std::get<1>( fault_groups );
             const float weight_mult = std::get<2>( fault_groups );
             for( const auto &id_and_weight : fault_g.obj().get_weighted_list() ) {
-                obj.faults.add_or_replace( id_and_weight.obj, ( id_and_weight.weight + weight_add ) * weight_mult );
+                obj.faults.add_or_replace( id_and_weight.first,
+                                           ( id_and_weight.second + weight_add ) * weight_mult );
             }
         } else {
             // weight_override is not -1, override the weight
-            for( const weighted_object<int, fault_id> &id_and_weight : fault_g.obj().get_weighted_list() ) {
-                obj.faults.add( id_and_weight.obj, std::get<0>( fault_groups ) );
+            for( const std::pair<fault_id, int> &id_and_weight : fault_g.obj().get_weighted_list() ) {
+                obj.faults.add( id_and_weight.first, std::get<0>( fault_groups ) );
             }
         }
     }
@@ -2466,8 +2467,8 @@ void Item_factory::check_definitions() const
         }
 
         for( const auto &f : type->faults ) {
-            if( !f.obj.is_valid() ) {
-                msg += string_format( "invalid item fault %s\n", f.obj.c_str() );
+            if( !f.first.is_valid() ) {
+                msg += string_format( "invalid item fault %s\n", f.first.c_str() );
             }
         }
 

src/magic_ter_fur_transform.cpp

@@ -72,7 +72,7 @@ static void load_transform_results( const JsonObject &jsi, const std::string &js
         list.add( T( jsi.get_string( json_key ) ), 1 );
         return;
     }
-    load_weighted_list( jsi.get_member( json_key ), list, 1 );
+    list.deserialize( jsi.get_member( json_key ) );
 }
 
 void ter_furn_transform::reset()