o Added a Clone() method to InterchangeObject and derivatives

   that allows making a descriptor copy that is not owned by
   any other strucure. The caller must arrange to delete the
   object pointer returned.

 o While implementing the above it became obvious that the
   reference-to-a-pointer-to-the-dictionary idiom that is used
   throughout the lower levels of the MXF library was the
   cause of much more grief than it was originally designed to
   prevent. This was made even more obvious when I replaced all
   of it with simple pointers, which revealed several shadow
   instances of m_Dict that were only reliable while the object
   that held them was valid.

1 files changed, 102 insertions, 102 deletions

diff --git a/src/Metadata.h b/src/Metadata.h
index ab11034..e559909 100755..100644
--- a/src/Metadata.h
+++ b/src/Metadata.h
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2005-2017, John Hurst
+Copyright (c) 2005-2021, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -38,7 +38,7 @@ namespace ASDCP
 {
   namespace MXF
     {
-      void Metadata_InitTypes(const Dictionary*& Dict);
+      void Metadata_InitTypes(const Dictionary* Dict);
 
       //
 
@@ -48,7 +48,6 @@ namespace ASDCP
 	  Identification();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID ThisGenerationUID;
           UTF16String CompanyName;
           UTF16String ProductName;
@@ -59,12 +58,13 @@ namespace ASDCP
           VersionType ToolkitVersion;
           optional_property<UTF16String > Platform;
 
-      Identification(const Dictionary*& d);
+      Identification(const Dictionary* d);
       Identification(const Identification& rhs);
       virtual ~Identification() {}
 
       const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const Identification& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "Identification"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -79,16 +79,16 @@ namespace ASDCP
 	  ContentStorage();
 
 	public:
-	  const Dictionary*& m_Dict;
           Batch<UUID> Packages;
           Batch<UUID> EssenceContainerData;
 
-      ContentStorage(const Dictionary*& d);
+      ContentStorage(const Dictionary* d);
       ContentStorage(const ContentStorage& rhs);
       virtual ~ContentStorage() {}
 
       const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const ContentStorage& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "ContentStorage"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -103,17 +103,17 @@ namespace ASDCP
 	  EssenceContainerData();
 
 	public:
-	  const Dictionary*& m_Dict;
           UMID LinkedPackageUID;
           optional_property<ui32_t > IndexSID;
           ui32_t BodySID;
 
-      EssenceContainerData(const Dictionary*& d);
+      EssenceContainerData(const Dictionary* d);
       EssenceContainerData(const EssenceContainerData& rhs);
       virtual ~EssenceContainerData() {}
 
       const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const EssenceContainerData& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "EssenceContainerData"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -128,19 +128,19 @@ namespace ASDCP
 	  GenericPackage();
 
 	public:
-	  const Dictionary*& m_Dict;
           UMID PackageUID;
           optional_property<UTF16String > Name;
           Kumu::Timestamp PackageCreationDate;
           Kumu::Timestamp PackageModifiedDate;
           Array<UUID> Tracks;
 
-      GenericPackage(const Dictionary*& d);
+      GenericPackage(const Dictionary* d);
       GenericPackage(const GenericPackage& rhs);
       virtual ~GenericPackage() {}
 
       const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericPackage& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericPackage"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -153,15 +153,15 @@ namespace ASDCP
 	  MaterialPackage();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<UUID > PackageMarker;
 
-      MaterialPackage(const Dictionary*& d);
+      MaterialPackage(const Dictionary* d);
       MaterialPackage(const MaterialPackage& rhs);
       virtual ~MaterialPackage() {}
 
       const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const MaterialPackage& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "MaterialPackage"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -176,15 +176,15 @@ namespace ASDCP
 	  SourcePackage();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID Descriptor;
 
-      SourcePackage(const Dictionary*& d);
+      SourcePackage(const Dictionary* d);
       SourcePackage(const SourcePackage& rhs);
       virtual ~SourcePackage() {}
 
       const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const SourcePackage& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "SourcePackage"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -199,18 +199,18 @@ namespace ASDCP
 	  GenericTrack();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui32_t TrackID;
           ui32_t TrackNumber;
           optional_property<UTF16String > TrackName;
           optional_property<UUID > Sequence;
 
-      GenericTrack(const Dictionary*& d);
+      GenericTrack(const Dictionary* d);
       GenericTrack(const GenericTrack& rhs);
       virtual ~GenericTrack() {}
 
       const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericTrack& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericTrack"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -223,14 +223,14 @@ namespace ASDCP
 	  StaticTrack();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      StaticTrack(const Dictionary*& d);
+      StaticTrack(const Dictionary* d);
       StaticTrack(const StaticTrack& rhs);
       virtual ~StaticTrack() {}
 
       const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const StaticTrack& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "StaticTrack"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -245,16 +245,16 @@ namespace ASDCP
 	  Track();
 
 	public:
-	  const Dictionary*& m_Dict;
           Rational EditRate;
           ui64_t Origin;
 
-      Track(const Dictionary*& d);
+      Track(const Dictionary* d);
       Track(const Track& rhs);
       virtual ~Track() {}
 
       const Track& operator=(const Track& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const Track& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "Track"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -269,16 +269,16 @@ namespace ASDCP
 	  StructuralComponent();
 
 	public:
-	  const Dictionary*& m_Dict;
           UL DataDefinition;
           optional_property<ui64_t > Duration;
 
-      StructuralComponent(const Dictionary*& d);
+      StructuralComponent(const Dictionary* d);
       StructuralComponent(const StructuralComponent& rhs);
       virtual ~StructuralComponent() {}
 
       const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const StructuralComponent& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "StructuralComponent"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -291,15 +291,15 @@ namespace ASDCP
 	  Sequence();
 
 	public:
-	  const Dictionary*& m_Dict;
           Array<UUID> StructuralComponents;
 
-      Sequence(const Dictionary*& d);
+      Sequence(const Dictionary* d);
       Sequence(const Sequence& rhs);
       virtual ~Sequence() {}
 
       const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const Sequence& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "Sequence"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -314,17 +314,17 @@ namespace ASDCP
 	  SourceClip();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui64_t StartPosition;
           UMID SourcePackageID;
           ui32_t SourceTrackID;
 
-      SourceClip(const Dictionary*& d);
+      SourceClip(const Dictionary* d);
       SourceClip(const SourceClip& rhs);
       virtual ~SourceClip() {}
 
       const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const SourceClip& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "SourceClip"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -339,17 +339,17 @@ namespace ASDCP
 	  TimecodeComponent();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui16_t RoundedTimecodeBase;
           ui64_t StartTimecode;
           ui8_t DropFrame;
 
-      TimecodeComponent(const Dictionary*& d);
+      TimecodeComponent(const Dictionary* d);
       TimecodeComponent(const TimecodeComponent& rhs);
       virtual ~TimecodeComponent() {}
 
       const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const TimecodeComponent& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "TimecodeComponent"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -364,16 +364,16 @@ namespace ASDCP
 	  GenericDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           Array<UUID> Locators;
           Array<UUID> SubDescriptors;
 
-      GenericDescriptor(const Dictionary*& d);
+      GenericDescriptor(const Dictionary* d);
       GenericDescriptor(const GenericDescriptor& rhs);
       virtual ~GenericDescriptor() {}
 
       const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -386,19 +386,19 @@ namespace ASDCP
 	  FileDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<ui32_t > LinkedTrackID;
           Rational SampleRate;
           optional_property<ui64_t > ContainerDuration;
           UL EssenceContainer;
           optional_property<UL > Codec;
 
-      FileDescriptor(const Dictionary*& d);
+      FileDescriptor(const Dictionary* d);
       FileDescriptor(const FileDescriptor& rhs);
       virtual ~FileDescriptor() {}
 
       const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const FileDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "FileDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -413,7 +413,6 @@ namespace ASDCP
 	  GenericSoundEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           Rational AudioSamplingRate;
           ui8_t Locked;
           optional_property<ui8_t > AudioRefLevel;
@@ -425,12 +424,13 @@ namespace ASDCP
           optional_property<ui8_t > ReferenceAudioAlignmentLevel;
           optional_property<Rational > ReferenceImageEditRate;
 
-      GenericSoundEssenceDescriptor(const Dictionary*& d);
+      GenericSoundEssenceDescriptor(const Dictionary* d);
       GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs);
       virtual ~GenericSoundEssenceDescriptor() {}
 
       const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericSoundEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -445,18 +445,18 @@ namespace ASDCP
 	  WaveAudioDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui16_t BlockAlign;
           optional_property<ui8_t > SequenceOffset;
           ui32_t AvgBps;
           optional_property<UL > ChannelAssignment;
 
-      WaveAudioDescriptor(const Dictionary*& d);
+      WaveAudioDescriptor(const Dictionary* d);
       WaveAudioDescriptor(const WaveAudioDescriptor& rhs);
       virtual ~WaveAudioDescriptor() {}
 
       const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const WaveAudioDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "WaveAudioDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -471,7 +471,6 @@ namespace ASDCP
 	  GenericPictureEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<ui8_t > SignalStandard;
           ui8_t FrameLayout;
           ui32_t StoredWidth;
@@ -508,12 +507,13 @@ namespace ASDCP
           optional_property<ui32_t > MasteringDisplayMaximumLuminance;
           optional_property<ui32_t > MasteringDisplayMinimumLuminance;
 
-      GenericPictureEssenceDescriptor(const Dictionary*& d);
+      GenericPictureEssenceDescriptor(const Dictionary* d);
       GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs);
       virtual ~GenericPictureEssenceDescriptor() {}
 
       const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericPictureEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -528,7 +528,6 @@ namespace ASDCP
 	  RGBAEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<ui32_t > ComponentMaxRef;
           optional_property<ui32_t > ComponentMinRef;
           optional_property<ui32_t > AlphaMinRef;
@@ -536,12 +535,13 @@ namespace ASDCP
           optional_property<ui8_t > ScanningDirection;
           RGBALayout PixelLayout;
 
-      RGBAEssenceDescriptor(const Dictionary*& d);
+      RGBAEssenceDescriptor(const Dictionary* d);
       RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs);
       virtual ~RGBAEssenceDescriptor() {}
 
       const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const RGBAEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -556,7 +556,6 @@ namespace ASDCP
 	  JPEG2000PictureSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui16_t Rsize;
           ui32_t Xsize;
           ui32_t Ysize;
@@ -575,12 +574,13 @@ namespace ASDCP
           optional_property<Array<Kumu::ArchivableUi16> > J2KProfile;
           optional_property<Array<Kumu::ArchivableUi16> > J2KCorrespondingProfile;
 
-      JPEG2000PictureSubDescriptor(const Dictionary*& d);
+      JPEG2000PictureSubDescriptor(const Dictionary* d);
       JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs);
       virtual ~JPEG2000PictureSubDescriptor() {}
 
       const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const JPEG2000PictureSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -595,7 +595,6 @@ namespace ASDCP
 	  CDCIEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui32_t ComponentDepth;
           ui32_t HorizontalSubsampling;
           optional_property<ui32_t > VerticalSubsampling;
@@ -607,12 +606,13 @@ namespace ASDCP
           optional_property<ui32_t > WhiteReflevel;
           optional_property<ui32_t > ColorRange;
 
-      CDCIEssenceDescriptor(const Dictionary*& d);
+      CDCIEssenceDescriptor(const Dictionary* d);
       CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs);
       virtual ~CDCIEssenceDescriptor() {}
 
       const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const CDCIEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -627,7 +627,6 @@ namespace ASDCP
 	  MPEG2VideoDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<ui8_t > SingleSequence;
           optional_property<ui8_t > ConstantBFrames;
           optional_property<ui8_t > CodedContentType;
@@ -639,12 +638,13 @@ namespace ASDCP
           optional_property<ui32_t > BitRate;
           optional_property<ui8_t > ProfileAndLevel;
 
-      MPEG2VideoDescriptor(const Dictionary*& d);
+      MPEG2VideoDescriptor(const Dictionary* d);
       MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs);
       virtual ~MPEG2VideoDescriptor() {}
 
       const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const MPEG2VideoDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -659,19 +659,19 @@ namespace ASDCP
 	  DMSegment();
 
 	public:
-	  const Dictionary*& m_Dict;
           UL DataDefinition;
           optional_property<ui64_t > Duration;
           optional_property<ui64_t > EventStartPosition;
           optional_property<UTF16String > EventComment;
           UUID DMFramework;
 
-      DMSegment(const Dictionary*& d);
+      DMSegment(const Dictionary* d);
       DMSegment(const DMSegment& rhs);
       virtual ~DMSegment() {}
 
       const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const DMSegment& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "DMSegment"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -686,15 +686,15 @@ namespace ASDCP
 	  CryptographicFramework();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID ContextSR;
 
-      CryptographicFramework(const Dictionary*& d);
+      CryptographicFramework(const Dictionary* d);
       CryptographicFramework(const CryptographicFramework& rhs);
       virtual ~CryptographicFramework() {}
 
       const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const CryptographicFramework& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "CryptographicFramework"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -709,19 +709,19 @@ namespace ASDCP
 	  CryptographicContext();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID ContextID;
           UL SourceEssenceContainer;
           UL CipherAlgorithm;
           UL MICAlgorithm;
           UUID CryptographicKeyID;
 
-      CryptographicContext(const Dictionary*& d);
+      CryptographicContext(const Dictionary* d);
       CryptographicContext(const CryptographicContext& rhs);
       virtual ~CryptographicContext() {}
 
       const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const CryptographicContext& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "CryptographicContext"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -736,15 +736,15 @@ namespace ASDCP
 	  DescriptiveFramework();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<UUID > LinkedDescriptiveFrameworkPlugInId;
 
-      DescriptiveFramework(const Dictionary*& d);
+      DescriptiveFramework(const Dictionary* d);
       DescriptiveFramework(const DescriptiveFramework& rhs);
       virtual ~DescriptiveFramework() {}
 
       const DescriptiveFramework& operator=(const DescriptiveFramework& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const DescriptiveFramework& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "DescriptiveFramework"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -759,15 +759,15 @@ namespace ASDCP
 	  DescriptiveObject();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<UUID > LinkedDescriptiveObjectPlugInId;
 
-      DescriptiveObject(const Dictionary*& d);
+      DescriptiveObject(const Dictionary* d);
       DescriptiveObject(const DescriptiveObject& rhs);
       virtual ~DescriptiveObject() {}
 
       const DescriptiveObject& operator=(const DescriptiveObject& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const DescriptiveObject& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "DescriptiveObject"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -782,15 +782,15 @@ namespace ASDCP
 	  GenericDataEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UL DataEssenceCoding;
 
-      GenericDataEssenceDescriptor(const Dictionary*& d);
+      GenericDataEssenceDescriptor(const Dictionary* d);
       GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs);
       virtual ~GenericDataEssenceDescriptor() {}
 
       const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericDataEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericDataEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -805,7 +805,6 @@ namespace ASDCP
 	  TimedTextDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID ResourceID;
           UTF16String UCSEncoding;
           UTF16String NamespaceURI;
@@ -814,12 +813,13 @@ namespace ASDCP
           optional_property<UTF16String > IntrinsicPictureResolution;
           optional_property<ui8_t > ZPositionInUse;
 
-      TimedTextDescriptor(const Dictionary*& d);
+      TimedTextDescriptor(const Dictionary* d);
       TimedTextDescriptor(const TimedTextDescriptor& rhs);
       virtual ~TimedTextDescriptor() {}
 
       const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const TimedTextDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "TimedTextDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -834,17 +834,17 @@ namespace ASDCP
 	  TimedTextResourceSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID AncillaryResourceID;
           UTF16String MIMEMediaType;
           ui32_t EssenceStreamID;
 
-      TimedTextResourceSubDescriptor(const Dictionary*& d);
+      TimedTextResourceSubDescriptor(const Dictionary* d);
       TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs);
       virtual ~TimedTextResourceSubDescriptor() {}
 
       const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const TimedTextResourceSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -859,14 +859,14 @@ namespace ASDCP
 	  StereoscopicPictureSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      StereoscopicPictureSubDescriptor(const Dictionary*& d);
+      StereoscopicPictureSubDescriptor(const Dictionary* d);
       StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs);
       virtual ~StereoscopicPictureSubDescriptor() {}
 
       const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const StereoscopicPictureSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -881,14 +881,14 @@ namespace ASDCP
 	  ContainerConstraintsSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      ContainerConstraintsSubDescriptor(const Dictionary*& d);
+      ContainerConstraintsSubDescriptor(const Dictionary* d);
       ContainerConstraintsSubDescriptor(const ContainerConstraintsSubDescriptor& rhs);
       virtual ~ContainerConstraintsSubDescriptor() {}
 
       const ContainerConstraintsSubDescriptor& operator=(const ContainerConstraintsSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const ContainerConstraintsSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "ContainerConstraintsSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -903,15 +903,15 @@ namespace ASDCP
 	  NetworkLocator();
 
 	public:
-	  const Dictionary*& m_Dict;
           UTF16String URLString;
 
-      NetworkLocator(const Dictionary*& d);
+      NetworkLocator(const Dictionary* d);
       NetworkLocator(const NetworkLocator& rhs);
       virtual ~NetworkLocator() {}
 
       const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const NetworkLocator& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "NetworkLocator"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -926,7 +926,6 @@ namespace ASDCP
 	  MCALabelSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UL MCALabelDictionaryID;
           UUID MCALinkID;
           UTF16String MCATagSymbol;
@@ -942,12 +941,13 @@ namespace ASDCP
           optional_property<UTF16String > MCAAudioContentKind;
           optional_property<UTF16String > MCAAudioElementKind;
 
-      MCALabelSubDescriptor(const Dictionary*& d);
+      MCALabelSubDescriptor(const Dictionary* d);
       MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs);
       virtual ~MCALabelSubDescriptor() {}
 
       const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const MCALabelSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "MCALabelSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -962,15 +962,15 @@ namespace ASDCP
 	  AudioChannelLabelSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<UUID > SoundfieldGroupLinkID;
 
-      AudioChannelLabelSubDescriptor(const Dictionary*& d);
+      AudioChannelLabelSubDescriptor(const Dictionary* d);
       AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs);
       virtual ~AudioChannelLabelSubDescriptor() {}
 
       const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const AudioChannelLabelSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -985,15 +985,15 @@ namespace ASDCP
 	  SoundfieldGroupLabelSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<Array<UUID> > GroupOfSoundfieldGroupsLinkID;
 
-      SoundfieldGroupLabelSubDescriptor(const Dictionary*& d);
+      SoundfieldGroupLabelSubDescriptor(const Dictionary* d);
       SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs);
       virtual ~SoundfieldGroupLabelSubDescriptor() {}
 
       const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1008,14 +1008,14 @@ namespace ASDCP
 	  GroupOfSoundfieldGroupsLabelSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d);
+      GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary* d);
       GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
       virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {}
 
       const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1030,14 +1030,14 @@ namespace ASDCP
 	  DCDataDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      DCDataDescriptor(const Dictionary*& d);
+      DCDataDescriptor(const Dictionary* d);
       DCDataDescriptor(const DCDataDescriptor& rhs);
       virtual ~DCDataDescriptor() {}
 
       const DCDataDescriptor& operator=(const DCDataDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const DCDataDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "DCDataDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1052,14 +1052,14 @@ namespace ASDCP
 	  PrivateDCDataDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      PrivateDCDataDescriptor(const Dictionary*& d);
+      PrivateDCDataDescriptor(const Dictionary* d);
       PrivateDCDataDescriptor(const PrivateDCDataDescriptor& rhs);
       virtual ~PrivateDCDataDescriptor() {}
 
       const PrivateDCDataDescriptor& operator=(const PrivateDCDataDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const PrivateDCDataDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "PrivateDCDataDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1074,19 +1074,19 @@ namespace ASDCP
 	  DolbyAtmosSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID AtmosID;
           ui32_t FirstFrame;
           ui16_t MaxChannelCount;
           ui16_t MaxObjectCount;
           ui8_t AtmosVersion;
 
-      DolbyAtmosSubDescriptor(const Dictionary*& d);
+      DolbyAtmosSubDescriptor(const Dictionary* d);
       DolbyAtmosSubDescriptor(const DolbyAtmosSubDescriptor& rhs);
       virtual ~DolbyAtmosSubDescriptor() {}
 
       const DolbyAtmosSubDescriptor& operator=(const DolbyAtmosSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const DolbyAtmosSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "DolbyAtmosSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1101,19 +1101,19 @@ namespace ASDCP
 	  ACESPictureSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<UTF16String > ACESAuthoringInformation;
           optional_property<ThreeColorPrimaries > ACESMasteringDisplayPrimaries;
           optional_property<ColorPrimary > ACESMasteringDisplayWhitePointChromaticity;
           optional_property<ui32_t > ACESMasteringDisplayMaximumLuminance;
           optional_property<ui32_t > ACESMasteringDisplayMinimumLuminance;
 
-      ACESPictureSubDescriptor(const Dictionary*& d);
+      ACESPictureSubDescriptor(const Dictionary* d);
       ACESPictureSubDescriptor(const ACESPictureSubDescriptor& rhs);
       virtual ~ACESPictureSubDescriptor() {}
 
       const ACESPictureSubDescriptor& operator=(const ACESPictureSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const ACESPictureSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "ACESPictureSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1128,7 +1128,6 @@ namespace ASDCP
 	  TargetFrameSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UUID TargetFrameAncillaryResourceID;
           UTF16String MediaType;
           ui64_t TargetFrameIndex;
@@ -1140,12 +1139,13 @@ namespace ASDCP
           optional_property<UUID > ACESPictureSubDescriptorInstanceID;
           optional_property<UL > TargetFrameViewingEnvironment;
 
-      TargetFrameSubDescriptor(const Dictionary*& d);
+      TargetFrameSubDescriptor(const Dictionary* d);
       TargetFrameSubDescriptor(const TargetFrameSubDescriptor& rhs);
       virtual ~TargetFrameSubDescriptor() {}
 
       const TargetFrameSubDescriptor& operator=(const TargetFrameSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const TargetFrameSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "TargetFrameSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1160,15 +1160,15 @@ namespace ASDCP
 	  TextBasedDMFramework();
 
 	public:
-	  const Dictionary*& m_Dict;
           optional_property<UUID > ObjectRef;
 
-      TextBasedDMFramework(const Dictionary*& d);
+      TextBasedDMFramework(const Dictionary* d);
       TextBasedDMFramework(const TextBasedDMFramework& rhs);
       virtual ~TextBasedDMFramework() {}
 
       const TextBasedDMFramework& operator=(const TextBasedDMFramework& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const TextBasedDMFramework& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "TextBasedDMFramework"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1183,18 +1183,18 @@ namespace ASDCP
 	  TextBasedObject();
 
 	public:
-	  const Dictionary*& m_Dict;
           UL PayloadSchemeID;
           UTF16String TextMIMEMediaType;
           UTF16String RFC5646TextLanguageCode;
           optional_property<UTF16String > TextDataDescription;
 
-      TextBasedObject(const Dictionary*& d);
+      TextBasedObject(const Dictionary* d);
       TextBasedObject(const TextBasedObject& rhs);
       virtual ~TextBasedObject() {}
 
       const TextBasedObject& operator=(const TextBasedObject& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const TextBasedObject& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "TextBasedObject"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1209,15 +1209,15 @@ namespace ASDCP
 	  GenericStreamTextBasedSet();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui32_t GenericStreamSID;
 
-      GenericStreamTextBasedSet(const Dictionary*& d);
+      GenericStreamTextBasedSet(const Dictionary* d);
       GenericStreamTextBasedSet(const GenericStreamTextBasedSet& rhs);
       virtual ~GenericStreamTextBasedSet() {}
 
       const GenericStreamTextBasedSet& operator=(const GenericStreamTextBasedSet& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const GenericStreamTextBasedSet& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "GenericStreamTextBasedSet"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1232,15 +1232,15 @@ namespace ASDCP
 	  ISXDDataEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           ISO8String NamespaceURI;
 
-      ISXDDataEssenceDescriptor(const Dictionary*& d);
+      ISXDDataEssenceDescriptor(const Dictionary* d);
       ISXDDataEssenceDescriptor(const ISXDDataEssenceDescriptor& rhs);
       virtual ~ISXDDataEssenceDescriptor() {}
 
       const ISXDDataEssenceDescriptor& operator=(const ISXDDataEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const ISXDDataEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "ISXDDataEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1255,17 +1255,17 @@ namespace ASDCP
 	  PHDRMetadataTrackSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           UL DataDefinition;
           ui32_t SourceTrackID;
           ui32_t SimplePayloadSID;
 
-      PHDRMetadataTrackSubDescriptor(const Dictionary*& d);
+      PHDRMetadataTrackSubDescriptor(const Dictionary* d);
       PHDRMetadataTrackSubDescriptor(const PHDRMetadataTrackSubDescriptor& rhs);
       virtual ~PHDRMetadataTrackSubDescriptor() {}
 
       const PHDRMetadataTrackSubDescriptor& operator=(const PHDRMetadataTrackSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const PHDRMetadataTrackSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "PHDRMetadataTrackSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1280,15 +1280,15 @@ namespace ASDCP
 	  PIMFDynamicMetadataDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
           ui32_t GlobalPayloadSID;
 
-      PIMFDynamicMetadataDescriptor(const Dictionary*& d);
+      PIMFDynamicMetadataDescriptor(const Dictionary* d);
       PIMFDynamicMetadataDescriptor(const PIMFDynamicMetadataDescriptor& rhs);
       virtual ~PIMFDynamicMetadataDescriptor() {}
 
       const PIMFDynamicMetadataDescriptor& operator=(const PIMFDynamicMetadataDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const PIMFDynamicMetadataDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "PIMFDynamicMetadataDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1303,14 +1303,14 @@ namespace ASDCP
 	  IABEssenceDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      IABEssenceDescriptor(const Dictionary*& d);
+      IABEssenceDescriptor(const Dictionary* d);
       IABEssenceDescriptor(const IABEssenceDescriptor& rhs);
       virtual ~IABEssenceDescriptor() {}
 
       const IABEssenceDescriptor& operator=(const IABEssenceDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const IABEssenceDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "IABEssenceDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
@@ -1325,14 +1325,14 @@ namespace ASDCP
 	  IABSoundfieldLabelSubDescriptor();
 
 	public:
-	  const Dictionary*& m_Dict;
 
-      IABSoundfieldLabelSubDescriptor(const Dictionary*& d);
+      IABSoundfieldLabelSubDescriptor(const Dictionary* d);
       IABSoundfieldLabelSubDescriptor(const IABSoundfieldLabelSubDescriptor& rhs);
       virtual ~IABSoundfieldLabelSubDescriptor() {}
 
       const IABSoundfieldLabelSubDescriptor& operator=(const IABSoundfieldLabelSubDescriptor& rhs) { Copy(rhs); return *this; }
       virtual void Copy(const IABSoundfieldLabelSubDescriptor& rhs);
+      virtual InterchangeObject *Clone() const;
       virtual const char* HasName() { return "IABSoundfieldLabelSubDescriptor"; }
       virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
       virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);