Allow more options for setting boolean flag values in SkFlags.

tools/SkFlags.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SK_FLAGS_H
 #define SK_FLAGS_H
 
@@ skipping 19 matching lines @@
  *  For example, the line
  *
  *  DEFINE_bool(boolean, false, "The variable boolean does such and such");
  *
  *  will create the following variable:
  *
  *  bool FLAGS_boolean;
  *
  *  which will initially be set to false, and can be set to true by using the
  *  flag "--boolean" on the commandline. "--noboolean" will set FLAGS_boolean
- *  to false. (Single dashes are also permitted for this and other flags.) The
- *  helpString will be printed if the help flag (-h or -help) is used.
+ *  to false. FLAGS_boolean can also be set using "--boolean=true" or
+ *  "--boolean true" (where "true" can be replaced by "false", "TRUE", "FALSE",
+ *  "1" or "0").
+ *
+ *  Single dashes are also permitted for this and other flags.
+ *
+ *  The helpString will be printed if the help flag (-h or -help) is used.

[reed1, 2013/03/20 20:09:41]

do you mean --help or -help?

[scroggo, 2013/03/20 21:12:05]

In reality, I mean --help or -help or -h or --h. For simplicity, I included only
the ones that are standard (two dashes for multiple characters, one for single
characters).

  *
  *  Similarly, the line
  *
  *  DEFINE_int32(integer, .., ..);
  *
  *  will create
  *
  *  int32_t FLAGS_integer;
  *
  *  and
@@ skipping 168 matching lines @@
 
     static bool CreateDoubleFlag(const char* name, double* pDouble,
                                  double defaultValue, const char* helpString) {
         SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kDouble_FlagType, helpString));
         info->fDoubleValue = pDouble;
         *info->fDoubleValue = info->fDefaultDouble = defaultValue;
         return true;
     }
 
     /**
-     *  Returns true if the string matches this flag. For a bool, also sets the
-     *  value, since a bool is specified as true or false by --name or --noname.
+     *  Check to see whether string represents a boolean value.
+     *  @param string C style string to parse.
+     *  @param result Pointer to a boolean which will be set to the value in the string, if the
+     *      string represents a boolean.
+     *  @param boolean True if the string represents a boolean, false otherwise.
+     */
+    static bool ParseBoolArg(const char* string, bool* result) {

[reed1, 2013/03/20 20:09:41]

Is it cleaner to use a small table of strings for these, instead of explicit
||s?

[scroggo, 2013/03/20 21:12:05]

Done.

+        SkString parameter(string);
+        if (parameter.equals("1") || parameter.equals("TRUE") || parameter.equals("true")) {
+            *result = true;
+            return true;
+        }
+        if (parameter.equals("0") || parameter.equals("FALSE") || parameter.equals("false")) {
+            *result = false;
+            return true;
+        }
+        SkDebugf("Parameter \"%s\" not supported.\n", string);
+        return false;
+    }
+
+    /**
+     *  Returns true if the string matches this flag.
+     *  For a boolean flag, also sets the value, since a boolean flag can be set in a number of ways
+     *  without looking at the following string:
+     *      --name
+     *      --noname
+     *      --name=true
+     *      --name=false
+     *      --name=1
+     *      --name=0
+     *      --name=TRUE
+     *      --name=FALSE
      */
     bool match(const char* string) {
         if (SkStrStartsWith(string, '-') && strlen(string) > 1) {
             string++;
             // Allow one or two dashes
             if (SkStrStartsWith(string, '-') && strlen(string) > 1) {
                 string++;
             }
             if (kBool_FlagType == fFlagType) {
                 // In this case, go ahead and set the value.
                 if (fName.equals(string) || fShortName.equals(string)) {
                     *fBoolValue = true;
                     return true;
                 }
                 if (SkStrStartsWith(string, "no") && strlen(string) > 2) {
                     string += 2;
                     if (fName.equals(string) || fShortName.equals(string)) {
                         *fBoolValue = false;
                         return true;
                     }
                     return false;
                 }
+                int equalIndex = SkStrFind(string, "=");
+                if (equalIndex > 0) {
+                    // The string has an equal sign. Check to see if the string matches.
+                    SkString flag(string, equalIndex);
+                    if (flag.equals(fName) || flag.equals(fShortName)) {
+                        // Check to see if the remainder beyond the equal sign is true or false:
+                        string += equalIndex + 1;
+                        ParseBoolArg(string, fBoolValue);
+                        return true;
+                    }
+                }
             }
             return fName.equals(string) || fShortName.equals(string);
         } else {
             // Has no dash
             return false;
         }
         return false;
     }
 
     FlagTypes getFlagType() const { return fFlagType; }
@@ skipping 23 matching lines @@
     }
 
     void setDouble(double value) {
         if (kDouble_FlagType == fFlagType) {
             *fDoubleValue = value;
         } else {
             SkASSERT(!"Can only call setDouble on kDouble_FlagType");
         }
     }
 
+    void setBool(bool value) {
+        if (kBool_FlagType == fFlagType) {
+            *fBoolValue = value;
+        } else {
+            SkASSERT(!"Can only call setBool on kBool_FlagType");
+        }
+    }
+
     SkFlagInfo* next() { return fNext; }
 
     const SkString& name() const { return fName; }
 
     const SkString& help() const { return fHelpString; }
 
     SkString defaultValue() const {
         SkString result;
         switch (fFlagType) {
             case SkFlagInfo::kBool_FlagType:
@@ skipping 56 matching lines @@
     double*              fDoubleValue;
     double               fDefaultDouble;
     SkTDArray<const char*>* fStrings;
     // Both for the help string and in case fStrings is empty.
     SkString             fDefaultString;
 
     // In order to keep a linked list.
     SkFlagInfo*          fNext;
 };
 #endif // SK_FLAGS_H