cleaned up the REFLECTION code a bit:

 * renamed 'tag' variable to 'reflector', which better describes its purpose
 * removed addAlias stuff, instead check for matching names 'manually'
 * removed backwards compatibility with <0.3.0 for templates, they are going to break anyway.

src/data/card.cpp

@@ -81,7 +81,7 @@ IMPLEMENT_REFLECTION(Card) {
 		} else if (stylesheet_for_reading()) {
 			REFLECT_IF_READING styling_data.init(stylesheet_for_reading()->styling_fields);
 			REFLECT(styling_data);
-		} else if (tag.reading()) {
+		} else if (reflector.isReading()) {
 			has_styling = false; // We don't know the style, this can be because of copy/pasting
 		}
 	}

src/data/field/choice.cpp

@@ -145,7 +145,7 @@ IMPLEMENT_REFLECTION_ENUM(ChoiceChoiceType) {
 }
 
 IMPLEMENT_REFLECTION(ChoiceField::Choice) {
-	if (isGroup() || line_below || enabled.isScripted() || tag.isComplex()) {
+	REFLECT_IF_READING_COMPOUND_OR(isGroup() || line_below || enabled.isScripted()) {
 		// complex values are groups
 		REFLECT(name);
 		REFLECT_N("group_choice", default_name);
@@ -263,14 +263,14 @@ IMPLEMENT_REFLECTION_ENUM(ChoiceRenderStyle) {
 	VALUE_N("both list",		RENDER_BOTH_LIST);
 }
 
-template <typename T> void reflect_content(T& tag,         const ChoiceStyle& cs) {}
-template <>           void reflect_content(GetMember& tag, const ChoiceStyle& cs) {
+template <typename Reflector>
+void reflect_content(Reflector& reflector, const ChoiceStyle& cs) {}
+void reflect_content(GetMember& reflector, const ChoiceStyle& cs) {
 	REFLECT_N("content_width",  cs.content_width);
 	REFLECT_N("content_height", cs.content_height);
 }
 
 IMPLEMENT_REFLECTION(ChoiceStyle) {
-	REFLECT_ALIAS(300, "card_list_colors", "colors_card_list");
 	REFLECT_BASE(Style);
 	REFLECT(popup_style);
 	REFLECT(render_style);
@@ -279,7 +279,7 @@ IMPLEMENT_REFLECTION(ChoiceStyle) {
 	REFLECT(font);
 	REFLECT(image);
 	REFLECT(choice_images);
-	reflect_content(tag, *this);
+	reflect_content(reflector, *this);
 }
 
 // ----------------------------------------------------------------------------- : ChoiceValue
@@ -303,7 +303,7 @@ bool ChoiceValue::update(Context& ctx) {
 }
 
 IMPLEMENT_REFLECTION_NAMELESS(ChoiceValue) {
-	if (fieldP->save_value || tag.scripting() || tag.reading()) REFLECT_NAMELESS(value);
+	if (fieldP->save_value || !reflector.isWriting()) REFLECT_NAMELESS(value);
 }
 
 INSTANTIATE_REFLECTION_NAMELESS(ChoiceValue)

src/data/field/color.cpp

@@ -41,12 +41,12 @@ IMPLEMENT_REFLECTION(ColorField) {
 // ----------------------------------------------------------------------------- : ColorField::Choice
 
 IMPLEMENT_REFLECTION(ColorField::Choice) {
-	if (tag.reading() && !tag.isComplex()) {
-		REFLECT_NAMELESS(name);
-		color = parse_color(name);
-	} else {
+	REFLECT_IF_READING_COMPOUND_OR(true) {
 		REFLECT(name);
 		REFLECT(color);
+	} else {
+		REFLECT_NAMELESS(name);
+		color = parse_color(name);
 	}
 }
 
@@ -100,5 +100,5 @@ bool ColorValue::update(Context& ctx) {
 }
 
 IMPLEMENT_REFLECTION_NAMELESS(ColorValue) {
-	if (fieldP->save_value || tag.scripting() || tag.reading()) REFLECT_NAMELESS(value);
+	if (fieldP->save_value || !reflector.isWriting()) REFLECT_NAMELESS(value);
 }

src/data/field/image.cpp

@@ -39,14 +39,14 @@ String ImageValue::toString() const {
 
 // custom reflection: convert to ScriptImageP for scripting
 
-void ImageValue::reflect(Reader& tag) {
-	tag.handle(filename);
+void ImageValue::reflect(Reader& reflector) {
+	reflector.handle(filename);
 }
-void ImageValue::reflect(Writer& tag) {
-	if (fieldP->save_value) tag.handle(filename);
+void ImageValue::reflect(Writer& reflector) {
+	if (fieldP->save_value) reflector.handle(filename);
 }
-void ImageValue::reflect(GetMember& tag) {}
-void ImageValue::reflect(GetDefaultMember& tag) {
+void ImageValue::reflect(GetMember& reflector) {}
+void ImageValue::reflect(GetDefaultMember& reflector) {
 	// convert to ScriptImageP for scripting
-	tag.handle( (ScriptValueP)intrusive(new ImageValueToImage(filename, last_update)) );
+	reflector.handle( (ScriptValueP)intrusive(new ImageValueToImage(filename, last_update)) );
 }

src/data/field/package_choice.cpp

@@ -67,13 +67,13 @@ bool PackageChoiceValue::update(Context& ctx) {
 	return change;
 }
 
-void PackageChoiceValue::reflect(Reader& tag) {
+void PackageChoiceValue::reflect(Reader& reflector) {
 	REFLECT_NAMELESS(package_name);
 }
-void PackageChoiceValue::reflect(Writer& tag) {
+void PackageChoiceValue::reflect(Writer& reflector) {
 	REFLECT_NAMELESS(package_name);
 }
-void PackageChoiceValue::reflect(GetDefaultMember& tag) {
+void PackageChoiceValue::reflect(GetDefaultMember& reflector) {
 	if (package_name.empty()) {
 		REFLECT_NAMELESS(package_name);
 	} else if(package_name != field().initial) {
@@ -84,4 +84,4 @@ void PackageChoiceValue::reflect(GetDefaultMember& tag) {
 		REFLECT_NAMELESS(_("/") + package_name);
 	}
 }
-void PackageChoiceValue::reflect(GetMember& tag) {}
+void PackageChoiceValue::reflect(GetMember& reflector) {}

src/data/field/symbol.cpp

@@ -52,5 +52,5 @@ String SymbolValue::toString() const {
 }
 
 IMPLEMENT_REFLECTION_NAMELESS(SymbolValue) {
-	if (fieldP->save_value || tag.scripting() || tag.reading()) REFLECT_NAMELESS(filename);
+	if (fieldP->save_value || !reflector.isWriting()) REFLECT_NAMELESS(filename);
 }

src/data/field/text.cpp

@@ -97,8 +97,8 @@ void TextStyle::checkContentDependencies(Context& ctx, const Dependency& dep) co
 	alignment.initDependencies(ctx, dep);
 }
 
-template <typename T> void reflect_content(T& tag,         const TextStyle& ts) {}
-template <>           void reflect_content(GetMember& tag, const TextStyle& ts) {
+template <typename Reflector> void reflect_content(Reflector& reflector, const TextStyle& ts) {}
+template <>                   void reflect_content(GetMember& reflector, const TextStyle& ts) {
 	REFLECT_N("content_width",  ts.content_width);
 	REFLECT_N("content_height", ts.content_height);
 	REFLECT_N("content_lines",  ts.content_lines);
@@ -127,7 +127,7 @@ IMPLEMENT_REFLECTION(TextStyle) {
 	REFLECT(line_height_line_max);
 	REFLECT(paragraph_height);
 	REFLECT(direction);
-	reflect_content(tag, *this);
+	reflect_content(reflector, *this);
 }
 
 // ----------------------------------------------------------------------------- : TextValue
@@ -147,7 +147,7 @@ bool TextValue::update(Context& ctx) {
 }
 
 IMPLEMENT_REFLECTION_NAMELESS(TextValue) {
-	if (fieldP->save_value || tag.scripting() || tag.reading()) REFLECT_NAMELESS(value);
+	if (fieldP->save_value || !reflector.isWriting()) REFLECT_NAMELESS(value);
 }
 
 // ----------------------------------------------------------------------------- : FakeTextValue

src/data/game.cpp

@@ -54,7 +54,7 @@ IMPLEMENT_REFLECTION(Game) {
 	REFLECT_NO_SCRIPT(card_list_color_script);
 	REFLECT_NO_SCRIPT(statistics_dimensions);
 	REFLECT_NO_SCRIPT(statistics_categories);
-	REFLECT_ALIAS(308, "pack_item", "pack_type");
+	REFLECT_COMPAT(<308, "pack_item", pack_types);
 	REFLECT_NO_SCRIPT(pack_types);
 	REFLECT_NO_SCRIPT(keyword_match_script);
 	REFLECT(has_keywords);

src/data/keyword.cpp

@@ -58,10 +58,10 @@ IMPLEMENT_REFLECTION(KeywordMode) {
 }
 
 // backwards compatability
-template <typename T> void read_compat(T&, const Keyword*) {}
-void read_compat(Reader& tag, Keyword* k) {
+template <typename Reflector> void read_compat(Reflector&, const Keyword*) {}
+void read_compat(Reader& reflector, Keyword* k) {
 	if (!k->match.empty()) return;
-	if (tag.file_app_version >= 301) return; // only for versions < 0.3.1
+	if (reflector.file_app_version >= 301) return; // only for versions < 0.3.1
 	String separator, parameter;
 	REFLECT(separator);
 	REFLECT(parameter);
@@ -90,7 +90,7 @@ bool Keyword::contains(String const& query) const {
 
 IMPLEMENT_REFLECTION(Keyword) {
 	REFLECT(keyword);
-	read_compat(tag, this);
+	read_compat(reflector, this);
 	REFLECT(match);
 	REFLECT(reminder);
 	REFLECT(rules);

src/data/pack.cpp

@@ -60,12 +60,12 @@ IMPLEMENT_REFLECTION(PackType) {
 }
 
 IMPLEMENT_REFLECTION(PackItem) {
-	if (!tag.isComplex()) {
-		REFLECT_NAMELESS(name);
-	} else {
+	REFLECT_IF_READING_COMPOUND_OR(true) {
 		REFLECT(name);
 		REFLECT(amount);
 		REFLECT(weight);
+	} else {
+		REFLECT_NAMELESS(name);
 	}
 }
 

src/data/set.cpp

@@ -170,8 +170,6 @@ void Set::validate(Version file_app_version) {
 }
 
 IMPLEMENT_REFLECTION(Set) {
-	REFLECT_ALIAS(300, "style",          "stylesheet"); // < 0.3.0 used style instead of stylesheet
-	REFLECT_ALIAS(300, "extra_set_info", "styling");
 	REFLECT(game);
 	if (game) {
 		REFLECT_IF_READING {
@@ -185,23 +183,23 @@ IMPLEMENT_REFLECTION(Set) {
 			REFLECT_N("styling", styling_data);
 		}
 		// Experimental: save each card to a different file
-		reflect_cards(tag);
+		reflect_cards(reflector);
 		REFLECT(keywords);
 		REFLECT(pack_types);
 	}
-	reflect_set_info_get_member(tag,data);
+	reflect_set_info_get_member(reflector,data);
 	REFLECT_NO_SCRIPT_N("version_control", vcs);
 	REFLECT(apprentice_code);
 }
 
 // TODO: make this a more generic function to be used elsewhere
-template <typename Tag>
-void Set::reflect_cards (Tag& tag) {
+template <typename Reflector>
+void Set::reflect_cards (Reflector& reflector) {
 	REFLECT(cards);
 }
 
 template <>
-void Set::reflect_cards<Writer> (Writer& tag) {
+void Set::reflect_cards<Writer> (Writer& reflector) {
 	// When writing to a directory, we write each card in a separate file.
 	// We don't do this in zipfiles because it leads to bloat.
 	if (isZipfile()) {
@@ -253,9 +251,9 @@ void mark_dependency_member(const Set& set, const String& name, const Dependency
 }
 
 // in scripts, set.something is read from the set_info
-template <typename Tag>
-void reflect_set_info_get_member(Tag&       tag, const IndexMap<FieldP, ValueP>& data) {}
-void reflect_set_info_get_member(GetMember& tag, const IndexMap<FieldP, ValueP>& data) {
+template <typename Reflector>
+void reflect_set_info_get_member(Reflector& reflector, const IndexMap<FieldP, ValueP>& data) {}
+void reflect_set_info_get_member(GetMember& reflector, const IndexMap<FieldP, ValueP>& data) {
 	REFLECT_NAMELESS(data);
 }
 

src/data/settings.cpp

@@ -244,8 +244,6 @@ String Settings::settingsFile() {
 }
 
 IMPLEMENT_REFLECTION_NO_SCRIPT(Settings) {
-	REFLECT_ALIAS(300,         "style_settings",         "stylesheet_settings");
-	REFLECT_ALIAS(300, "default_style_settings", "default_stylesheet_settings");
 	REFLECT(locale);
 	REFLECT(recent_sets);
 	REFLECT(default_set_dir);
@@ -266,7 +264,7 @@ IMPLEMENT_REFLECTION_NO_SCRIPT(Settings) {
 	#if USE_OLD_STYLE_UPDATE_CHECKER
 		REFLECT(updates_url);
 	#else
-		REFLECT_IGNORE(306,"updates url");
+		REFLECT_COMPAT_IGNORE(<306,"updates url",String);
 	#endif
 	REFLECT(package_versions_url);
 	REFLECT(installer_list_url);
@@ -277,6 +275,8 @@ IMPLEMENT_REFLECTION_NO_SCRIPT(Settings) {
 	REFLECT(game_settings);
 	REFLECT(stylesheet_settings);
 	REFLECT(default_stylesheet_settings);
+	REFLECT_COMPAT(<300, "style_settings", stylesheet_settings);
+	REFLECT_COMPAT(<300, "default_style_settings", default_stylesheet_settings);
 	REFLECT(export_options);
 }
 

src/data/stylesheet.cpp

@@ -94,16 +94,6 @@ void mark_dependency_value(const StyleSheet& stylesheet, const Dependency& dep)
 
 
 IMPLEMENT_REFLECTION(StyleSheet) {
-	// < 0.3.0 didn't use card_ prefix
-	REFLECT_ALIAS(300, "width",       "card_width");
-	REFLECT_ALIAS(300, "height",      "card_height");
-	REFLECT_ALIAS(300, "dpi",         "card_dpi");
-	REFLECT_ALIAS(300, "background",  "card_background");
-	REFLECT_ALIAS(300, "info_style",  "set_info_style");
-	REFLECT_ALIAS(300, "align",       "alignment");
-	REFLECT_ALIAS(300, "extra_field", "styling_field");
-	REFLECT_ALIAS(300, "extra_style", "styling_style");
-	
 	REFLECT(game);
 	REFLECT_BASE(Packaged);
 	REFLECT(card_width);

src/data/symbol.cpp

@@ -30,10 +30,10 @@ IMPLEMENT_REFLECTION(ControlPoint) {
 	REFLECT_N("position",      pos);
 	REFLECT_N("lock",          lock);
 	REFLECT_N("line_after",    segment_after);
-	if (tag.reading() || segment_before == SEGMENT_CURVE) {
+	if (reflector.isReading() || segment_before == SEGMENT_CURVE) {
 		REFLECT_N("handle_before", delta_before);
 	}
-	if (tag.reading() || segment_after  == SEGMENT_CURVE) {
+	if (reflector.isReading() || segment_after  == SEGMENT_CURVE) {
 		REFLECT_N("handle_after",  delta_after);
 	}
 }
@@ -159,8 +159,10 @@ IMPLEMENT_REFLECTION_ENUM(SymbolShapeCombine) {
 }
 
 
-template<typename T> void fix(const T&,SymbolShape&) {}
-void fix(const Reader& reader, SymbolShape& shape) {
+template<typename Reflector>
+void fix(Reflector&,SymbolShape&) {}
+void fix(Reader& reader, SymbolShape& shape) {
+	// compatibility with before the time we included version numbers
 	if (reader.file_app_version != Version()) return;
 	shape.updateBounds();
 	if (shape.bounds.max.x < 100 || shape.bounds.max.y < 100) return;
@@ -183,7 +185,7 @@ IMPLEMENT_REFLECTION(SymbolShape) {
 	REFLECT_IF_READING {
 		// enforce constraints
 		enforceConstraints();
-		fix(tag,*this);
+		fix(reflector,*this);
 	}
 }
 

src/data/symbol_font.cpp

@@ -50,8 +50,6 @@ SymbolFontP SymbolFont::byName(const String& name) {
 
 IMPLEMENT_REFLECTION(SymbolFont) {
 	REFLECT_BASE(Packaged);
-
-	REFLECT_ALIAS(300, "text_align", "text_alignment");
 	
 	REFLECT_N("image_font_size",  img_size);
 	REFLECT_N("horizontal_space", spacing.width);
@@ -183,6 +181,7 @@ IMPLEMENT_REFLECTION(SymbolInFont) {
 	REFLECT(draw_text);
 	REFLECT(text_font);
 	REFLECT(text_alignment);
+	REFLECT_COMPAT(<300,"text_align",text_alignment);
 	REFLECT(text_margin_left);
 	REFLECT(text_margin_right);
 	REFLECT(text_margin_top);
@@ -533,7 +532,7 @@ IMPLEMENT_REFLECTION_ENUM(MenuItemType) {
 }
 
 IMPLEMENT_REFLECTION_NO_GET_MEMBER(InsertSymbolMenu) {
-	if (!items.empty() || (tag.reading() && tag.isComplex())) {
+	REFLECT_IF_READING_COMPOUND_OR(!items.empty()) {
 		// complex values are groups
 		REFLECT(type);
 		REFLECT(name);

src/data/word_list.cpp

@@ -17,7 +17,7 @@ WordListWord::WordListWord()
 {}
 
 IMPLEMENT_REFLECTION_NO_SCRIPT(WordListWord) {
-	if (line_below || is_prefix || isGroup() || script || (tag.reading() && tag.isComplex())) {
+	REFLECT_IF_READING_COMPOUND_OR(line_below || is_prefix || isGroup() || script) {
 		// complex value
 		REFLECT(name);
 		REFLECT(line_below);

src/util/io/get_member.cpp

@@ -37,7 +37,7 @@ GetMember::GetMember(const String& name)
 	: target_name(name)
 {}
 
-// caused by the pattern: if (!tag.isComplex()) { REFLECT_NAMELESS(stuff) }
+// caused by the pattern: if (!reflector.isCompound()) { REFLECT_NAMELESS(stuff) }
 template <> void GetMember::handle(const String& v) {
 	throw InternalError(_("GetDefaultMember::handle"));
 }

src/util/io/get_member.hpp

@@ -25,18 +25,17 @@ template <typename T> class Scriptable;
 class GetDefaultMember {
   public:
 	/// Tell the reflection code we are not reading
-	inline bool reading()   const { return false; }
-	inline bool scripting() const { return true; }
-	inline bool isComplex() const { return false; }
-	inline void addAlias(int, const Char*, const Char*) {}
-	inline void handleIgnore(int, const Char*) {}
+	inline bool isReading() const { return false; }
+	inline bool isWriting() const { return false; }
+	inline bool isCompound() const { return false; }
+	inline Version formatVersion() const { return app_version; }
 	
 	/// The result, or script_nil if the member was not found
 	inline ScriptValueP result() { return value; } 
 	
 	// --------------------------------------------------- : Handling objects
 	
-	/// Handle an object: we don't match things with a name
+	/// Handle a key/value pair: ignore it.
 	template <typename T>
 	void handle(const Char* name, const T& object) {}
 	/// Don't handle a value
@@ -72,11 +71,10 @@ class GetMember : private GetDefaultMember {
 	GetMember(const String& name);
 	
 	/// Tell the reflection code we are not reading
-	inline bool reading()   const { return false; }
-	inline bool scripting() const { return true; }
-	inline bool isComplex() const { return true; }
-	inline void addAlias(int, const Char*, const Char*) {}
-	inline void handleIgnore(int, const Char*) {}
+	inline bool isReading() const { return false; }
+	inline bool isWriting() const { return false; }
+	inline bool isCompound() const { return true; }
+	inline Version formatVersion() const { return app_version; }
 	
 	/// The result, or script_nil if the member was not found
 	inline ScriptValueP result() { return gdm.result(); } 
@@ -121,17 +119,17 @@ class GetMember : private GetDefaultMember {
 #define REFLECT_OBJECT_GET_DEFAULT_MEMBER_NOT(Cls)	REFLECT_WRITE_NO(Cls,GetDefaultMember)
 #define REFLECT_OBJECT_GET_MEMBER_NOT(Cls)			REFLECT_WRITE_NO(Cls,GetMember)
 
-#define REFLECT_WRITE_YES(Cls, Tag)										\
-	template<> void Tag::handle<Cls>(const Cls& object) {				\
-		const_cast<Cls&>(object).reflect(*this);						\
-	}																	\
-	void Cls::reflect(Tag& tag) {										\
-		reflect_impl(tag);												\
+#define REFLECT_WRITE_YES(Cls, Reflector) \
+	template<> void Reflector::handle<Cls>(const Cls& object) { \
+		const_cast<Cls&>(object).reflect(*this); \
+	} \
+	void Cls::reflect(Reflector& reflector) { \
+		reflect_impl(reflector); \
 	}
 
-#define REFLECT_WRITE_NO(Cls, Tag)										\
-	template<> void Tag::handle<Cls>(const Cls& object) {}				\
-	void Cls::reflect(Tag& tag) {}
+#define REFLECT_WRITE_NO(Cls, Reflector) \
+	template<> void Reflector::handle<Cls>(const Cls& object) {} \
+	void Cls::reflect(Reflector& reflector) {}
 
 // ----------------------------------------------------------------------------- : Reflection for enumerations
 
@@ -142,7 +140,7 @@ class GetMember : private GetDefaultMember {
 		reflect_ ## Enum(const_cast<Enum&>(enum_), egm);				\
 	}
 
-/// 'Tag' to be used when reflecting enumerations for GetMember
+/// 'EnumReflector' to be used when reflecting enumerations for GetMember
 class EnumGetMember {
   public:
 	inline EnumGetMember(GetDefaultMember& gdm)

src/util/io/package.cpp

@@ -478,7 +478,7 @@ DateTime Package::modificationTime(const pair<String, FileInfo>& fi) const {
 // ----------------------------------------------------------------------------- : Packaged
 
 template <> void Reader::handle(PackageDependency& dep) {
-	if (!isComplex()) {
+	if (!isCompound()) {
 		handle(dep.package);
 		size_t pos = dep.package.find_first_of(_(' '));
 		if (pos != String::npos) {

src/util/io/reader.cpp

@@ -45,18 +45,6 @@ Reader::Reader(Reader* parent, Packaged* pkg, const String& filename, bool ignor
 	}
 }
 
-void Reader::addAlias(Version end_version, const Char* a, const Char* b) {
-	Alias& alias = aliasses[a];
-	alias.new_key     = b;
-	alias.end_version = end_version;
-}
-
-void Reader::handleIgnore(int end_version, const Char* a) {
-	if (file_app_version < end_version) {
-		if (enterBlock(a)) exitBlock();
-	}
-}
-
 void Reader::handleAppVersion() {
  	if (enterBlock(_("mse_version"))) {
 		handle(file_app_version);
@@ -278,26 +266,6 @@ void Reader::unknownKey() {
 		} while (indent > expected_indent);
 		return;
 	}
-	// aliasses?
-	map<String,Alias>::const_iterator it = aliasses.find(key);
-	if (it != aliasses.end()) {
-		if (aliasses.find(it->second.new_key) != aliasses.end()) {
-			// alias points to another alias, don't follow it, there is the risk of infinite loops
-		} else if (it->second.end_version <= file_app_version) {
-			// alias not used for this version, use in warning
-			if (indent == expected_indent) {
-				warning(_("Unexpected key: '") + key + _("'  use  '") + it->second.new_key + _("'"), 0, false);
-				do {
-					moveNext();
-				} while (indent > expected_indent);
-				return;
-			}
-		} else {
-			// try this key instead
-			key = it->second.new_key;
-			return;
-		}
-	}
 	if (indent >= expected_indent) {
 		warning(_("Unexpected key: '") + key + _("'"), 0, false);
 		do {

src/util/io/reader.hpp

@@ -47,15 +47,13 @@ class Reader {
 	~Reader() { showWarnings(); }
 	
 	/// Tell the reflection code we are reading
-	inline bool reading() const { return true; }
-	/// Tell the reflection code we are not related to scripting
-	inline bool scripting() const { return false; }
+	inline bool isReading() const { return true; }
+	/// Tell the reflection code we are not writing
+	inline bool isWriting() const { return false; }
 	/// Is the thing currently being read 'complex', i.e. does it have children
-	inline bool isComplex() const { return indent != expected_indent - 1 || value.empty(); }
-	/// Add a as an alias for b, all keys a will be replaced with b, only if file_app_version < end_version
-	void addAlias(Version end_version, const Char* a, const Char* b);
-	/// Ignore old keys
-	void handleIgnore(int, const Char*);
+	inline bool isCompound() const { return indent != expected_indent - 1 || value.empty(); }
+	/// Get the version of the format we are reading
+	inline Version formatVersion() const { return file_app_version; }
 	
 	/// Read and check the application version
 	void handleAppVersion();
@@ -137,13 +135,6 @@ class Reader {
 		HANDLED,		///< We have handled a value, and moved to the next line, previous_value is the value we just handled
 		UNHANDLED,		///< Something has been 'unhandled()'
 	} state;
-	/// Aliasses for compatability
-	struct Alias {
-		String  new_key;
-		Version end_version;
-	};
-	/// Aliasses for compatability
-	map<String, Alias> aliasses;
 	/// Should all invalid keys be ignored?
 	bool ignore_invalid;
 	

src/util/io/writer.hpp

@@ -29,11 +29,10 @@ class Writer {
 	Writer(const OutputStreamP& output, Version file_app_version);
 	
 	/// Tell the reflection code we are not reading
-	inline bool reading()   const { return false; }
-	inline bool scripting() const { return false; }
-	inline bool isComplex() const { return true; }
-	inline void addAlias(int, const Char*, const Char*) {}
-	inline void handleIgnore(int, const Char*) {}
+	inline bool isReading() const { return false; }
+	inline bool isWriting() const { return true; }
+	inline bool isCompound() const { return true; }
+	inline Version formatVersion() const { return app_version; }
 	
 	// --------------------------------------------------- : Handling objects
 	/// Handle an object: write it under the given name

src/util/reflect.hpp

@@ -25,7 +25,7 @@
  */
 #define DECLARE_REFLECTION()											\
           protected:													\
-			template<class Tag> void reflect_impl(Tag& tag);			\
+			template<class Reflector> void reflect_impl(Reflector& reflector); \
 			friend class Reader;										\
 			friend class Writer;										\
 			friend class GetDefaultMember;								\
@@ -38,7 +38,7 @@
 /// Declare that a class supports reflection, which can be overridden in derived classes
 #define DECLARE_REFLECTION_VIRTUAL()									\
           protected:													\
-			template<class Tag> void reflect_impl(Tag& tag);			\
+			template<class Reflector> void reflect_impl(Reflector& reflector); \
 			friend class Reader;										\
 			friend class Writer;										\
 			friend class GetDefaultMember;								\
@@ -72,8 +72,8 @@
 			REFLECT_OBJECT_WRITER(Cls)									\
 			REFLECT_OBJECT_GET_DEFAULT_MEMBER_NOT(Cls)					\
 			REFLECT_OBJECT_GET_MEMBER(Cls)								\
-			template <class Tag>										\
-			void Cls::reflect_impl(Tag& tag)
+			template <class Reflector>									\
+			void Cls::reflect_impl(Reflector& reflector)
 
 /// Implement the refelection of a class type Cls that only uses REFLECT_NAMELESS
 #define IMPLEMENT_REFLECTION_NAMELESS(Cls)								\
@@ -81,16 +81,16 @@
 			REFLECT_OBJECT_WRITER(Cls)									\
 			REFLECT_OBJECT_GET_DEFAULT_MEMBER(Cls)						\
 			REFLECT_OBJECT_GET_MEMBER_NOT(Cls)							\
-			template <class Tag>										\
-			void Cls::reflect_impl(Tag& tag)
+			template <class Reflector>									\
+			void Cls::reflect_impl(Reflector& reflector)
 
 /// Implement the refelection of a class type Cls, but only for Reader and Writer,
 /** There is custom code for GetMember and GetDefaultMember */
 #define IMPLEMENT_REFLECTION_NO_GET_MEMBER(Cls)							\
 			REFLECT_OBJECT_READER(Cls)									\
 			REFLECT_OBJECT_WRITER(Cls)									\
-			template <class Tag>										\
-			void Cls::reflect_impl(Tag& tag)
+			template <class Reflector>									\
+			void Cls::reflect_impl(Reflector& reflector)
 
 /// Implement the refelection of a class type Cls, but only for Reader and Writer
 /** There is no code for GetMember and GetDefaultMember */
@@ -99,18 +99,18 @@
 			REFLECT_OBJECT_WRITER(Cls)									\
 			REFLECT_OBJECT_GET_DEFAULT_MEMBER_NOT(Cls)					\
 			REFLECT_OBJECT_GET_MEMBER_NOT(Cls)							\
-			template <class Tag>										\
-			void Cls::reflect_impl(Tag& tag)
+			template <class Reflector>									\
+			void Cls::reflect_impl(Reflector& reflector)
 
 /// Reflect a variable
-#define REFLECT(var)          tag.handle(_(#var), var)
+#define REFLECT(var)          reflector.handle(_(#var), var)
 /// Reflect a variable under the given name
-#define REFLECT_N(name, var)  tag.handle(_(name), var)
+#define REFLECT_N(name, var)  reflector.handle(_(name), var)
 /// Reflect a variable without a name, should be used only once per class
-#define REFLECT_NAMELESS(var) tag.handle(var)
+#define REFLECT_NAMELESS(var) reflector.handle(var)
 
 /// Declare that the variables of a base class should also be reflected
-#define REFLECT_BASE(Base)    Base::reflect_impl(tag)
+#define REFLECT_BASE(Base)    Base::reflect_impl(reflector)
 
 /// Reflect a group of declarations only when reading
 /** Usage:
@@ -120,7 +120,7 @@
  *   }
  *  @endcode
  */
-#define REFLECT_IF_READING    if (tag.reading())
+#define REFLECT_IF_READING    if (reflector.isReading())
 
 /// Reflect a group of declarations only when *not* reading
 /** Usage:
@@ -130,24 +130,29 @@
  *   }
  *  @endcode
  */
-#define REFLECT_IF_NOT_READING  if (!tag.reading())
+#define REFLECT_IF_NOT_READING  if (!reflector.isReading())
 
-/// Add an alias for backwards compatability
-/** If a key 'old' is encountered in the input file, it is interpreted as 'new' for versions < version
+/// Reflect a group of declarations only when either
+///  a. reading a compound value, or
+///  b. not reading, and the condition is true
+#define REFLECT_IF_READING_COMPOUND_OR(cond) if (reflector.isReading() ? reflector.isCompound() : cond)
+
+/// Add an alias for backwards compatibility
+/** If a key 'name' is encountered in the input file, it is interpreted as 'var' for versions < version
  *  Example:
  *  @code
- *   REFLECT_ALIAS(300, "style", "stylesheet") // prior to 0.3.0 style was used instead of stylesheet
+ *   REFLECT_ALIAS(<300, "style", stylesheet) // prior to 0.3.0 style was used instead of stylesheet
  *  @encode
  */
-#define REFLECT_ALIAS(version, old, new) tag.addAlias(version, _(old), _(new))
+#define REFLECT_COMPAT(cond, name, var) if (reflector.formatVersion() cond) REFLECT_N(name,var)
 
-/// Ignore things for backwards compatability for versions < 'version'
-#define REFLECT_IGNORE(version, old) tag.handleIgnore(version, _(old))
+/// Ignore things for backwards compatibility for versions < 'version'
+#define REFLECT_COMPAT_IGNORE(cond, name, Type) if (reflector.formatVersion() cond) {Type ignored; REFLECT_N(name,ignored);}
 
 /// Reflect a variable, ignores the variable for scripting
-#define REFLECT_NO_SCRIPT(var)          tag.handleNoScript(_(#var), var)
+#define REFLECT_NO_SCRIPT(var)          reflector.handleNoScript(_(#var), var)
 /// Reflect a variable under the given name
-#define REFLECT_NO_SCRIPT_N(name, var)  tag.handleNoScript(_(name), var)
+#define REFLECT_NO_SCRIPT_N(name, var)  reflector.handleNoScript(_(name), var)
 
 /// Explicitly instantiate reflection; this is occasionally required.
 #define INSTANTIATE_REFLECTION(Class)								\
@@ -162,7 +167,7 @@
 
 // ----------------------------------------------------------------------------- : Reflecting enums
 
-/// Implement the refelection of a enumeration type Enum
+/// Implement the reflection of an enumeration type Enum
 /** Usage:
  *    @code
  *     IMPLEMENT_REFLECTION_ENUM(MyEnum) {
@@ -178,20 +183,20 @@
  *   - Writer::handle(const Enum&)
  *   - GetDefaultMember::handle(const Enum&)
  */
-#define IMPLEMENT_REFLECTION_ENUM(Enum)									\
-			template <class Tag>										\
-			void reflect_ ## Enum (Enum& enum_, Tag& tag);				\
-			REFLECT_ENUM_READER(Enum)									\
-			REFLECT_ENUM_WRITER(Enum)									\
-			REFLECT_ENUM_GET_MEMBER(Enum)								\
-			template <class Tag>										\
-			void reflect_ ## Enum (Enum& enum_, Tag& tag)
+#define IMPLEMENT_REFLECTION_ENUM(Enum) \
+			template <class ER> \
+			void reflect_ ## Enum (Enum& enum_, ER& enum_reflector); \
+			REFLECT_ENUM_READER(Enum) \
+			REFLECT_ENUM_WRITER(Enum) \
+			REFLECT_ENUM_GET_MEMBER(Enum) \
+			template <class ER> \
+			void reflect_ ## Enum (Enum& enum_, ER& enum_reflector)
 
 /// Declare a possible value of an enum
-#define VALUE(val)			tag.handle(_(#val), val, enum_)
+#define VALUE(val)			enum_reflector.handle(_(#val), val, enum_)
 
 /// Declare a possible value of an enum under the given name
-#define VALUE_N(name, val)	tag.handle(_(name), val, enum_)
+#define VALUE_N(name, val)	enum_reflector.handle(_(name), val, enum_)
 
 // ----------------------------------------------------------------------------- : EOF
 #endif