projects/mde: mde/lookup/Options.d comparison

comparison mde/lookup/Options.d @ 94:9520cc0448e5

Boolean options are now encapsulated within a Content class (currently an experiment). This should facilitate generic option editing widgets.

author	Diggory Hardy <diggory.hardy@gmail.com>
date	Thu, 23 Oct 2008 17:45:49 +0100
parents	97e6dce08037
children	2a364c7d82c9

comparison

equal deleted inserted replaced

-:08a4ae11454b
+:9520cc0448e5
 module mde.lookup.Options;
 import mde.setup.paths;
 import mde.exception;
+public import mde.gui.content.Content;
 import mde.file.mergetag.Reader;
 import mde.file.mergetag.Writer;
 import mde.file.mergetag.DataSet;
 import mde.file.serialize;
 *
 * Each sub-class provides named variables for maximal-speed reading. Local sub-class references
 * should be used for reading variables, and via the addOptionsClass() hook will be loaded from
 * files during pre-init (init0 stage). Do not write changes directly to the subclasses or they will
 * not be saved; instead use set(), for example, miscOpts.set!(char[])("L10n","en-GB"). Use an
-* example like OptionsMisc as a template for creating a new Options sub-class.
+* example like MiscOptions as a template for creating a new Options sub-class.
 *
 * Optionally, overload the validate() function. This is called after loading, allowing conditions
 * to be enforced on variables. Use set!()() to change the variables. If an exception is thrown,
 * init will abort and the executable won't start.
 *
 protected this() {}   /// Do not instantiate directly.
 // All supported types, for generic handling via templates. It should be possible to change
 // the supported types simply by changing this list now (untested).
 template store(A...) { alias A store; }
-alias store!(bool, int, double, char[]) TYPES;
+alias store!(int, double, char[]) TYPES;//FIXME removed bool
 //BEGIN Templates: internal
 private {
 // Get name of a type. Basically just stringof, but special handling for arrays.
 // Use TName!(T) for a valid symbol name, and T.stringof for a type.
 template TName(T : T[]) {
 template TName(T) {
 const char[] TName = T.stringof;
 }
 // Pointer lists
-template PLists(T, A...) {
+template PLists(A...) {
 static if (A.length) {
-const char[] PLists = T.stringof~"*[ID] opts"~TName!(T)~";\n" ~ PLists!(A);
+static if (is (T == bool)) {
-} else
+const char[] PLists = PLists!(A[1..$]);
-const char[] PLists = T.stringof~"*[ID] opts"~TName!(T)~";\n";
+} else
+const char[] PLists = A[0].stringof~"*[ID] opts"~TName!(A[0])~";\n" ~ PLists!(A[1..$]);
+} else
+const char[] PLists = "";
 }
 // True if type is one of A
 template TIsIn(T, A...) {
 static if (A.length) {
 const bool TIsIn = false;	// no more possibilities
 }
 // For addTag
 template addTagMixin(T, A...) {
-const char[] ifBlock = `if (tp == "`~T.stringof~`") {
+static if (is(T == bool)) {
-`~T.stringof~`** p = id in opts`~TName!(T)~`;
+const char[] ifBlock = `if (tp == "`~T.stringof~`") {
-if (p !is null) **p = parseTo!(`~T.stringof~`) (dt);
+auto p = id in opts;
-}`;
+if (p) {
+auto q = cast(BoolContent) (*p);
+if (q) q = parseTo!(`~T.stringof~`) (dt);
+}
+}`;
+} else
+const char[] ifBlock = `if (tp == "`~T.stringof~`") {
+`~T.stringof~`** p = id in opts`~TName!(T)~`;
+if (p !is null) **p = parseTo!(`~T.stringof~`) (dt);
+}`;
 static if (A.length)
 const char[] addTagMixin = ifBlock~` else `~addTagMixin!(A).addTagMixin;
 else
 const char[] addTagMixin = ifBlock;
 }
 static if (A.length) {
 const char[] writeAllMixin =
 `foreach (ID id, `~A[0].stringof~`* val; opts`~TName!(A[0])~`) dlg ("`~A[0].stringof~`", id, parseFrom!(`~A[0].stringof~`) (*val));` ~ writeAllMixin!(A[1..$]);
 } else
 const char[] writeAllMixin = ``;
+}
+// For list
+template listMixin(A...) {
+static if (A.length) {
+const char[] listMixin = `ret ~= opts`~TName!(A[0])~`.keys;` ~ listMixin!(A[1..$]);
+} else
+const char[] listMixin = ``;
 }
 }
 //END Templates: internal
 	void addOptionsClass (Options c, char[] i)
 	in {    // Trap a couple of potential coding errors:
 assert (c !is null);    // Instance must be created before calling addOptionsClass
 assert (((cast(ID) i) in subClasses) is null);  // Don't allow a silent replacement
 } body {
+c.secName = i;
 subClasses[cast(ID) i] = c;
 }
 	// Track all sections for saving/loading/other generic handling.
 Options[ID] subClasses;
 *
 * Due to the way options are handled generically, string IDs must be used to access the options
 * via hash-maps, which is a little slower than direct access but necessary since the option
 * must be changed in two separate places. */
 void set(T) (char[] symbol, T val) {
-static assert (TIsIn!(T,TYPES), "Options does not support type "~T.stringof);
+static assert (TIsIn!(T,TYPES) && !is(T == bool), "Options does not support type "~T.stringof);
 changed = true;     // something got set (don't bother checking this isn't what it already was)
 try {
 mixin (`*(opts`~TName!(T)~`[cast(ID) symbol]) = val;`);
 } catch (ArrayBoundsException) {
 // log and ignore:
 logger.error ("Options.set: invalid symbol");
 }
 }
+/+
 /** Get option symbol of an Options sub-class.
 *
 * Using this method to read an option is not necessary, but allows for generic use.  */
 T get(T) (char[] symbol) {
 static assert (TIsIn!(T,TYPES), "Options does not support type "~T.stringof);
 return *(optsVars[cast(ID) symbol]);
 } catch (ArrayBoundsException) {
 // log and ignore:
 logger.error ("Options.get: invalid symbol");
 }
-}
+}+/
 /** List the names of all options of a specific type. */
-char[][] list(T) () {
+char[][] list () {
-static assert (TIsIn!(T,TYPES), "Options does not support type "~T.stringof);
+char[][] ret;
+mixin (listMixin!(TYPES));
-mixin (`alias opts`~TName!(T)~` optsVars;`);
+return ret;
+}
-return optsVars.keys;
+/// Get all Options stored with a ValueContent.
+ValueContent[char[]] content() {
+return opts;
 }
 /// Variable validate function. This implementation does nothing.
 void validate() {}
 protected {
+char[] secName;         // name of this option setting; set null after translation is loaded
 OptionChanges optionChanges;	// all changes to options (for saving)
 // The "pointer lists", e.g. char[]*[ID] optscharA;
-mixin (PLists!(TYPES));
+mixin (PLists!(TYPES)); //FIXME adds unused optsbool
+ValueContent[char[]] opts;      // generic list of option values
 }
 //BEGIN Mergetag loading/saving code
 void addTag (char[] tp, ID id, char[] dt) {
 mixin(addTagMixin!(TYPES).addTagMixin);
 //END Non-static
 //BEGIN Templates: impl & optionsThis
 private {
+// Replace, e.g., bool, with BoolContent
+template contentName(A) {
+static if (is(A == bool)) {
+const char[] contentName = "BoolContent";
+} else static if (is(A == int)) {
+const char[] contentName = "int";// no IntContent yet
+} else static if (is(A == double)) {
+const char[] contentName = "double";
+} else static if (is(A == char[])) {
+const char[] contentName = "char[]";
+} else
+static assert (false, "unsuppurted type: "~ A);
+}
 // Return index of first comma, or halts if not found.
 template cIndex(char[] A) {
 static if (A.length == 0)
 static assert (false, "Error in implementation");
 else static if (A[0] == ',')
 else static if (A[0] == ';')
 const size_t scIndex = 0;
 else
 const size_t scIndex = 1 + scIndex!(A[1..$]);
 }
-// Look for "type symbols;" in A and return symbols as a comma separated list of names
+/* Look for "type symbols;" in A and return symbols as a comma separated list of names
-// (even if type is encountered more than once). Output may contain spaces and, if
+(even if type is encountered more than once). Output may contain spaces and will have a
-// non-empty, will contain a trailing comma. Assumes scIndex always returns less than A.$.
+trailing comma unless no match was found in which case an empty string is returned.
+Assumes scIndex always returns less than A.$ . */
 template parseT(char[] type, char[] A) {
 static if (A.length < type.length + 1)	// end of input, no match
 const char[] parseT = "";
 else static if (A[0] == ' ')		// leading whitespace: skip
 const char[] parseT = parseT!(type, A[1..$]);
 const char[] parseT = A[type.length+1 .. scIndex!(A)] ~ "," ~
 parseT!(type, A[scIndex!(A)+1 .. $]);
 else					// no match
 const char[] parseT = parseT!(type, A[scIndex!(A)+1 .. $]);
 }
-// May have a trailing comma. Assumes cIndex always returns less than A.$.
+// May have a trailing comma. Assumes cIndex always returns less than A.$ .
 template aaVars(char[] A) {
 static if (A.length == 0)
 const char[] aaVars = "";
 else static if (A[0] == ' ')
 const char[] aaVars = aaVars!(A[1..$]);
 else
 const char[] aaVars = "\""~A[0..cIndex!(A)]~"\"[]:&"~A[0..cIndex!(A)] ~ "," ~
 aaVars!(A[cIndex!(A)+1..$]);
+}
+// May have a trailing comma. Assumes cIndex always returns less than A.$ .
+template aaVarsBool(char[] A) {//FIXME
+static if (A.length == 0)
+const char[] aaVarsBool = "";
+else static if (A[0] == ' ')
+const char[] aaVarsBool = aaVarsBool!(A[1..$]);
+else
+const char[] aaVarsBool = "\""~A[0..cIndex!(A)]~"\"[]:"~A[0..cIndex!(A)] ~ "," ~
+aaVarsBool!(A[cIndex!(A)+1..$]);
 }
 // strip Trailing Comma
 template sTC(char[] A) {
 static if (A.length && A[$-1] == ',')
 const char[] sTC = A[0..$-1];
 else static if (A[0] == ' ')
 const char[] listOrNull = listOrNull!(A[1..$]);
 else
 const char[] listOrNull = "["~A~"]";
 }
+// if B is empty return an empty string otherswise return what's below:
+template catOrNothing(char[] A,char[] B) {
+static if (B.length)
+const char[] catOrNothing = A~` `~sTC!(B)~";\n";
+else
+const char[] catOrNothing = ``;
+}
+// foreach decl...
+template createBCs(char[] A) {
+static if (A.length == 0)
+const char[] createBCs = "";
+else static if (A[0] == ' ')
+const char[] createBCs = createBCs!(A[1..$]);
+else
+const char[] createBCs = A[0..cIndex!(A)]~ " = new BoolContent (false);\n"~
+createBCs!(A[cIndex!(A)+1..$]);
+}
 // for recursing on TYPES
 template optionsThisInternal(char[] A, B...) {
 static if (B.length) {
+static if (is(B[0] == bool)) {//FIXME
+const char[] optionsThisInternal = createBCs!(parseT!(B[0].stringof,A))~
+`opts = `~listOrNull!(sTC!(aaVarsBool!(parseT!(B[0].stringof,A))))~";\n" ~
+optionsThisInternal!(A,B[1..$]);
+} else
 const char[] optionsThisInternal = `opts`~TName!(B[0])~` = `~listOrNull!(sTC!(aaVars!(parseT!(B[0].stringof,A))))~";\n" ~ optionsThisInternal!(A,B[1..$]);
 } else
 const char[] optionsThisInternal = ``;
 }
+template declValsInternal(char[] A, B...) {
+static if (B.length) {
+const char[] declValsInternal = catOrNothing!(contentName!(B[0]),parseT!(B[0].stringof,A)) ~ declValsInternal!(A,B[1..$]);
+} else
+const char[] declValsInternal = ``;
+}
 } protected {
+/** Declares the values.
+*
+* Basic types are replaced with a ValueContent class to keep the option synchronized and
+* generalize use. */
+template declVals(char[] A) {
+const char[] declVals = declValsInternal!(A, TYPES,bool);
+}
 /** Produces the implementation code to go in the constuctor. */
 template optionsThis(char[] A) {
 const char[] optionsThis =
 "optionChanges = new OptionChanges;\n" ~
-optionsThisInternal!(A,TYPES);
+optionsThisInternal!(A,TYPES,bool);
 }
 /+ Needs too many custom parameters to be worth it? Plus makes class less readable.
 /** Produces the implementation code to go in the static constuctor. */
 template optClassAdd(char[] symb) {
 const char[] optClassAdd = symb ~ "=new "~classinfo(this).name~";\n";//Options.addOptionsClass("~symb~", );\n";
 * mixin (impl ("bool a, b; int i;"));
 * ---
 *
 * In case this() needs to be customized, mixin(impl!(A)) is equivalent to:
 * ---
-* mixin (A~`
+* mixin (declVals!(A)~`
 this () {
 	`~optionsThis!(A)~`
 	}`);
 * ---
 *
 * necessary.
 *
 * Extending: mixins could also be used for the static this() {...} or even the whole
 * class, but doing so would rather decrease readability of any implementation. */
 template impl(char[] A /+, char[] symb+/) {
-const char[] impl = A~"\nthis(){\n"~optionsThis!(A)~"}";
+const char[] impl = declVals!(A)~"\nthis(){\n"~optionsThis!(A)~"}";
 // ~"\nstatic this(){\n"~optClassAdd!(symb)~"}"
 }
 }
 //END Templates: impl & optionsThis
 }
 *
 * To create a new Options sub-class, just copy, paste and adjust.
 */
 /** A home for all miscellaneous options, at least for now. */
-OptionsMisc miscOpts;
+MiscOptions miscOpts;
-class OptionsMisc : Options {
+class MiscOptions : Options {
-mixin (impl!("bool exitImmediately; int maxThreads, logOptions; double pollInterval; char[] L10n, a,b,c,g,z;"));
+const A = "bool exitImmediately; int maxThreads, logOptions; double pollInterval; char[] L10n;";
+//pragma (msg, impl!(A));
+mixin (impl!(A));
 void validate() {
 // Try to enforce sensible values, whilst being reasonably flexible:
 if (miscOpts.maxThreads < 1 || miscOpts.maxThreads > 64) {
 logger.warn ("maxThreads must be in the range 1-64. Defaulting to 4.");
 if (pollInterval !<= 1.0 || pollInterval !>= 0.0)
 set!(double) ("pollInterval", 0.01);
 }
 static this() {
-miscOpts = new OptionsMisc;
+miscOpts = new MiscOptions;
-Options.addOptionsClass (miscOpts, "misc");
+Options.addOptionsClass (miscOpts, "MiscOptions");
 }
 }

Mercurial > projects > mde

comparison mde/lookup/Options.d @ 94:9520cc0448e5