	The AAF Analyzer is currently composed of eight libraries.  Three of the
libraries (AnalyzerBase, RequirementLib and TestPhaseLib) are completely
independent from AAF.  These libraries can be reused as the foundations of
another analyzer type program.

	The library AAFAnalyzerBase builds upon the AnalyzerBase library and is used
by the BaseTestImpl library which also uses the RequirementLib and TestPhaseLib
libraries.  The AAFAnalyzerBase library extends the AnalyzerBase library for use
with AAF.  The BaseTestImpl library implements tests that test the structure of
an AAF file versus the AAF Object Specification.

	The library EPAnalyzerBase build upon the AAFAnalyzerBase and is used by
the EditProtocolTestImpl library which also uses the RequirementLib and
TestPhaseLib libraries.  The EPAnalyzerBase library extends the AAFAnalyzerBase
library for use with Edit Protocol data types.  The EditProtocolTestImpl
library implements test that the the structure of AAF files versus the Edit
Protocol specification.

--------------------------------------------------------------------------------

AnalyzerBase:

	The AnalyzerBase library provides the tools needed to build and traverse a
graph out of the contents of a file.

TestGraph - Container for the graph that is built by reading a file.  A
			TestGraph can be explored and nodes in the graph can be
			individually tested.  The decorator pattern may be used to add
			functionality to nodes of the graph.  A node should never be
			directly decorated because this will cause there to be references to
			the decorated and the undecorated node.  In order to decorate a
			node, the Decorate function of the TestGraph should be called.
			
Node - Represents a node on the test graph.  Nodes can be visited to analyze
	   their contents.  The decorator pattern may be used to add functionality
	   to a specific node.  If special processing is needed when the node is
	   decorated, that functionality should be implemented by overriding the
	   Decorate method.
	   
Edge - An Edge represents a path from one node to another.  Edges are directed
	   and have a parent and a child node.
	   
EdgeMap - A TestGraph has an EdgeMap.  The EdgeMap stores all edges that
		  connect nodes within the TestGraph.

Visitor - A visitor is capable of visiting a node an analyzing the node to
		  determine if the node meets a set of criteria.
		  
DepthFirstTraversal - Provides methods to visit nodes in a test graph by
					  traversing up or down the graph from a specified starting
					  node.
					  
AnalyzerException - Exceptions thrown by any analyzer program should extend
					from an AnalyzerException.

--------------------------------------------------------------------------------

RequirementLib:

	The RequirementLib library provides tools required to parse requirements
out of an XML file and use them in the analysis process.  After being read,
analysis may be done to determine if a TestGraph meets the requirements.

RequirementLoader - Reads an XML file and creates and stores Requirement
					objects in the RequirementRegistry.
					
RequirementXMLException - Thrown when the RequirementLoader encounters a problem
						  while attempting to parse the XML requirement file.
						  
Requirement - Container for a requirement id, requirement type, requirement
			  category, requirement name, requirement description and a
			  document reference for the requirement.
			  
RequirementRegistry - Single spot of storage for all requirements that have
					  been loaded by an analyzer program.  Any part of an
					  analyzer program may access the RequirementRegistry and
					  obtain Requirement Objects based upon their ids.
					  
RequirementRegistryException - Thrown by RequirementRegistry when attempting to
							   register a requirement that has already been
							   registered or when attempting to access an
							   unregistered requirement.
							   
--------------------------------------------------------------------------------

TestPhaseLib:

	The TestPhaseLib library provides the foundation for implementing tests and
phases of tests.  It also provides a mechanism for reporting the results of
tests as well as the results of subtests and collections of tests.

Test - Base class for any test to be implemented.  Before being run, a test
	   must be registered with the TestRegistry.  In order to register with the
	   TestRegistry, a test must implement a static method GetTestInfo() that
       returns a TestInfo object.

TestPhase - Base class for any test phase to be implemented.

TestRegistry - Stores the requirements associated with every test that has been
			   registered.  Any part of an analyzer program may access the
			   TestRegistry and obtain its requirements based upon the Tests
			   name.
			   
TestRegistryException - Thrown by TestRegistry when attempting to register a
						test that is already registered or when attempting to
						find the requirements for an unregistered test.
						
TestInfo - Container for the name of a test and the requirements associated
		   with that test.
		   
TestInfoRegistrar - Used to register tests with the TestRegistry.  Registration
					is accomplished by specifying a test as the template
					parameter of the TestInfoRegistrar constructor.  If the test
					does not implement a static method GetTestInfo() returning a
					TestInfo object, the analyzer will not compile.
					
TestResult - Base interface for storing the results of the run analyzer, a test
			 phase, a test or a sub-test.  Indicates the overall result as well
			 as the a pass/fail/warn indication for each requirement that was
			 tested. Contains a collection of sub-TestResults.  GetResultType()
			 is a pure virtual method with the sole purpose of preventing a
			 TestResult class from being instantiated.
			 
HighLevelTestResult - Interface for storing the results of an analyzer run or a
					  test phase.  GetResultType() is a pure virtual method with
					  the sole purpose of preventing a HighLevelTestResult class
					  from being instantiated.
					  
LowLevelTestResult - Interface for storing the results of a test or a sub-test.
					 GetResultType() is a pure virtual method with the sole
					 purpose of preventing a LowLevelTestResult from being
					 instantiated.
					 
TopLevelTestResult - Used to report the overall results of an analyzer program.
					 May only contain TestPhaseLevelTestResults as
					 sub-TestResults.  Requirement pass/fail/warn statuses are
					 automatically updated when sub-TestResults are appended.
					 
TestPhaseLevelTestResult - Used to report the results of a TestPhase.  May only
						   contain TestLevelTestResults as sub-TestResults. 
						   Requirement pass/fail/warn statuses are
						   automatically updated when sub-TestResults are
						   appended.
						   
TestLevelTestResult - Used to report the results of a Test.  The requirements
					  that are specified as being part of the test result must
					  be identical to the requirements specified as being part
					  of the associated test. May only contain
					  DetailLevelTestResults as sub-TestResults. Requirement
					  pass/fail/warn statuses are not updated when a
					  sub-TestResults are appended.
					  
DetailLevelTestResults - Used to report the results of sub-tests (visitors). 
						 May only contain other DetailLevelTestResults as
						 sub-TestResults. Requirement pass/fail/warn statuses
						 are not updated when a sub-TestResult is appended.
						 
RequirementMismatchException - Thrown by TestLevelTestResult when the
							   requirements for a TestLevelTestResult do not
							   match the requirements of the associated test,
							   or when attempting to append a
							   DetailLevelTestResult which has a requirement
							   that is not part of the TestLevelTestResult.

--------------------------------------------------------------------------------

AAFAnalyzerBase:

	The AAFAnalyzerBase library extends the AnalyzerBase library adding
functionality specific to AAF.

AAFContainment - An edge that represents two nodes that are adjacent in a
				 recursive iterator.

AAFMobReference - An edge between a source clip node and a mob node.

AAFSlotReference - An edge between a source clip node and a mob slot node.

AAFComponentReference - An edge between two source clip nodes.

AAFObjNode - A graph node that is associated with an AAF.  Although the AAF
			 object has a specific type, this node only provides access to the
			 IAAFObject interface.
			  
AAFTypedObjNode - Interface for graph nodes that are associated with a specific
				  type of AAF object.
				  
AAFTypedObjNodeImpl - Concreate implementation of an AAFTypedObjNode.  This
					  node provides access to the interface of the specific
					  type of AAF object.
					  
AAFTypedObjNodeDecorator - Interface for using the decorator pattern to create
						   a decorated AAFTypedObjNodeImpl.  Forwards requests
						   for GetAAFObjectOfType() and Decorate() to the
						   actual node. However, calls to PreOrderVisit() and
						   PostOrderVisit() are not forwarded in order to ensure
						   that visitors correctly receive a decorate object
						   and not the AAFTypedObjectNode in their
						   PreOrderVisit() and PostOrderVisit() methods.
						   
GraphBuilder - Creates a TestGraph and AAFGraphInfo by reading an AAF input
			   file.
			   
AAFGraphInfo - Container for a TestGraph and an AxFile.  When the AAFGraphInfo
			   object is destroyed, the associated AxFile will be closed and
			   AAFObjNodes and any derived nodes will not be able to access the
			   AAF interface of the objects associated with those nodes.
			   
MobNodeMap - A map storing all nodes in the TestGraph that contain Mob objects.
			 Any part of an AAFAnalyer program may access the MobNodeMap in
			 order to access, decorate or remove nodes.
			 
NodeFactory - Interface for a factory to create AAFObjNode objects based upon an
			  AAF object.

NodeFactoryImpl - Concrete implementation of NodeFactory that forwards
				  CreateNode() requests on to a TypedNodeFactory().
				  
TypedNodeFactory - Interface for a factory to create AAFTypedObjNode objects
				   based upon an AAF object.
				   
TypedNodeFactoryImpl - Concrete implementation of TypedNodeFactory that create
					   an AAFTypedObjNode with the template parameter of the
					   factory.
					   
TypedNodeFactoryRegistry - Registry that stores every instantiation of a
						   TypedNodeFactoryImpl.  NodeFactoryImpl uses the
						   TypedNodeFactoryRegistry to forward CreateNode()
						   requests to the appropriate TypedNodeFactory.  Any
						   part of an AAFAnalyzer may access the
						   TypedNodeFactoryRegister to register or deregister
						   factories or to obtain a TypedNodeFactory.
						   
TypedVisitor - Derived from the visitor class, implements PreOrderVisit and
			   PostOrderVisit methods that take AAFTypedObjNodes as
			   parameters. The methods are implemented for each AAF object. 
			   Also, EdgeVisit methods are implemented for each class in the
			   AAFAnalyzer library derived from Edge.
			   
--------------------------------------------------------------------------------

EPAnalyzerBase:

	The EPAnalyzerBase library extends the AAFAnalyzerBase library adding
functionality specific to the AAF Edit Protocol.

EPObject - Base class for any Edit Protocol object.

EPDerivationChainObject - Base type for any object in the Edit Protocol
						  Derivation Chain.
						  
EPTopLevelComposition - A Top Level Composition.

EPLowerLevelComposition - A Lower Level Composition.

EPAdjustedClipComposition - An Adjusted Clip Composition.

EPSubClipComposition - A Sub-clip Composition.

EPTemplateClip - A Template Clip.

EPClip - A Clip.

EPFileSource - A File Source.

EPRecordingSource - A Recording Source.

EPImportSource - An Import Source.

EPFilmSource - A Film Source.

EPTapeSource - A Tape Source.

EPTrackObject - Base type for any Edit Protocol Track object.

EPTimecodeTrack - A Timecode Track.

EPEdgecodeTrack - An Edgecode Track.

EPEssenceTrack - An Essence Track.

EPExtendedEssenceTrack - An Essence Track plus information about the child
						 source clip and the mob which it references.

EPAudioTrack - An Audio Track.

EPVideoTrack - A Video Track.

EPEffect - Base type for any Edit Protocol Effect object.

EPVideoDissolveEffect - A Video Dissolve Effect.

EPSMPTEVideoWipeEffect - An SMPTE Video Wipe Effect.

EPVideoSpeedControlEffect - A Video Speed Control Effect.

EPVideoRepeatEffect - A Video Repeat Effect.

EPVideoFlipEffect - A Video Flip Effect.

EPVideoFlopEffect - A Video Flop Effect.

EPFlipFlopEffect - A Video Flip-Flop Effect.

EPVideoPositionEffect - A Video Position Effect.

EPVideoCropEffect - A Video Crop Effect.

EPVideoScaleEffect - A Video Scale Effect.

EPVideoRotateEffect - A Video Rotate Effect.

EPVideoCornerPinningEffect - A Video Corner Pinning Effect.

EPAlphaWithVideoKeyEffect - An Alpha with Video Key Effect.

EPSeparateAlphaKeyEffect - A Separate-Alpha Key Effect.

EPLuminanceKeyEffect - A Luminance Key Effect.

EPChromaKeyEffect - A Chroma Key Effect.

EPAudioGainEffect - An Audio Gain Effect.

EPAudioPanEffect - An Audio Pan Effect.

EPSingleParameterAudioDissolveEffect - An Audio Dissolve Effect.

EPTwoParameterAudioDissolveEffect - A Two-Parameter Audio Dissolve Effect.

EPTypedObjNode - Derived from AAFTypedObjNodeDecorator, used to decorate
				 AAFTypedObjNodes with an Edit Protocol Derivation Chain type. 
				 Valuse for the template parameters must come from the following
				 list:
				 	AAFObjType			EPObjType
					------------------	-------------------------
				 	IAAFCompositionMob	EPTopLevelComposition
					IAAFCompositionMob	EPLowerLevelComposition
					IAAFCompositionMob	EPAdjustedClipComposition
					IAAFCompositionMob	EPSubClipComposition
					IAAFMasterMob		EPTemplateClip
					IAAFMasterMob		EPClip
					IAAFSourceMob		EPFileSource
					IAAFSourceMob		EPRecordingSource
					IAAFSourceMob		EPImportSource
					IAAFSourceMob		EPFilmSource
					IAAFSourceMob		EPTapeSource
					IAAFTimelineMobSlot	EPEssenceTrack
					IAAFTimelineMobSlot	EPAudioTrack
					IAAFTimelineMobSlot	EPVideoTrack
					IAAFTimelineMobSlot	EPTimecodeTrack
					IAAFTimelineMobSlot	EPEdgecodeTrack
					IAAFStaticMobSlot	EPEssenceTrack
					IAAFStaticMobSlot	EPAudioTrack
					IAAFStaticMobSlot	EPVideoTrack
					IAAFStaticMobSlot	EPTimecodeTrack
					IAAFStaticMobSlot	EPEdgecodeTrack
					IAAFEventMobSlot	EPEssenceTrack
					IAAFEventMobSlot	EPAudioTrack
					IAAFEventMobSlot	EPVideoTrack
					IAAFEventMobSlot	EPTimecodeTrack
					IAAFEventMobSlot	EPEdgecodeTrack
					IAAFMobSlot			EPEssenceTrack
					IAAFMobSlot			EPAudioTrack
					IAAFMobSlot			EPVideoTrack
					IAAFMobSlot			EPTimecodeTrack
					IAAFMobSlot			EPEdgecodeTrack
					IAAFOperationGroup	EPVideoDissolveEffect
					IAAFOperationGroup	EPSMPTEVideoWipeEffect
					IAAFOperationGroup	EPVideoSpeedControlEffect
					IAAFOperationGroup	EPVideoRepeatEffect
					IAAFOperationGroup	EPVideoFlipEffect
					IAAFOperationGroup	EPVideoFlopEffect
					IAAFOperationGroup	EPFlipFlopEffect
					IAAFOperationGroup	EPVideoPositionEffect
					IAAFOperationGroup	EPVideoCropEffect
					IAAFOperationGroup	EPVideoScaleEffect
					IAAFOperationGroup	EPVideoRotateEffect
					IAAFOperationGroup	EPVideoCornerPinningEffect
					IAAFOperationGroup	EPAlphaWithVideoKeyEffect
					IAAFOperationGroup	EPSeparateAlphaKeyEffect
					IAAFOperationGroup	EPLuminanceKeyEffect
					IAAFOperationGroup	EPChromaKeyEffect
					IAAFOperationGroup	EPAudioGainEffect
					IAAFOperationGroup	EPAudioPanEffect
					IAAFOperationGroup	EPSingleParameterAudioDissolveEffect
					IAAFOperationGroup	EPTwoParameterAudioDissolveEffect
					IAAFOperationGroup	EPEffect
					
EPCastException - Thrown by EPTypedObjNode when attempting an illegal cast on
				  the EPObjType parameter of an EPTypedObjNode.
					
EPTypedVisitor - Derived from TypedVisitor.  Implements PreOrderVisit() and
				 PostOrderVisit() for EPTypedObjNodes with the parameters in the
				 above list. The default behaviour of these functions is to call
				 the same function using an appropriate AAFTypedObjNode.  In
				 order to accomplish this, the PreOrderVisit and PostOrderVisit
				 methods in TypedVisitor are exposed using the using
			     declaration.
			     
ParentMobSlotVisitor - Derived from EPTypedVisitor and used by EPTypedVisitor.
					   Visits AAFContainment edges to find the first mob above
					   a given node.  (Declared and defined in an anonymous 
					   namespace).
					   
ChildMobSlotVisitor - Derived from EPTypedVisitor and used by EPTypedVisitor.
					  Visits AAFContainment edges to find  tracks that are
					  contained beneath a given node.  (Declared and defined in
					  an anonymous namespace).
				 
--------------------------------------------------------------------------------

BaseTestImpl:

	The BaseTestImpl library implements the test used to test the basic
structure of an AAF file versus the requirements set out in the AAF Object
Specification.

LoadPhase - Derived from TestPhase, creates a TestGraph from an AAF file and
		    runs basic structural tests.
		   
FileLoad - Derived from Test and executed by LoadPhase.  This test converts an
		   AAF file into a TestGraph.
		  
AcyclicAnalysis - Derived from Test and executed by LoadPhase.  This test
				  traverses a TestGraph to ensure that there are no cycles in
				  the graph.
				  
AcyclicVisitor - Derived from Visitor and used by AcyclicAnalysis.  This
				 visitor checks for cycles in a TestGraph.
				 
RefResolver - Derived from Test and executed by LoadPhase.  This test traverses
			  a TestGraph searching for out of file references.
			  
ResolveRefVisitor - Derived from TypedVisitor and used by RefResolver.  This
					visitor visits AAFTypedObjNode<IAAFSourceClip> objects and
					checks for out of file references.
					
ResolveComponentRefVisitor - Derived from TypedVisitor and used by
							 ResolveRefVisitor.  This visitor visits source clip
							 objects to create AAFComponentReference edges.
							 (Declared and defined in an anonymous namespace).
							 
ResolveSlotRefVisitor - Derived from TypedVisitor and used by
						ResolveSlotRefVisitor.  This visitor visits mob slot
						objects to create AAFSlotReference edges.
						(Declared and defined in an anonymous namespace).
					
DumpPhase - Derived from TestPhase, outputs a TestGraph to the console.

FileDumper - Derived from Test and executed by DumpPhase to output a TestGraph
			 to the console.
			 
TestVisitor - Derived from Visitor and used by FileDumper to output a TestGraph
			  to the console.
			  
--------------------------------------------------------------------------------

EditProtocolTestImpl:

	The EditProtocolTestImpl library implements the tests used to verify that
an AAF File conforms to the AAF Edit Protocol.

EPMobDepPhase - Derived from TestPhase, runs all tests related to the Edit
			    Protocol.
				
DecorateEPTest - Derived from Test and executed by EPMobDepPhase.  Decorates
				 all appropriate AAFTypedObjNodes with EPTypedObjNodes.
				 
EPDecoratorVisitor - Derived from TypedVisitor, used by DecorateEPTest to
					 decorate AAFTypedObjNodes with template parameters
					 IAAFCompositionMob, IAAFMasterMob and IAAFSourceMob.
					 (Declared and defined in an anonymous namespace).
					 
CompMobDependency - Derived from Test and executed by EPMobDepPhase.  Counts
					the number of references to each mob in a TestGraph.
					
NodRefCountVisitor - Derived from TypedVisitor and used by CompMobDependency to
					 count the number of references to each mob.
					 
EPDerivationTest - Derived from Test and executed by EPMobDepPhase.  Tests a
				   TestGraph to ensure it forms a valid derivation chain.
				   
MobChainVisitor - Derived from EPTypedVisitor, used by EPDerivationTest to
				  verify that a TestGraph forms a valid derivation chain.
				  (Declared and defined in an anonymous namespace).
				  
Analyzer - Used by MobChainVisitor to implement a for_each loop.  (Declared and
		   defined in an anonymous namespace).

DerivationChainStateMachine - Used by MobChainVisitor to track the current
							  position in a derivation chain and to detect any
							  errors in the chain.
							  
StateMachineException - Thrown by DerivationChainStateMachine when an unknown
						event is passed to the state machine.
						
EPNameTest - Derived from Test and executed by EPMobDepPhase.  Tests a TestGraph
			 to ensure that objects have valid Edit Protocol names.
			 
EPNameVisitor - Derived from EPTypedVisitor.  Used by EPNameTest to verify that
				object names are acceptable under the Edit Protocol.
				
EPContainedTrackTest - Derived from Test and executed by EPMobDepPhase.  Tests
					   the mobs on a test graph to ensure that the tracks
					   contained within them are acceptable under the Edit
					   Protocol.
					   
EPContainedTrackVisitor - Derived from EPTypedVisitor.  Used by
						  EPContainedTrackTest to verify that tracks contained
						  within mobs are valid under the Edit Protocol.
						  
AuxiliarySlotVisitor - Derived from EPTyped visitor.  Used by
					   EPContainedTrackVisitor to verify that Auxiliary Source
					   Mobs have valid mob slots.  (Declared and defined in an
					   anonymous namespace).
						  
EPTrackContentsTest - Derived from test and executed by EPMobDepPhase.  Test
					  tracks within mobs of a TestGraph to make sure they
					  contain valid content.
					  
EPTrackContentsVisitor - Derived from EPTypedVisitor, used by
						 EPTrackContentsTest to veryify that tracks contained
						 within mobs of a TestGraph have valid contents.
						 
EPEditRateTest - Derived from test and execured by EPMobDepPhase.  Tests
				 essence tracks within mobs of a TestGraph to make sure they
				 have valid edit rates.
				 
EPEditRateVisitor - Derived from EPTypedVisitor, used by EPEditRate test to
					verify that essence tracks contained within mobs of a
					TestGraph have valid edit rates.
					
AllowedEditRateTable - Store all valid essence track edit rates and determine if
					   any given rate is located in the table.
					   
EPEffectTest - Derived from Test and executed by EPMobDepPhase.  Tests
			   OperationGroups to ensure they meet the requirements set out for
			   effects in the Edit Protocol.

EPEffectVisitor - Derived from EPTypedVisitor, used by EPEffectTest to verify
				  that all OperationGroups are valid.
				  
TransitionInputVisitor - Derived from TypedVisitor and used by EFEffectVisitor.
						 Visits the parents of an effect to find the transition
						 in which it is contained and the input segments to the
						 transition.

EPLocatorTest - Derived from Test and executed by EPMobDepPhase.  Test that
				locators in Import and File Sources are valid (currently not
				being executed).
			
EPLocatorVisitor - Derived from EPTypedVisitor, used by EPVisitorTest to verify
				   that locators are valid.  Currently uses the library libURI
				   (http://sourceforge.net/projects/liburi/),however, this 
				   library is not sufficient and will need to be changed.  To
				   run the library with this test the LD_LIBRARY_PATH variable
				   will need to be set to include the path of the library
				   (install directory is /usr/local/lib).  Also, to install the
				   library, the code must be modified - one function specifies
				   a default parameter value in the function definition and
				   declaration - remove the default value in the definition.

EPAnnotationTest - Derived from Test and executed by EPMobDepPhase.  Test that
				   all annotations in the AAF file are legal.

EPAnnotationVisitor - Derived from EPTypedVisitor, used by EPAnnotationTest to
					  verify that all annotations are legal.

EPDefinitionTest - Derived from Test and executed by EPMobDepPhase.  Test that
				   all DefinitionObjects are properly used.
				   
EPDefinitionVisitor - Derived from EPTypedVisitor, used by EPDefinitionTest to
					  verify that all DefinitionObjects are used legally.
					  
EPHeaderTest - Derived from Test and executed by EPMobDepPhase.  Test that the
			   header of an AAF file complies to the Edit Protocol.
			   
EPHeaderVisitor - Derived from TypedVisitor, used by EPDefinitionTest to verify
				  the header of the AAF file is valid.

EPParameterTest - Derived from Test and executed by EPMobDepPhase.  Test that
				  all parameters with an AAF file meet the Edit Protocol
				  requirements.

EPParameterVisitor - Derived from EPTypedVisitor, used by EPParameterTest to
					 verify that all parameters in an AAF file are legal.

EPMultiChannelAudioTest - Derived from Test and executed by EPMobDepPhase.  Test
						  that multi-channel audio is used properly within an
						  AAF file.

EPMultiChannelAudioVisitor - Derived from EPTypedVisitor, used by
							 EPMultiChannelAudioTest to verify the proper use
							 of multi-channel audio.