refactor enum casts: prefer lexical cast default and cfg["x"].str()

src/gamestatus.cpp

@@ -830,7 +830,7 @@ game_classification::game_classification(const config& cfg):
 	label(cfg["label"]),
 	parent(cfg["parent"]),
 	version(cfg["version"]),
-	campaign_type(lexical_cast_default<game_classification::CAMPAIGN_TYPE> (cfg["campaign_type"], game_classification::SCENARIO)),
+	campaign_type(lexical_cast_default<game_classification::CAMPAIGN_TYPE> (cfg["campaign_type"].str(), game_classification::SCENARIO)),
 	campaign_define(cfg["campaign_define"]),
 	campaign_xtra_defines(utils::split(cfg["campaign_extra_defines"])),
 	campaign(cfg["campaign"]),

src/menu_events.cpp

@@ -3140,12 +3140,17 @@ void console_handler::do_unit() {
 	// But someday the code ought to be
 	// changed to allow general string
 	// alignments for UMC.
-	if (name == "alignment" && (value != "lawful" && value != "neutral" && value != "chaotic" && value != "liminal")) {
-		utils::string_map symbols;
-		symbols["alignment"] = get_arg(1);
-		command_failed(VGETTEXT("Invalid alignment: '$alignment',"
-			" needs to be one of lawful, neutral, chaotic, or liminal.", symbols));
-		return;
+	if (name == "alignment") { // && (value != "lawful" && value != "neutral" && value != "chaotic" && value != "liminal")) {
+		std::stringstream ss(value);
+		unit_type::ALIGNMENT alignment = unit_type::ALIGNMENT();
+		ss >> alignment;
+		if (!ss) {
+			utils::string_map symbols;
+			symbols["alignment"] = get_arg(1);
+			command_failed(VGETTEXT("Invalid alignment: '$alignment',"
+				" needs to be one of lawful, neutral, chaotic, or liminal.", symbols));
+			return;
+		}
 	}
 	if (name == "advances" ){
 		if(synced_context::get_synced_state() == synced_context::SYNCED)

src/savegame.cpp

@@ -579,7 +579,7 @@ void loadgame::load_game(
 	}
 
 	gamestate_.classification().campaign_define = load_config_["campaign_define"].str();
-	gamestate_.classification().campaign_type = lexical_cast_default<game_classification::CAMPAIGN_TYPE> (load_config_["campaign_type"], game_classification::SCENARIO);
+	gamestate_.classification().campaign_type = lexical_cast_default<game_classification::CAMPAIGN_TYPE> (load_config_["campaign_type"].str(), game_classification::SCENARIO);
 	gamestate_.classification().campaign_xtra_defines = utils::split(load_config_["campaign_extra_defines"]);
 	gamestate_.classification().version = load_config_["version"].str();
 	if (config & carryover_sides_start = load_config_.child("carryover_sides_start")) {

src/team.cpp

@@ -131,7 +131,7 @@ void team::team_info::read(const config &cfg)
 	allow_player = cfg["allow_player"].to_bool(true);
 	chose_random = cfg["chose_random"].to_bool(false);
 	no_leader = cfg["no_leader"].to_bool();
-	defeat_condition = lexical_cast_default<team::DEFEAT_CONDITION>(cfg["defeat_condition"], team::NO_LEADER);
+	defeat_condition = lexical_cast_default<team::DEFEAT_CONDITION>(cfg["defeat_condition"].str(), team::NO_LEADER);
 	hidden = cfg["hidden"].to_bool();
 	no_turn_confirmation = cfg["suppress_end_turn_confirmation"].to_bool();
 	side = cfg["side"].to_int(1);
@@ -184,7 +184,7 @@ void team::team_info::read(const config &cfg)
 	else
 		support_per_village = lexical_cast_default<int>(village_support, game_config::village_support);
 
-	controller = lexical_cast_default<team::CONTROLLER> (cfg["controller"], team::AI);
+	controller = lexical_cast_default<team::CONTROLLER> (cfg["controller"].str(), team::AI);
 	//by default, persistence of a team is set depending on the controller
 	//TODO: Why is network_ai marked persistent?
 	//TODO: Why do we read disallow observers differently when controller is empty?

src/terrain_filter.cpp

@@ -247,14 +247,14 @@ bool terrain_filter::match_internal(const map_location& loc, const bool ignore_x
 		if(!tod_type.empty()) {
 			const std::vector<std::string>& vals = utils::split(tod_type);
 			if(tod.lawful_bonus<0) {
-				if(std::find(vals.begin(),vals.end(),std::string("chaotic")) == vals.end()) {
+				if(std::find(vals.begin(),vals.end(),lexical_cast<std::string>(unit_type::CHAOTIC)) == vals.end()) {
 					return false;
 				}
 			} else if(tod.lawful_bonus>0) {
-				if(std::find(vals.begin(),vals.end(),std::string("lawful")) == vals.end()) {
+				if(std::find(vals.begin(),vals.end(),lexical_cast<std::string>(unit_type::LAWFUL)) == vals.end()) {
 					return false;
 				}
-			} else if(std::find(vals.begin(),vals.end(),std::string("neutral")) == vals.end()) {
+			} else if(std::find(vals.begin(),vals.end(),lexical_cast<std::string>(unit_type::NEUTRAL)) == vals.end()) {
 				return false;
 			}
 		}

src/unit.cpp

@@ -229,7 +229,7 @@ unit::unit(const config &cfg, bool use_traits, const vconfig* vcfg) :
 	recall_cost_(-1),
 	canrecruit_(cfg["canrecruit"].to_bool()),
 	recruit_list_(),
-	alignment_(),
+	alignment_(lexical_cast_default<unit_type::ALIGNMENT> (cfg["alignment"].str(), unit_type::NEUTRAL)),
 	flag_rgb_(),
 	image_mods_(),
 	unrenamable_(false),
@@ -471,19 +471,6 @@ unit::unit(const config &cfg, bool use_traits, const vconfig* vcfg) :
 		recall_cost_ = cfg["recall_cost"].to_int(recall_cost_);
 	}
 
-	const std::string& align = cfg["alignment"];
-	if(align == "lawful") {
-		alignment_ = unit_type::LAWFUL;
-	} else if(align == "neutral") {
-		alignment_ = unit_type::NEUTRAL;
-	} else if(align == "chaotic") {
-		alignment_ = unit_type::CHAOTIC;
-	} else if(align == "liminal") {
-		alignment_ = unit_type::LIMINAL;
-	} else if(align.empty()==false) {
-		alignment_ = unit_type::NEUTRAL;
-	}
-
 	generate_name();
 
 	// Make the default upkeep "full"
@@ -1772,22 +1759,7 @@ void unit::write(config& cfg) const
 	cfg["language_name"] = type_name_;
 	cfg["undead_variation"] = undead_variation_;
 	cfg["level"] = level_;
-	switch(alignment_) {
-		case unit_type::LAWFUL:
-			cfg["alignment"] = "lawful";
-			break;
-		case unit_type::NEUTRAL:
-			cfg["alignment"] = "neutral";
-			break;
-		case unit_type::CHAOTIC:
-			cfg["alignment"] = "chaotic";
-			break;
-		case unit_type::LIMINAL:
-			cfg["alignment"] = "liminal";
-			break;
-		default:
-			cfg["alignment"] = "neutral";
-	}
+	cfg["alignment"] = lexical_cast<std::string> (alignment_);
 	cfg["flag_rgb"] = flag_rgb_;
 	cfg["unrenamable"] = unrenamable_;
 	cfg["alpha"] = str_cast(alpha_);

src/unit_types.cpp

@@ -447,7 +447,7 @@ unit_type::unit_type(const config &cfg, const std::string & parent_id) :
 	advances_to_(),
 	experience_needed_(0),
 	in_advancefrom_(false),
-	alignment_(),
+	alignment_(unit_type::NEUTRAL),
 	movement_type_(),
 	possibleTraits_(),
 	genders_(),
@@ -486,7 +486,7 @@ void unit_type::build_full(const movement_type_map &mv_types,
 			gender_types_[i]->build_full(mv_types, races, traits);
 	}
 
-	alignment_ = lexical_cast_default<unit_type::ALIGNMENT>(cfg_["alignment"], unit_type::NEUTRAL);
+	alignment_ = lexical_cast_default<unit_type::ALIGNMENT>(cfg_["alignment"].str(), unit_type::NEUTRAL);
 
 	if ( race_ != &unit_race::null_race )
 	{
@@ -498,7 +498,7 @@ void unit_type::build_full(const movement_type_map &mv_types,
 		} else {
 			BOOST_FOREACH(const config &t, race_->additional_traits())
 			{
-				if (alignment_ != NEUTRAL || t["id"] != "fearless")
+				if (alignment_ != unit_type::NEUTRAL || t["id"] != "fearless")
 					possibleTraits_.add_child("trait", t);
 			}
 		}