Changeset 15116

Timestamp:

Sep 29, 2007, 12:18:39 PM (19 years ago)

Author:

eugene

Message:

RULEs now allow MULTI entries, which act as an OR list

File:

• trunk/psModules/src/config/pmConfig.c (modified) (5 diffs)

trunk/psModules/src/config/pmConfig.c

@@ -4 +4 @@
  *  @author EAM (IfA)
  *
- *  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-09-05 02:30:30 $
+ *  @version $Revision: 1.105 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-09-29 22:18:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -823 +823 @@
 
 
-// XXX aren't these (return false) below errors: call psError?
+// does this header match the specified camera format?  answer is supplied to 'valid' the
+// return value defines the error condition. error only on config errors
 bool pmConfigValidateCameraFormat(bool *valid, const psMetadata *cameraFormat, const psMetadata *header)
 {
@@ -839 +840 @@
     }
 
-    // Apply the rules
-    psMetadataIterator *ruleIter = psMetadataIteratorAlloc(rule, PS_LIST_HEAD, NULL); // Rule iterator
-    psMetadataItem *ruleItem = NULL;    // Item from the metadata
+    // grab the metadata items in sequence by key so we get the MULTI entry
+    psList *keyList = psMetadataKeys (rule);
+    psArray *keys = psListToArray (keyList);
+    if (! keys) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to read rule for camera.");
+        *valid = false;
+        return false;
+    }
 
     *valid = true;
-    while (*valid && (ruleItem = psMetadataGetAndIncrement(ruleIter))) {
-        // Check for the existence of the rule
+    for (int i = 0; *valid && (i < keys->n); i++) {
+
+        // get the ruleItem for this key
+        psMetadataItem *ruleItem = psMetadataLookup(rule, keys->data[i]);
+
+        // Check for the existence of the rule in the header
         psMetadataItem *headerItem = psMetadataLookup(header, ruleItem->name);
         if (! headerItem) {
@@ -851 +861 @@
             psTrace("psModules.config", 5, "Can't find %s", ruleItem->name);
             *valid = false;
-        }
-
-        // Check to see if the rule works
-        if (headerItem && !psMetadataItemCompare(headerItem, ruleItem)) {
-            psTrace("psModules.config", 5, "%s doesn't match.", ruleItem->name);
-            *valid = false;
-        }
-    } // Iterating through the RULEs
-
-    psFree(ruleIter);
+            continue;
+        }
+
+        // if the RULE type is a primitive type (int, float, etc) or string compare directly
+        if (PS_DATA_IS_PRIMITIVE (ruleItem->type) || (ruleItem->type == PS_DATA_STRING)) {
+            // Check to see if the rule works
+            if (!psMetadataItemCompare(headerItem, ruleItem)) {
+                psTrace("psModules.config", 5, "%s doesn't match.", ruleItem->name);
+                *valid = false;
+            }
+            continue;
+        } 
+
+        // for MULTI, try each one & succeed if any match (valid = true is default state)
+        if (ruleItem->type == PS_DATA_METADATA_MULTI) {
+            bool found = false;
+            for (int j = 0; j < ruleItem->data.list->n; j++) {
+                psMetadataItem *entry = psListGet (ruleItem->data.list, j);
+                assert (entry);
+                if (psMetadataItemCompare(headerItem, entry)) {
+                    found = true;
+                    psTrace("psModules.config", 5, "%s in multi list matches.", ruleItem->name);
+                    break;
+                }
+            }
+            if (!found) {
+                *valid = false;
+                psTrace("psModules.config", 5, "%s doesn't match.", ruleItem->name);
+            }
+            continue;
+        }
+
+        psError(PS_ERR_UNKNOWN, false, "Invalid type for RULE %s.", ruleItem->name);
+        *valid = false;
+        psFree (keyList);
+        psFree (keys);
+        return false;
+    }
+
+    psFree (keyList);
+    psFree (keys);
     return true;
 }
@@ -1096 +1137 @@
     psMetadataItem *rulesItem = NULL;   // Item from iteration
     while ((rulesItem = psMetadataGetAndIncrement(rulesIter))) {
-        psMetadataItem *newItem = psMetadataItemCopy(rulesItem); // Copy of item
-        psMetadataAddItem(header, newItem, PS_LIST_TAIL, PS_META_REPLACE);
-        psFree(newItem);                // Drop reference
+        // this will insert each of the MULTI entries, writing over the previous copies
+        if (PS_DATA_IS_PRIMITIVE (rulesItem->type) || (rulesItem->type == PS_DATA_STRING)) {
+            psMetadataItem *newItem = psMetadataItemCopy(rulesItem); // Copy of item
+            psMetadataAddItem(header, newItem, PS_LIST_TAIL, PS_META_REPLACE);
+            psFree(newItem);                // Drop reference
+            continue;
+        }
+        
+        # if (0) // XXX not needed
+        // for MULTI entries, supply the first one
+        if (rulesItem->type == PS_DATA_METADATA_MULTI) {
+            psMetadataItem *entry = psListGet (rulesItem->data.list, PS_LIST_HEAD);
+            if (!entry) {
+                psError(PS_ERR_UNKNOWN, true, "No entries for MULTI RULE item.");
+                return false;
+            }
+            psMetadataItem *newItem = psMetadataItemCopy(entry); // Copy of item
+            psMetadataAddItem(header, newItem, PS_LIST_TAIL, PS_META_REPLACE);
+            psFree(newItem);                // Drop reference
+            continue;
+        }
+        # endif
+
+        psError(PS_ERR_UNKNOWN, false, "Invalid type for RULE %s.", rulesItem->name);
+        return false;
     }
     psFree(rulesIter);