Syntax

   FACTORY_DEF <ReaderKeyword> DeaggregateFactory
   [FACTORY_NAME <factory name>] 
   [INPUT FEATURE_TYPE <feature type>
      [<attribute name> <attribute value>]*
      [<feature function>]*]*
   [SPLIT_COMPOSITES [(YES|NO)]]
   [INSTANTIATE_GEOMETRY_INSTANCES [(YES|NO)]]   
   [INSTANTIATE_GEOMETRY_INSTANCES_NEW [(YES|NO)]]   
   [LIST_NAME <list name>{}]
   [PART_NUMBER_FIELD <attribute name>]
   [RECURSIVE [(YES|NO|HIERARCHY)]]
   [SET_FME_TYPE [(YES|NO)]]
   [PATH_SPLIT_MODE [(YES|NO)]]
   [HOMOGENIZE_COLLECTIONS [(YES|NO)]]
   [GEOMETRY_NAME_FIELD <attribute name>]
   [ID_ATTR <ID attr name>]
   [PARENT_ID_ATTR <parent ID attr name>]
   [CHILD_ID_ATTR <child ID list attr name>]
   [COPY_ATTR (EVERY_NODE|ROOT_NODE)]
   [OUTPUT (DONUT|LINE|PIP|POINT|POLYGON|AGGREGATE|SEGMENT|NON_PATH|REJECTED)
      FEATURE_TYPE <feature type>
      [<attribute name> <attribute value>]*
      [<feature function>]*]*

Overview

   This factory takes a feature with aggregate geometry and breaks it into 
   several features, one for each geometry fragment it contained. Each piece 
   gets a complete copy of the original aggregate feature's attributes. 
   
   The optional LIST_NAME clause is used to associate attributes with each 
   member of the aggregate. When the aggregate is broken up, any elements of the 
   attribute list corresponding to the geometry will be added to the feature 
   that is output in the same manner as with the ElementFactory.
   
   If the optional PART_NUMBER_FIELD clause is specified, then each deaggregated 
   output feature is given an attribute containing the part's (deaggregated 
   feature) index within the original aggregate feature. This clause will not 
   apply if RECURSIVE clause is also used.
   
   The optional RECURSIVE keyword is used to deaggregate nested aggregates 
   recursively. If the keyword is not used, the default action is no 
   recursion and any nested aggregates will not be broken apart. If YES, the
   aggregate will be flattened. If HIERARCHY, the aggregate will be disassembled
   so that every node in the aggregate tree will be output.
   
   If SET_FME_TYPE is given, all features output will have an appropriate 
   fme_type attribute set (which will be the same as the input feature's type, 
   if it exists).
   
   PATH_SPLIT_MODE designates that the factory is to split paths that are input 
   and output their component segments, instead of splitting aggregate 
   geometries.

   HOMOGENIZE_COLLECTIONS designates that the factory is to split aggregates
   into homogeneous multis. This mode is implicitly recursive, i.e. any nested
   aggregates will be split as well
   
   For geometries that are named, supplying the optional GEOMETRY_NAME_FIELD 
   clause will set the specified attribute to the name of the (deaggregated) 
   geometry. This clause can only be specified when PATH_SPLIT_MODE is set to 
   no.
   
   If an aggregate had a member for a geometry type not represented in any 
   OUTPUT clause, that portion of the geometry will be discarded.
   
      Tip: The DeaggregateFactory is similar to the ElementFactory. The 
      ElementFactory breaks attribute lists into features, whereas the 
      DeaggregateFactory breaks aggregated geometry into features.

   INSTANTIATE_GEOMETRY_INSTANCES = YES causes the input feature to be 
   instantiated AND deaggregated ONLY WHEN the input feature contains
   instances or is an instance. INSTANTIATE_GEOMETRY_INSTANCES = NO is the
   default and is treated the same as when this keyword is absent.

   INSTANTIATE_GEOMETRY_INSTANCES_NEW = YES causes the input feature to be
   instantiated when it contains instances or is an instance. When this
   keyword is present, the input feature is always deaggregated. 

   Only one of INSTANTIATE_GEOMETRY_INSTANCES_NEW and INSTANTIATE_GEOMETRY_INSTANCES
   may be supplied to the factory. If both of them are supplied, an
   error will result.

Assumptions

   Features entering the DeaggregateFactory should have aggregate geometry. 
   Aggregate geometry may be found on features coming from several formats, or 
   on features created by the AggregateFactory. If a feature that is not an 
   aggregate enters the factory, then that feature is output via the appropriate 
   OUTPUT clause, according to the geometry it carries.

Output Tags

   The DeaggregateFactory supports the following output tags.
   
   DONUT 
   
      Donut geometries in the original feature have this specification applied 
      to them as they are output.

   LINE  
   
      Linear geometries in the original feature have this specification applied 
      to them as they are output.

   PIP   
   
      Point-in-polygon geometries in the original feature have this 
      specification applied to them as they are output.

   POINT 
   
      Point geometries in the original feature have this specification applied 
      to them as they are output.

   POLYGON  
   
      Polygon geometries in the original feature have this specification applied 
      to them as they are output.

   AGGREGATE   
   
      Aggregate geometries in the original feature have this specification 
      applied to them as they are output.

   SEGMENT  
   
      In PATH_SPLIT mode, each input path has its component segments output in 
      order with this tag.

   NON_PATH 
   
      In PATH_SPLIT mode, any input features whose geometry is not a path is 
      output with this tag.

TO BE RESOLVED

   SPLIT_COMPOSITES clause and REJECTED 
   output tag added to Syntax section above, but not documented.