Changeset 6195 for trunk/psLib/src/types

Timestamp:

Jan 25, 2006, 2:46:54 PM (21 years ago)

Author:

drobbin

Message:

Fixed/updated MetadataCopy (bug579) (& tests). Now makes deeper copies of items.

File:

• trunk/psLib/src/types/psMetadata.c (modified) (2 diffs)

trunk/psLib/src/types/psMetadata.c

@@ -12 +12 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.95 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-01-25 03:02:47 $
+ *  @version $Revision: 1.96 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-01-26 00:46:54 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -324 +324 @@
         out = psMetadataAlloc();
     }
-    psMetadataItem *item = NULL;
+    //    psMetadataItem *item = NULL;
     psMetadataIterator *iter = NULL;
     iter = psMetadataIteratorAlloc(*(psMetadata**)&in, PS_LIST_HEAD, NULL);
-    item = psMetadataGetAndIncrement(iter);
-    while (item != NULL) {
-        psMetadataAddItem(out, item, PS_LIST_TAIL, 0);
+    /*
         item = psMetadataGetAndIncrement(iter);
-    }
-    psFree(item);
+        while (item != NULL) {
+            psMetadataAddItem(out, item, PS_LIST_TAIL, 0);
+            item = psMetadataGetAndIncrement(iter);
+        }
+        psFree(item);
+        psFree(iter);
+        return out;
+    */
+    psMetadataItem *inItem = NULL;
+    unsigned long numPointers = 0;      // Number of pointers we were forced to copy
+    while ((inItem = psMetadataGetAndIncrement(iter))) {
+        // Need to look for MULTI, which won't be picked up using the iterator.
+        psMetadataItem *multiCheckItem = psMetadataLookup(in, inItem->name);
+        unsigned int flag = PS_META_REPLACE; // Flag to indicate MULTI; otherwise, replace
+        if (multiCheckItem->type == PS_DATA_METADATA_MULTI) {
+            psTrace(__func__, 10, "MULTI: %s (%s)\n", inItem->name, inItem->comment);
+            flag = PS_DATA_METADATA_MULTI;
+        }
+        psTrace(__func__, 5, "Copying %s (%s)...\n", inItem->name, inItem->comment);
+
+
+        //        case PS_TYPE_##NAME:
+        #define PS_METADATA_COPY_CASE(NAME,TYPE) \
+    case PS_DATA_##NAME: \
+        if (! psMetadataAdd(out, PS_LIST_TAIL, inItem->name, \
+                            PS_DATA_##NAME | flag, inItem->comment, inItem->data.TYPE)) { \
+            psErrorStackPrint(stderr, "Error copying %s (%s) in the metadata\n", \
+                              inItem->name, inItem->comment); \
+        } \
+        break;
+
+        switch (inItem->type) {
+            // Numerical types
+            PS_METADATA_COPY_CASE(BOOL,B);
+            //            PS_METADATA_COPY_CASE(S8,S8);
+            //            PS_METADATA_COPY_CASE(S16,S16);
+            PS_METADATA_COPY_CASE(S32,S32);
+            //            PS_METADATA_COPY_CASE(U8,U8);
+            //            PS_METADATA_COPY_CASE(U16,U16);
+            //            PS_METADATA_COPY_CASE(U32,U32);
+            PS_METADATA_COPY_CASE(F32,F32);
+            PS_METADATA_COPY_CASE(F64,F64);
+
+        case PS_DATA_VECTOR: {
+                psVector *vecCopy = psVectorCopy(NULL, (psVector*)(inItem->data.V),
+                                                 ((psVector*)(inItem->data.V))->type.type);
+                if (vecCopy == NULL) {
+                    psError(PS_ERR_BAD_PARAMETER_NULL, false,
+                            "Error copying vector.  Vector skipped.\n");
+                } else {
+                    psMetadataAddVector(out, PS_LIST_TAIL, inItem->name, flag,
+                                        inItem->comment, vecCopy);
+                    psFree(vecCopy);
+                }
+                break;
+            }
+        case PS_DATA_TIME: {
+                psTime *timeCopy = p_psTimeCopy( (psTime*)(inItem->data.V) );
+                if (timeCopy == NULL) {
+                    psError(PS_ERR_BAD_PARAMETER_NULL, false,
+                            "Error copying time.  Time skipped.\n");
+                } else {
+                    psMetadataAddTime(out, PS_LIST_TAIL, inItem->name, flag,
+                                      inItem->comment, timeCopy);
+                    psFree(timeCopy);
+                }
+                break;
+            }
+            // String: relying on the fact that this will copy the string, not point at it.
+        case PS_DATA_STRING:
+            psMetadataAdd(out, PS_LIST_TAIL, inItem->name, PS_DATA_STRING |
+                          flag, inItem->comment, inItem->data.V);
+            break;
+            // Metadata: copy the next level and stuff that in too
+        case PS_DATA_METADATA: {
+                psMetadata *metadata = psMetadataCopy(NULL, inItem->data.md);
+                psMetadataAdd(out, PS_LIST_TAIL, inItem->name,
+                              PS_DATA_METADATA | flag, inItem->comment, metadata);
+                psFree(metadata);
+                break;
+            }
+            // Other kinds of pointers
+        default:
+            numPointers++;
+            psTrace(__func__, 10, "Copying a pointer in the metadata: %x\n", inItem->type);
+            psMetadataAdd(out, PS_LIST_TAIL, inItem->name, inItem->type | flag,
+                          inItem->comment, inItem->data.V);
+            break;
+        }
+    }
     psFree(iter);
+
+    if (numPointers > 0) {
+        psLogMsg(__func__, PS_LOG_WARN,
+                 "Forced to copy %d pointers when copying metadata.  Updating the "
+                 "copied psMetadata will affect the original!\n", numPointers);
+    }
+
     return out;
 }