check for missing class types in object instances add optional removal of

    object references and instances for missing types transaction fixes

1 files changed, 74 insertions, 30 deletions

diff --git a/cpp/test/XMLTransform/transform/Populate.cpp b/cpp/test/XMLTransform/transform/Populate.cpp
index c9027568b73..2ebb00d98fe 100644
--- a/cpp/test/XMLTransform/transform/Populate.cpp
+++ b/cpp/test/XMLTransform/transform/Populate.cpp
@@ -83,7 +83,6 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
     Int i;
 
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq dummy;
 
     cout << "transforming primitives... " << flush;
@@ -108,7 +107,10 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "byteToShort", false);
         emitSchemas("xs:byte", "xs:short");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -130,7 +132,10 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "shortToInt", false);
         emitSchemas("xs:short", "xs:int");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -152,7 +157,10 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "intToLong", false);
         emitSchemas("xs:int", "xs:long");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -174,7 +182,10 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "longToByte", false);
         emitSchemas("xs:long", "xs:byte");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;	
 
@@ -196,7 +207,10 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "floatToDouble", false);
         emitSchemas("xs:float", "xs:double");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -223,7 +237,8 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
         emitSchemas("xs:long", "xs:byte");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -256,7 +271,8 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
         emitSchemas("xs:long", "xs:short");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -289,7 +305,8 @@ transformPrimitive(const DBEnvironmentPtr& dbEnv)
         emitSchemas("xs:long", "xs:int");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -323,7 +340,6 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
     Int i;
 
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq dummy;
 
     cout << "transforming primitive sequences... " << flush;
@@ -350,7 +366,10 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "byteToShortSeq", false);
         emitSchemas("tns:_internal.Test.Seq1Type", "tns:_internal.Test.Seq1Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -374,7 +393,10 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "shortToIntSeq", false);
         emitSchemas("tns:_internal.Test.Seq2Type", "tns:_internal.Test.Seq2Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -398,7 +420,10 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "intToLongSeq", false);
         emitSchemas("tns:_internal.Test.Seq3Type", "tns:_internal.Test.Seq3Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -422,7 +447,10 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "longToByteSeq", false);
         emitSchemas("tns:_internal.Test.Seq4Type", "tns:_internal.Test.Seq4Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -451,7 +479,8 @@ transformPrimitiveSequence(const DBEnvironmentPtr& dbEnv)
         emitSchemas("tns:_internal.Test.Seq4Type", "tns:_internal.Test.Seq4Type");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -483,7 +512,6 @@ static void
 transformEnum(const DBEnvironmentPtr& dbEnv)
 {
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq dummy;
 
     cout << "transforming enumerations... " << flush;
@@ -506,7 +534,10 @@ transformEnum(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "enum", false);
         emitSchemas("tns:_internal.Test.E1Type", "tns:_internal.Test.E1Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -529,7 +560,8 @@ transformEnum(const DBEnvironmentPtr& dbEnv)
         emitSchemas("tns:_internal.Test.E1Type", "tns:_internal.Test.E1Type");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -561,7 +593,6 @@ static void
 transformDictionary(const DBEnvironmentPtr& dbEnv)
 {
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq dummy;
 
     cout << "transforming dictionaries... " << flush;
@@ -586,7 +617,10 @@ transformDictionary(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "dict", false);
         emitSchemas("tns:_internal.Test.D1Type", "tns:_internal.Test.D1Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -611,7 +645,8 @@ transformDictionary(const DBEnvironmentPtr& dbEnv)
         emitSchemas("tns:_internal.Test.D1Type", "tns:_internal.Test.D1Type");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -643,7 +678,6 @@ static void
 transformStruct(const DBEnvironmentPtr& dbEnv)
 {
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq dummy;
 
     cout << "transforming structs... " << flush;
@@ -674,7 +708,10 @@ transformStruct(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "struct", false);
         emitSchemas("tns:_internal.Test.S1Type", "tns:_internal.Test.S1Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -704,7 +741,8 @@ transformStruct(const DBEnvironmentPtr& dbEnv)
         emitSchemas("tns:_internal.Test.S1Type", "tns:_internal.Test.S1Type");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -751,7 +789,6 @@ static void
 transformClass(const DBEnvironmentPtr& dbEnv)
 {
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq dummy;
 
     cout << "transforming classes... " << flush;
@@ -834,7 +871,10 @@ transformClass(const DBEnvironmentPtr& dbEnv)
 
         db = dbEnv->openDBWithTxn(0, "class", false);
         emitSchemas("tns:_internal.Test.C1Type", "tns:_internal.Test.C1Type");
-        transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
+        }
         db->close();
         db = 0;
 
@@ -880,7 +920,8 @@ transformClass(const DBEnvironmentPtr& dbEnv)
         emitSchemas("tns:_internal.Test.C1Type", "tns:_internal.Test.C1Type");
         try
         {
-            transformer.transform(dbEnv, db, dummy, dummy, paths, paths, oldSchema, newSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, dummy, dummy, paths, paths, false);
+            transformer.transform(oldSchema, newSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)
@@ -927,7 +968,6 @@ static void
 transformEvictor(const DBEnvironmentPtr& dbEnv)
 {
     DBPtr db;
-    XMLTransform::DBTransformer transformer;
     StringSeq loadOld, loadNew;
     Identity ident;
     EvictorPtr evictor;
@@ -1032,7 +1072,10 @@ transformEvictor(const DBEnvironmentPtr& dbEnv)
         db = 0;
 
         db = dbEnv->openDBWithTxn(0, "evictor", false);
-        transformer.transform(dbEnv, db, loadOld, loadNew, paths, paths, evictorSchema);
+        {
+            XMLTransform::DBTransformer transformer(dbEnv, db, loadOld, loadNew, paths, paths, false);
+            transformer.transform(evictorSchema);
+        }
         db->close();
         db = 0;
 
@@ -1081,7 +1124,8 @@ transformEvictor(const DBEnvironmentPtr& dbEnv)
         db = dbEnv->openDBWithTxn(0, "failure", false);
         try
         {
-            transformer.transform(dbEnv, db, loadOld, loadNew, paths, paths, evictorSchema);
+            XMLTransform::DBTransformer transformer(dbEnv, db, loadOld, loadNew, paths, paths, false);
+            transformer.transform(evictorSchema);
             test(false);
         }
         catch(const XMLTransform::IllegalTransform&)