ExchangeToolkit.h

#pragma once

#include <vector>
#include <set>
#include <unordered_map>
#include <functional>
#include <memory>
#include <algorithm>
#include <iterator>

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4503)
#endif

namespace ts3d {
    class CheckResult {
    public:
        static CheckResult &instance( void ) {
            static CheckResult _instance;
            return _instance;
        }

        void setFailureCallback( std::function<bool(CheckResult const&)> failure_cb ) {
            _failureCallback = failure_cb;
        }
        
        std::string const &file( void ) const {
            return _file;
        }
        
        int const &line( void ) const {
            return _line;
        }
        
        std::string const &fn( void ) const {
            return _fn;
        }
        
        A3DStatus const &result( void ) const {
            return _result;
        }
        
        
        bool _record( std::string const file, int const line_no, std::string const fn, A3DStatus const result ) {
            _file = file;
            _line = line_no;
            _fn = fn;
            _result = result;
            if( _result != A3D_SUCCESS && _failureCallback ) {
                return _failureCallback(*this);
            }
            return A3D_SUCCESS == _result;
        }
        
    private:
        CheckResult( void ) {}
        CheckResult( CheckResult const &other ) = delete;
        
        std::string _file;
        int _line = 0;
        std::string _fn;
        A3DStatus _result = A3D_SUCCESS;
        std::function<bool(CheckResult const&)> _failureCallback = [](ts3d::CheckResult const &r ) {
            std::string const error_string = A3DMiscGetErrorMsg( r.result() );
            std::cerr << "API FAILURE: " << r.fn() << " [" << r.file() << ":" << r.line() << "] == " << error_string << "(" << r.result() << ")" << std::endl;
            return false;
        };

    };
}

#define CheckResult( f ) \
    ts3d::CheckResult::instance()._record( __FILE__, __LINE__, #f, f )

#define A3D_HELPERS( A3D_VOID_TYPE ) \
namespace ts3d {\
 \
 \
 \
struct A3D_VOID_TYPE ## Wrapper { \
    \
 \
    using DataType = A3D_VOID_TYPE ## Data; \
    \
\
 \
    A3D_VOID_TYPE ## Wrapper( A3D_VOID_TYPE *ntt = nullptr ) { \
        A3D_INITIALIZE_DATA( A3D_VOID_TYPE ## Data, _d ); \
        if( ntt ) A3D_VOID_TYPE ## Get( ntt, &_d ); \
    } \
    \
 \
    ~A3D_VOID_TYPE ## Wrapper( void ) { \
        A3D_VOID_TYPE ## Get( nullptr, &_d ); \
    } \
    \
 \
    DataType const *operator->() const { \
        return &_d; \
    } \
    \
 \
 \
 \
    DataType *operator->() { \
        return &_d; \
    } \
    \
 \
 \
    void reset( A3D_VOID_TYPE *ntt ) { \
        A3D_VOID_TYPE ## Get( nullptr, &_d ); \
        if( ntt ) A3D_VOID_TYPE ## Get( ntt, &_d ); \
    }\
    \
 \
    DataType _d; \
    }; \
}

A3D_HELPERS(A3DAsmFilter)
A3D_HELPERS(A3DAsmModelFile)
A3D_HELPERS(A3DAsmPartDefinition)
A3D_HELPERS(A3DAsmProductOccurrence)
A3D_HELPERS(A3DCrvBlend02Boundary)
A3D_HELPERS(A3DCrvCircle)
A3D_HELPERS(A3DCrvComposite)
A3D_HELPERS(A3DCrvEllipse)
A3D_HELPERS(A3DCrvEquation)
A3D_HELPERS(A3DCrvHelix)
A3D_HELPERS(A3DCrvHyperbola)
A3D_HELPERS(A3DCrvIntersection)
A3D_HELPERS(A3DCrvLine)
A3D_HELPERS(A3DCrvNurbs)
A3D_HELPERS(A3DCrvOffset)
A3D_HELPERS(A3DCrvOnSurf)
A3D_HELPERS(A3DCrvParabola)
A3D_HELPERS(A3DCrvPolyLine)
A3D_HELPERS(A3DCrvTransform)
A3D_HELPERS(A3DDrawingBlockBasic)
A3D_HELPERS(A3DDrawingBlockOperator)
A3D_HELPERS(A3DDrawingClipFrame)
A3D_HELPERS(A3DDrawingCurve)
A3D_HELPERS(A3DDrawingFilledArea)
A3D_HELPERS(A3DDrawingModel)
A3D_HELPERS(A3DDrawingPicture)
A3D_HELPERS(A3DDrawingSheet)
A3D_HELPERS(A3DDrawingSheetFormat)
A3D_HELPERS(A3DDrawingVertices)
A3D_HELPERS(A3DDrawingView)
A3D_HELPERS(A3DFRMFeature)
A3D_HELPERS(A3DFRMFeatureLinkedItem)
A3D_HELPERS(A3DFRMFeatureTree)
A3D_HELPERS(A3DFRMParameter)
A3D_HELPERS(A3DGlobal)
A3D_HELPERS(A3DGraphAmbientLight)
A3D_HELPERS(A3DGraphCamera)
A3D_HELPERS(A3DGraphDirectionalLight)
A3D_HELPERS(A3DGraphPointLight)
A3D_HELPERS(A3DGraphSceneDisplayParameters)
A3D_HELPERS(A3DGraphSpotLight)
A3D_HELPERS(A3DGraphTextureTransformation)
A3D_HELPERS(A3DGraphics)
A3D_HELPERS(A3DHLRRepresentationItem)
A3D_HELPERS(A3DMDDimensionCombinedToleranceFormat)
A3D_HELPERS(A3DMDDimensionExtentionLine)
A3D_HELPERS(A3DMDDimensionExtremity)
A3D_HELPERS(A3DMDDimensionForeshortened)
A3D_HELPERS(A3DMDDimensionFunnel)
A3D_HELPERS(A3DMDDimensionLine)
A3D_HELPERS(A3DMDDimensionLineSymbol)
A3D_HELPERS(A3DMDDimensionSecondPart)
A3D_HELPERS(A3DMDDimensionSimpleToleranceFormat)
A3D_HELPERS(A3DMDDimensionValue)
A3D_HELPERS(A3DMDDimensionValueFormat)
A3D_HELPERS(A3DMDFCFDraftingRow)
A3D_HELPERS(A3DMDFCFDrawingRow)
A3D_HELPERS(A3DMDFCFIndicator)
A3D_HELPERS(A3DMDFCFRowDatum)
A3D_HELPERS(A3DMDFCFToleranceValue)
A3D_HELPERS(A3DMDFCProjectedZone)
A3D_HELPERS(A3DMDFCTolerancePerUnit)
A3D_HELPERS(A3DMDFCValue)
A3D_HELPERS(A3DMDFeatureControlFrame)
A3D_HELPERS(A3DMDLeaderDefinition)
A3D_HELPERS(A3DMDLeaderSymbol)
A3D_HELPERS(A3DMDMarkupLeaderStub)
A3D_HELPERS(A3DMDPosition2D)
A3D_HELPERS(A3DMDPosition3D)
A3D_HELPERS(A3DMDPositionReference)
A3D_HELPERS(A3DMDTextPosition)
A3D_HELPERS(A3DMDTextProperties)
A3D_HELPERS(A3DMDToleranceSize)
A3D_HELPERS(A3DMDToleranceSizeValue)
A3D_HELPERS(A3DMarkupBalloon)
A3D_HELPERS(A3DMarkupCoordinate)
A3D_HELPERS(A3DMarkupDatum)
A3D_HELPERS(A3DMarkupDefinition)
A3D_HELPERS(A3DMarkupDimension)
A3D_HELPERS(A3DMarkupFastener)
A3D_HELPERS(A3DMarkupGDT)
A3D_HELPERS(A3DMarkupLineWelding)
A3D_HELPERS(A3DMarkupLocator)
A3D_HELPERS(A3DMarkupMeasurementPoint)
A3D_HELPERS(A3DMarkupRichText)
A3D_HELPERS(A3DMarkupRoughness)
A3D_HELPERS(A3DMarkupSpotWelding)
A3D_HELPERS(A3DMarkupText)
A3D_HELPERS(A3DMathFct1DArctanCos)
A3D_HELPERS(A3DMathFct1DCombination)
A3D_HELPERS(A3DMathFct1DFraction)
A3D_HELPERS(A3DMathFct1DPolynom)
A3D_HELPERS(A3DMathFct1DTrigonometric)
A3D_HELPERS(A3DMathFct3DLinear)
A3D_HELPERS(A3DMathFct3DNonLinear)
A3D_HELPERS(A3DMiscAttribute)
A3D_HELPERS(A3DMiscCartesianTransformation)
A3D_HELPERS(A3DMiscCascadedAttributes)
A3D_HELPERS(A3DMiscEntityReference)
A3D_HELPERS(A3DMiscGeneralTransformation)
A3D_HELPERS(A3DMiscMarkupLinkedItem)
A3D_HELPERS(A3DMiscReferenceOnCsysItem)
A3D_HELPERS(A3DMiscReferenceOnTess)
A3D_HELPERS(A3DMiscReferenceOnTopology)
A3D_HELPERS(A3DMkpAnnotationItem)
A3D_HELPERS(A3DMkpAnnotationReference)
A3D_HELPERS(A3DMkpAnnotationSet)
A3D_HELPERS(A3DMkpLeader)
A3D_HELPERS(A3DMkpMarkup)
A3D_HELPERS(A3DMkpRTFField)
A3D_HELPERS(A3DMkpView)
A3D_HELPERS(A3DRiBrepModel)
A3D_HELPERS(A3DRiCoordinateSystem)
A3D_HELPERS(A3DRiCurve)
A3D_HELPERS(A3DRiDirection)
A3D_HELPERS(A3DRiPlane)
A3D_HELPERS(A3DRiPointSet)
A3D_HELPERS(A3DRiPolyBrepModel)
A3D_HELPERS(A3DRiPolyWire)
A3D_HELPERS(A3DRiRepresentationItem)
A3D_HELPERS(A3DRiSet)
A3D_HELPERS(A3DRootBase)
A3D_HELPERS(A3DRootBaseWithGraphics)
A3D_HELPERS(A3DSurfBlend01)
A3D_HELPERS(A3DSurfBlend02)
A3D_HELPERS(A3DSurfBlend03)
A3D_HELPERS(A3DSurfCone)
A3D_HELPERS(A3DSurfCylinder)
A3D_HELPERS(A3DSurfCylindrical)
A3D_HELPERS(A3DSurfExtrusion)
A3D_HELPERS(A3DSurfFromCurves)
A3D_HELPERS(A3DSurfNurbs)
A3D_HELPERS(A3DSurfOffset)
A3D_HELPERS(A3DSurfPipe)
A3D_HELPERS(A3DSurfPlane)
A3D_HELPERS(A3DSurfRevolution)
A3D_HELPERS(A3DSurfRuled)
A3D_HELPERS(A3DSurfSphere)
A3D_HELPERS(A3DSurfTorus)
A3D_HELPERS(A3DSurfTransform)
A3D_HELPERS(A3DTess3D)
A3D_HELPERS(A3DTess3DWire)
A3D_HELPERS(A3DTessBase)
A3D_HELPERS(A3DTessMarkup)
A3D_HELPERS(A3DTopoBody)
A3D_HELPERS(A3DTopoBrepData)
A3D_HELPERS(A3DTopoCoEdge)
A3D_HELPERS(A3DTopoConnex)
A3D_HELPERS(A3DTopoContext)
A3D_HELPERS(A3DTopoEdge)
A3D_HELPERS(A3DTopoFace)
A3D_HELPERS(A3DTopoLoop)
A3D_HELPERS(A3DTopoMultipleVertex)
A3D_HELPERS(A3DTopoShell)
A3D_HELPERS(A3DTopoSingleWireBody)
A3D_HELPERS(A3DTopoUniqueVertex)
A3D_HELPERS(A3DTopoWireEdge)



namespace ts3d {
    template<typename T, typename S>
    std::vector<T> toVector( T *d, S const &sz ) {
        return std::vector<T>( d, d+sz );
    }
}

namespace {
    std::pair<A3DBool, double> getUnitFromPO( A3DAsmProductOccurrence *po ) {
        if( nullptr == po ) {
            return std::make_pair(static_cast<A3DBool>( false ), 0. );
        }
    
        ts3d::A3DAsmProductOccurrenceWrapper d( po );
        
        if(!d->m_bUnitFromCAD && nullptr != d->m_pPrototype ) {
            return getUnitFromPO( d->m_pPrototype );
        }
        
        return std::make_pair( d->m_bUnitFromCAD, d->m_dUnit );
    }
    
    double getUnitFactor( std::vector<A3DAsmProductOccurrence*> const &pos ) {
        for( auto po : pos ) {
            auto po_unit = getUnitFromPO( po );
            if(po_unit.first) {
                return po_unit.second;
            } else {
                ts3d::A3DAsmProductOccurrenceWrapper d( po );
                auto const child_pos = ts3d::toVector( d->m_ppPOccurrences, d->m_uiPOccurrencesSize );
                return getUnitFactor( child_pos );
            }
        }
        return -1.;
    }
}

namespace ts3d {
    using EntityArray = std::vector<A3DEntity*>;

    using EntitySet = std::set<A3DEntity*>;
    
    static inline bool isRepresentationItem( A3DEEntityType const &t ) {
        return (kA3DTypeRiRepresentationItem == t ||
                kA3DTypeRiSet == t ||
                kA3DTypeRiCurve == t ||
                kA3DTypeRiPlane == t ||
                kA3DTypeRiPointSet == t ||
                kA3DTypeRiPolyWire == t ||
                kA3DTypeRiPolyBrepModel == t ||
                kA3DTypeRiBrepModel == t ||
                kA3DTypeRiDirection == t);
    }

    static inline bool isTessBase( A3DEEntityType const &t ) {
        return (kA3DTypeTessBase == t ||
                kA3DTypeTess3D == t ||
                kA3DTypeTess3DWire == t ||
                kA3DTypeTessMarkup == t);
    }

    static inline bool isAnnotationEntity( A3DEEntityType const &t ) {
        return (kA3DTypeMkpAnnotationItem == t ||
                kA3DTypeMkpAnnotationSet == t ||
                kA3DTypeMkpAnnotationReference == t);
    }

    static inline bool isMarkup( A3DEEntityType const &t ) {
        return (kA3DTypeMDPosition2D == t ||
                kA3DTypeMDPosition3D == t ||
                kA3DTypeMDPositionReference == t ||
                kA3DTypeMarkupCoordinate == t ||
                kA3DTypeMarkupText == t ||
                kA3DTypeMDTextPosition == t ||
                kA3DTypeMarkupRichText == t ||
                kA3DTypeMarkupDimension == t ||
                kA3DTypeMarkupDatum == t ||
                kA3DTypeMarkupGDT == t ||
                kA3DTypeMarkupRoughness == t ||
                kA3DTypeMarkupBalloon == t ||
                kA3DTypeMarkupFastener == t ||
                kA3DTypeMarkupLocator == t ||
                kA3DTypeMarkupMeasurementPoint == t ||
                kA3DTypeMarkupLineWelding == t ||
                kA3DTypeMarkupSpotWelding == t);
    }

    static inline A3DEEntityType getEntityType( A3DEntity *ntt ) {
        auto result = kA3DTypeUnknown;
        if( nullptr != ntt ) {
            A3DEntityGetType( ntt, &result );
        }
        return result;
    }
    
    enum class PrototypeOption {
        Use,
        DoNotUse
    };

    static inline A3DAsmPartDefinition *getPartDefinition( A3DAsmProductOccurrence *po, PrototypeOption const &opt = PrototypeOption::Use ) {
        if( nullptr == po ) {
            return nullptr;
        }
        A3DAsmProductOccurrenceWrapper d( po );
        return d->m_pPart ? d->m_pPart : (opt == PrototypeOption::Use ? getPartDefinition( d->m_pPrototype, opt ) : nullptr );
    }

    static inline EntityArray getProductOccurrences( A3DAsmProductOccurrence *po, PrototypeOption const &opt = PrototypeOption::Use ) {
        if( nullptr == po ) {
            return EntityArray();
        }
        
        A3DAsmProductOccurrenceWrapper d( po );
        return d->m_uiPOccurrencesSize != 0 ? toVector( d->m_ppPOccurrences, d->m_uiPOccurrencesSize ) : (opt == PrototypeOption::Use ? getProductOccurrences( d->m_pPrototype, opt ) : EntityArray() );
    }

    static inline double getUnit( A3DAsmModelFile *modelFile ) {
        A3DAsmModelFileWrapper d( modelFile );
        return d->m_bUnitFromCAD ? d->m_dUnit : getUnitFactor( toVector( d->m_ppPOccurrences, d->m_uiPOccurrencesSize ) );
    }
}

#define kA3DTypeTopoVertex static_cast<A3DEEntityType>(kA3DTypeTopo + 18)

#define kA3DTypeMkpAnnotationEntity static_cast<A3DEEntityType>(kA3DTypeMkp + 7)



namespace ts3d {
    using InstancePath = EntityArray;

    
    using InstancePathArray = std::vector<InstancePath>;

    static InstancePathArray getLeafInstances( A3DEntity *owner, A3DEEntityType const &leaf_type );

    static inline EntitySet getUniqueParts( A3DAsmModelFile *modelFile );

    using InstancePathMap = std::unordered_map<A3DEntity*, InstancePathArray>;

    static inline EntitySet getUniqueLeafEntities( A3DEntity *owner, A3DEEntityType const &leaf_type );

    static inline EntitySet getUniqueChildren( A3DEntity *owner, A3DEEntityType const &leaf_type ) {
        return getUniqueLeafEntities( owner, leaf_type );
    }

    static inline EntitySet getUniqueLeafEntities( A3DEntity *owner, A3DEEntityType const &leaf_type, InstancePathMap &instance_path_map );

    static inline EntitySet getUniqueChildren( A3DEntity *owner, A3DEEntityType const &leaf_type, InstancePathMap &instance_path_map ) {
        return getUniqueLeafEntities( owner, leaf_type, instance_path_map );
    }

    static inline InstancePath getOwningInstance( InstancePath const &instance_path, A3DEEntityType const &owner_type );

    static inline EntityArray getChildren( A3DEntity *parent, A3DEEntityType const &child_type );

}


namespace std {
    template <> struct hash<A3DEEntityType> {
        size_t operator()(A3DEEntityType const& s) const noexcept {
            return s;
        }
    };
    template<>  struct hash<ts3d::InstancePath> {
        size_t operator()(ts3d::InstancePath const &i ) const noexcept {
            auto seed = i.size();
            auto const magic_number = reinterpret_cast<size_t>( A3DAsmModelFileGet );
            for( auto &ntt : i ) {
                seed ^= reinterpret_cast<size_t>( ntt ) + magic_number + (seed << 6) + (seed >>2 );
            }
            return seed;
        }
    };
}

namespace {
    using namespace ts3d;
    using TypeSet = std::set<A3DEEntityType>;
    using TypePath = std::vector<A3DEEntityType>;
    using TypePathArray = std::vector<TypePath>;

    // Function object that can be invoked to obtain an EntityArray
    // of the child objects
    using GetterFunction = std::function<EntityArray (A3DEntity*)>;

    // The GetterMap is used to look up a getter function for a
    // particular child object type
    using GetterMap = std::unordered_map<A3DEEntityType, GetterFunction>;

    // The GetterMapsByType is used to look up a GetterMap for a
    // particular owning object type
    using GetterMapsByType = std::unordered_map<A3DEEntityType, GetterMap>;
    
    // This is the static instance of a GetterMapsByType. It is
    // initialized with parent type to { child type } hash, and
    // for each child type it contains a function object for
    // obtaining the children of that type. See the typedef
    // statements above to better understand the initializer
    // syntax.
    static GetterMapsByType _getterMapByType = {
        {   // an entry in GetterMapsByType
            kA3DTypeAsmModelFile, // A3DEEntityType (owning object type)
            { // GetterMap
                { // an entry in GetterMap
                    kA3DTypeAsmProductOccurrence, // A3DEEntityType (child object type)
                    [](A3DEntity *ntt) {          // GetteFunction (function for getting children)
                        A3DAsmModelFileWrapper d( ntt );
                        return toVector( d->m_ppPOccurrences, d->m_uiPOccurrencesSize );
                    }
                }
            }
        },
        {
            kA3DTypeAsmProductOccurrence,
            {
                {
                    kA3DTypeAsmProductOccurrence,
                    [](A3DEntity *ntt) {
                        return getProductOccurrences( ntt, PrototypeOption::Use );
                    }
                },
                {
                    kA3DTypeAsmPartDefinition,
                    [](A3DEntity *ntt) {
                        auto const part_definition = getPartDefinition( ntt, PrototypeOption::Use );
                        return nullptr == part_definition ? EntityArray() : EntityArray( 1, part_definition );
                    }
                },
                {
                    kA3DTypeMkpView,
                    [](A3DEntity *ntt) {
                        A3DAsmProductOccurrenceWrapper d( ntt );
                        return toVector( d->m_ppViews, d->m_uiViewsSize );
                    }
                },
                {
                    kA3DTypeGraphCamera,
                    [](A3DEntity *ntt) {
                        A3DAsmProductOccurrenceWrapper d( ntt );
                        return toVector( d->m_ppCamera, d->m_uiCameraSize );
                    }
                },
                {
                    kA3DTypeMkpAnnotationEntity,
                    [](A3DEntity *ntt) {
                        A3DAsmProductOccurrenceWrapper d( ntt );
                        return toVector( d->m_ppAnnotations, d->m_uiAnnotationsSize );
                    }
                }
            }
        },
        {
            kA3DTypeAsmPartDefinition,
            {
                {
                    kA3DTypeRiRepresentationItem,
                    [](A3DEntity *ntt) {
                        A3DAsmPartDefinitionWrapper d( ntt );
                        return toVector( d->m_ppRepItems, d->m_uiRepItemsSize );
                    }
                },
                {
                    kA3DTypeMkpAnnotationEntity,
                    [](A3DEntity *ntt) {
                        A3DAsmPartDefinitionWrapper d( ntt );
                        return toVector( d->m_ppAnnotations, d->m_uiAnnotationsSize );
                    }
                },
                {
                    kA3DTypeMkpView,
                    []( A3DEntity *ntt) {
                        A3DAsmPartDefinitionWrapper d( ntt );
                        return toVector( d->m_ppViews, d->m_uiViewsSize );
                    }
                }
            }
        },
        {
            kA3DTypeRiRepresentationItem,
            {
                {
                    kA3DTypeRiRepresentationItem,
                    [](A3DEntity *ntt) {
                        if( kA3DTypeRiSet == getEntityType( ntt ) ) {
                            A3DRiSetWrapper d( ntt );
                            return toVector( d->m_ppRepItems, d->m_uiRepItemsSize );
                        }
                        return EntityArray();
                    }
                },
                {
                    kA3DTypeTopoBrepData,
                    [](A3DEntity *ntt) {
                        auto const ntt_type = getEntityType( ntt );
                        if( kA3DTypeRiBrepModel == ntt_type ) {
                            A3DRiBrepModelWrapper d( ntt );
                            return EntityArray( 1, d->m_pBrepData );
                        } else if( kA3DTypeRiPlane == ntt_type ) {
                            A3DRiPlaneWrapper d( ntt );
                            return EntityArray( 1, d->m_pBrepData );
                        }
                        return EntityArray();
                    }
                },
                {
                    kA3DTypeTopoSingleWireBody,
                    [](A3DEntity *ntt) {
                        if( kA3DTypeRiCurve == getEntityType( ntt ) ) {
                            A3DRiCurveWrapper d( ntt );
                            return EntityArray( 1, d->m_pBody );
                        }
                        return EntityArray();
                    }
                }
            }
        },
        {
            kA3DTypeTopoBrepData,
            {
                {
                    kA3DTypeTopoConnex,
                    [](A3DEntity *ntt) {
                        A3DTopoBrepDataWrapper d( ntt );
                        return toVector( d->m_ppConnexes, d->m_uiConnexSize );
                    }
                }
            }
        },
        {
            kA3DTypeTopoConnex,
            {
                {
                    kA3DTypeTopoShell,
                    [](A3DEntity *ntt) {
                        A3DTopoConnexWrapper d( ntt );
                        return toVector( d->m_ppShells, d->m_uiShellSize );
                    }
                }
            }
        },
        {
            kA3DTypeTopoShell,
            {
                {
                    kA3DTypeTopoFace,
                    [](A3DEntity *ntt) {
                        A3DTopoShellWrapper d( ntt );
                        return toVector( d->m_ppFaces, d->m_uiFaceSize );
                    }
                }
            }
        },
        {
            kA3DTypeTopoFace,
            {
                {
                    kA3DTypeTopoLoop,
                    [](A3DEntity *ntt) {
                        A3DTopoFaceWrapper d( ntt );
                        return toVector( d->m_ppLoops, d->m_uiLoopSize );
                    }
                }
            }
        },
        {
            kA3DTypeTopoLoop,
            {
                {
                    kA3DTypeTopoCoEdge,
                    [](A3DEntity *ntt) {
                        A3DTopoLoopWrapper d( ntt );
                        return toVector( d->m_ppCoEdges, d->m_uiCoEdgeSize );
                    }
                }
            }
        },
        {
            kA3DTypeTopoCoEdge,
            {
                {
                    kA3DTypeTopoEdge,
                    []( A3DEntity *ntt ) {
                        A3DTopoCoEdgeWrapper d( ntt );
                        return EntityArray( 1, d->m_pEdge );
                        
                    }
                }
            }
        },
        {
            kA3DTypeTopoEdge,
            {
                {
                    kA3DTypeTopoVertex,
                    []( A3DEntity *ntt ) {
                        A3DTopoEdgeWrapper d( ntt );
                        EntityArray result;
                        result.reserve( 2 );
                        result.push_back( d->m_pStartVertex );
                        result.push_back( d->m_pEndVertex );
                        return result;
                    }
                }
            }
        },
        {
            kA3DTypeTopoSingleWireBody,
            {
                {
                    kA3DTypeTopoWireEdge,
                    []( A3DEntity *ntt ) {
                        A3DTopoSingleWireBodyWrapper d( ntt );
                        return EntityArray( 1, d->m_pWireEdge );
                    }
                }
            }
        },
        {
            kA3DTypeMkpAnnotationEntity,
            {
                {
                    kA3DTypeMkpAnnotationEntity,
                    []( A3DEntity *ntt ) {
                        if( kA3DTypeMkpAnnotationSet == getEntityType( ntt ) ) {
                            A3DMkpAnnotationSetWrapper d( ntt );
                            return toVector( d->m_ppAnnotations, d->m_uiAnnotationsSize );
                        }
                        return EntityArray();
                    }
                },
                {
                    kA3DTypeMiscMarkupLinkedItem,
                    []( A3DEntity *ntt ) {
                        if( kA3DTypeMkpAnnotationReference == getEntityType( ntt ) ) {
                            A3DMkpAnnotationReferenceWrapper d( ntt );
                            return toVector( d->m_ppLinkedItems, d->m_uiLinkedItemsSize );
                        }
                        return EntityArray();
                    }
                },
                {
                    kA3DTypeMkpMarkup, // Base type, matches all markups
                    []( A3DEntity *ntt ) {
                        if( kA3DTypeMkpAnnotationItem == getEntityType( ntt ) ) {
                            A3DMkpAnnotationItemWrapper d( ntt );
                            return EntityArray( 1, d->m_pMarkup );
                        }
                        return EntityArray();
                    }
                }
            }
        },
        {
            kA3DTypeMkpMarkup,
            {
                {
                    kA3DTypeMiscMarkupLinkedItem,
                    []( A3DEntity *ntt ) {
                        A3DMkpMarkupWrapper d( ntt );
                        return toVector( d->m_ppLinkedItems, d->m_uiLinkedItemsSize );
                    }
                },
                {
                    kA3DTypeMkpLeader,
                    []( A3DEntity *ntt ) {
                        A3DMkpMarkupWrapper d( ntt );
                        return toVector( d->m_ppLeaders, d->m_uiLeadersSize );
                    }
                }
            }
        }
    };
    
    // For an entity type child_type, this function returns
    // a list of entity types that can contain the child type
    static inline TypeSet getPossibleParents( A3DEEntityType const &child_type ) {
        static std::unordered_map<A3DEEntityType, TypeSet> _cache;
        auto const it = _cache.find( child_type );
        if( std::end( _cache ) != it ) {
            return it->second;
        }
        
        TypeSet possible_parents;
        for( auto const owning_type_entry : _getterMapByType ) {
            auto const owning_type = owning_type_entry.first;
            for( auto const child_type_entry : owning_type_entry.second ) {
                if( child_type_entry.first == child_type ) {
                    possible_parents.insert( owning_type );
                    break;
                }
            }
        }
        _cache[child_type] = possible_parents;
        return possible_parents;
    }
    
    // Since some entity types "derived", this function is a helper
    // used to obtain a "base" type for entity_type
    static inline A3DEEntityType getBaseType( A3DEEntityType const &entity_type ) {
        auto base_type = entity_type;
        if( isRepresentationItem( entity_type ) ) {
            base_type = kA3DTypeRiRepresentationItem;
        } else if( isTessBase( entity_type ) ) {
            base_type = kA3DTypeTessBase;
        } else if( kA3DTypeTopoUniqueVertex == entity_type || kA3DTypeTopoMultipleVertex == entity_type ) {
            base_type = kA3DTypeTopoVertex;
        } else if( isAnnotationEntity( entity_type ) ) {
            base_type = kA3DTypeMkpAnnotationEntity;
        } else if( isMarkup( entity_type ) ) {
            base_type = kA3DTypeMkpMarkup;
        }
        return base_type;
    }
    
    // This function can be used to obtain a set of type paths where the parent type
    // and leaf child type values are both given. Each type path returned is one
    // possible way to traverse the Exchange data structures such that the beginning
    // entity type and ending entity type are equal to the input parameters.
    static TypePathArray getPossibleTypePaths( A3DEEntityType const &parent_type, A3DEEntityType const &child_type ) {
        
        // check to see if the given owner and child type values are present in the cache
        static std::unordered_map< A3DEEntityType, std::unordered_map< A3DEEntityType, TypePathArray >> _cache;
        auto const parent_type_it = _cache.find( parent_type );
        if(std::end( _cache ) != parent_type_it ) {
            auto const child_type_it = parent_type_it->second.find( child_type );
            if( std::end( parent_type_it->second ) != child_type_it ) {
                return child_type_it->second;
            }
        }
        
        // result is not present in the cache, so compute it
        TypePathArray type_paths;
        auto const possible_parents = getPossibleParents( child_type );
        if( std::end( possible_parents ) != possible_parents.find( parent_type ) ) {
            // child entity type is an immediate child of parent entity type
            TypePath type_path;
            type_path.push_back( parent_type );
            type_path.push_back( child_type );
            type_paths.push_back( type_path );
        } else {
            // child entity type is not an immediate child of parent entity type
            // so we must iterate over the list of all possible parent types
            // and for each of those parent types, examine up the ownership chain
            for( auto const intermediate_parent_type : possible_parents ) {
                if( intermediate_parent_type != child_type ) {
                    auto const intermediate_type_paths = getPossibleTypePaths( parent_type, intermediate_parent_type );
                    for( auto const intermediate_type_path : intermediate_type_paths ) {
                        type_paths.push_back( intermediate_type_path );
                        type_paths.back().push_back( child_type );
                    }
                }
            }
        }
        // augment the cache

        _cache[parent_type][child_type] = type_paths;
        return type_paths;
    }
    
    static ts3d::InstancePathArray getInstancePaths( A3DEntity *owner, TypePath const &type_path, ts3d::InstancePath const &instance_path = ts3d::InstancePath() )  {
        ts3d::InstancePathArray instance_paths;
        auto const owner_type = ts3d::getEntityType( owner );
        auto const owner_base_type = getBaseType( owner_type );
        auto const owner_decomposer_it = _getterMapByType.find( owner_base_type );
        auto base_instance_path = instance_path;
        base_instance_path.push_back( owner );

        if(std::end( _getterMapByType ) == owner_decomposer_it ) {
            if( type_path.size() == 1 && owner_base_type == type_path.back() ) {
                instance_paths.push_back( base_instance_path );
            }
            return instance_paths;
        }
        
        
        if( kA3DTypeAsmProductOccurrence == owner_base_type ) {
            auto const children = owner_decomposer_it->second[kA3DTypeAsmProductOccurrence]( owner );
            if( !children.empty() ) {
                for( auto child : children ) {
                    auto const child_instance_paths = getInstancePaths( child, type_path, base_instance_path );
                    std::copy( child_instance_paths.begin(), child_instance_paths.end(), std::back_inserter( instance_paths ) );
                }
            }
        } else if( kA3DTypeRiSet == owner_type ) {
            auto const children = owner_decomposer_it->second[kA3DTypeRiRepresentationItem]( owner );
            if( !children.empty() ) {
                for( auto child : children ) {
                    auto const child_instance_paths = getInstancePaths( child, type_path, base_instance_path );
                    std::copy( child_instance_paths.begin(), child_instance_paths.end(), std::back_inserter( instance_paths ) );
                }
                return instance_paths;
            }
        } else if( kA3DTypeMkpAnnotationSet == owner_type ) {
            auto const children = owner_decomposer_it->second[kA3DTypeMkpAnnotationEntity]( owner );
            if( !children.empty() ) {
                for( auto child : children ) {
                    auto const child_instance_paths = getInstancePaths( child, type_path, base_instance_path );
                    std::copy( child_instance_paths.begin(), child_instance_paths.end(), std::back_inserter( instance_paths ) );
                }
            }
        }
        
        TypePath const child_type_path( type_path.begin() + 1, type_path.end() );
        if(child_type_path.empty()) {
            instance_paths.push_back( base_instance_path );
            return instance_paths;
        }
        auto const children = owner_decomposer_it->second[child_type_path.front()]( owner );
        for(auto child : children ) {
            auto const child_instance_paths = getInstancePaths( child, child_type_path, base_instance_path );
            std::copy( child_instance_paths.begin(), child_instance_paths.end(), std::back_inserter( instance_paths ) );
        }
        return instance_paths;
    }
}

ts3d::InstancePathArray ts3d::getLeafInstances( A3DEntity *owner, A3DEEntityType const &leaf_type ) {
    InstancePathArray result;
    auto const owner_base_type = getBaseType( getEntityType( owner ) );
    auto const leaf_base_type = getBaseType( leaf_type );
    
    auto const possible_type_paths = getPossibleTypePaths( owner_base_type, leaf_base_type );
    for( auto const possible_type_path : possible_type_paths ) {
        if( possible_type_path.empty() ) {
            continue;
        }
        auto const instance_paths = getInstancePaths( owner, possible_type_path );
        if( leaf_base_type != leaf_type ) {
            std::copy_if( instance_paths.begin(), instance_paths.end(), std::back_inserter( result ),
                         [leaf_type](InstancePath const &instance_path) {
                             auto const leaf_entity = instance_path.back();
                             return getEntityType( leaf_entity ) == leaf_type;
                         });
        } else {
            std::copy( instance_paths.begin(), instance_paths.end(), std::back_inserter( result ) );
        }
    }
    
    return result;
}

ts3d::EntitySet ts3d::getUniqueParts( A3DAsmModelFile *modelFile ) {
    return getUniqueLeafEntities( modelFile, kA3DTypeAsmPartDefinition );
}

ts3d::EntitySet ts3d::getUniqueLeafEntities( A3DEntity *owner, A3DEEntityType const &leaf_type ) {
    EntitySet result;
    auto const paths = getLeafInstances( owner, leaf_type );
    for( auto path : paths ) {
        result.insert( path.back() );
    }
    return result;
}

ts3d::EntitySet ts3d::getUniqueLeafEntities( A3DEntity *owner, A3DEEntityType const &leaf_type, InstancePathMap &instance_path_map ) {
    EntitySet result;
    auto const paths = getLeafInstances( owner, leaf_type );
    for( auto path : paths) {
        result.insert( path.back() );
        instance_path_map[path.back()].emplace_back( path );
    }
    return result;
}

ts3d::InstancePath ts3d::getOwningInstance( InstancePath const &instance_path, A3DEEntityType const &owner_type ) {
    auto result = instance_path;
    while( !result.empty() && getEntityType( result.back() ) != owner_type ) {
        result.pop_back();
    }
    return result;
}

ts3d::EntityArray ts3d::getChildren( A3DEntity *owner, A3DEEntityType const &child_type ) {
    auto const owner_type = ts3d::getEntityType( owner );
    auto const owner_base_type = getBaseType( owner_type );
    auto const child_base_type = getBaseType( child_type );
    auto const owner_decomposer_it = _getterMapByType.find( owner_base_type );
    
    EntityArray result;
    auto const decomposer_it = owner_decomposer_it->second.find(child_base_type);
    if (std::end(owner_decomposer_it->second) == decomposer_it) {
        return result;
    }
    auto const children = decomposer_it->second( owner );
    std::copy_if( std::begin( children ), std::end( children ), std::back_inserter( result ), [child_type, child_base_type]( A3DEntity *child ) {
        return child_type == child_base_type || getEntityType( child ) == child_type;
    });
    return result;
}


namespace {
    static inline std::string getName( A3DEntity *ntt ) {
        ts3d::A3DRootBaseWrapper d( ntt );
        if( d->m_pcName ) {
            return d->m_pcName;
        }

        auto const t = ts3d::getEntityType( ntt );
        if( kA3DTypeAsmProductOccurrence == t ) {
            ts3d::A3DAsmProductOccurrenceWrapper d( ntt );
            return getName( d->m_pPrototype );
        }
        
        return std::string();
    }

    A3DMiscTransformation *getLocation( A3DAsmProductOccurrence *po ) {
        if( nullptr == po ) {
            return nullptr;
        }
        A3DAsmProductOccurrenceData d;
        A3D_INITIALIZE_DATA( A3DAsmModelFileData, d );
        A3DAsmProductOccurrenceGet( po, &d );
        auto location = d.m_pLocation;
        auto prototype = d.m_pPrototype;
        A3DAsmProductOccurrenceGet( nullptr, &d );
        return location ? location : getLocation( prototype );
    }
}

namespace ts3d {
    class Instance;
    using InstancePtr = std::shared_ptr<Instance>;
    
    class Instance {
    public:
        Instance( InstancePath const &path )
        : _path( path ) {
        }

        
        Instance( Instance const &other )
        : _path( other._path ) {
        }

        
        Instance( Instance &&other )
        : _path( std::move( other._path ) ) {
        }

        
        virtual ~Instance( void ) {
            reset( InstancePath() );
        }
        
        Instance &operator=( Instance const &other ) {
            _path = other._path;
            return *this;
        }
        
        Instance &operator=( Instance &&other ) {
            _path = std::move( other._path );
            return *this;
        }

        bool operator==( Instance const &other ) const {
            return _path == other._path;
        }
        
        std::string getName( void ) const {
            return ::getName( leaf() );
        }

        std::string getType( void ) const {
            return A3DMiscGetEntityTypeMsg( leafType() );
        }

        InstancePath const &path( void ) const {
            return _path;
        }

        Instance owner( void ) const {
            if( _path.size() < 2 ) {
                return Instance( InstancePath() );
            }
            auto owner_path = _path;
            owner_path.pop_back();
            return Instance( owner_path );
        }


        void reset( InstancePath const &new_path ) {
            if( new_path == _path ) {
                return;
            }
            
            _path = new_path;
            
            for( auto attrib : _cascaded_attribs ) {
                A3DMiscCascadedAttributesDelete( attrib );
            }
            
            _cascaded_attribs_data.reset( nullptr );
        }
        
        A3DEntity *leaf( void ) const {
            return _path.empty() ? nullptr : _path.back();
        }

        A3DEEntityType leafType( void ) const {
           return getEntityType( leaf() );
       }



        bool getNetRemoved( void ) const {
            return A3D_TRUE == getCascadedAttributesData()->m_bRemoved;
        }


        bool getNetShow( void ) const {
            return A3D_TRUE == getCascadedAttributesData()->m_bShow;
        }
        
        A3DGraphStyleData getNetStyle( void ) const {
            return getCascadedAttributesData()->m_sStyle;
        }
        
        A3DUns16 getNetLayer( void ) const {
            return getCascadedAttributesData()->m_usLayer;
        }
    protected:
        A3DMiscCascadedAttributesWrapper const &getCascadedAttributesData( void ) const {
            if( _cascaded_attribs.empty() ) {
                getCascadedAttributes();
            }
            return _cascaded_attribs_data;
        }
        
        A3DMiscCascadedAttributes *getCascadedAttributes( void ) const {
            if(_cascaded_attribs.empty() ) {
                _cascaded_attribs.push_back( nullptr );
                CheckResult( A3DMiscCascadedAttributesCreate( &_cascaded_attribs.back() ) );
                for( auto ntt : _path ) {
                    if( A3DEntityIsBaseWithGraphicsType( ntt ) ) {
                        auto father = _cascaded_attribs.back();
                        _cascaded_attribs.push_back( nullptr );
                        CheckResult( A3DMiscCascadedAttributesCreate( &_cascaded_attribs.back() ) );
                        CheckResult( A3DMiscCascadedAttributesPush( _cascaded_attribs.back(), ntt, father ) );
                    }
                }
                if( !_cascaded_attribs.empty() ) {
                    _cascaded_attribs_data.reset( _cascaded_attribs.back() );
                }
            }
            return _cascaded_attribs.empty() ? nullptr : _cascaded_attribs.back();
        }
        
        InstancePath _path;
        mutable std::vector<A3DMiscCascadedAttributes*> _cascaded_attribs;
        mutable A3DMiscCascadedAttributesWrapper _cascaded_attribs_data;
    };

    class TessBaseInstance : public Instance {
    public:
        TessBaseInstance( InstancePath const &path )
        : Instance( path ) {
            if( !isTessBase( leafType() ) ) {
                throw std::invalid_argument( "Expected leaf node type of A3DTessBase. " );
            }
            _d.reset( leaf() );
        }

        
        double const *coords( void ) const {
            return _d->m_pdCoords;
        }

        A3DUns32 coordsSize( void ) const {
            return _d->m_uiCoordSize;
        }
        
    private:
        A3DTessBaseWrapper _d;
    };

    class TessFaceDataHelper {
    public:
        TessFaceDataHelper( A3DTessFaceData const &d, A3DUns32 const *triangulatedIndexes, A3DUns32 const *wireIndexes ) {
            auto sz_tri_idx = 0u;
            auto ti_index = d.m_uiStartTriangulated;
            if(kA3DTessFaceDataTriangle & d.m_usUsedEntitiesFlags) {
                auto const num_tris = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto tri = 0u; tri < num_tris; tri++) {
                    for(auto vert = 0u; vert < 3u; vert++) {
                        _normals.push_back( triangulatedIndexes[ti_index++] );
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                    }
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleFan  & d.m_usUsedEntitiesFlags) {
                auto const num_fans = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto fan_idx = 0u; fan_idx < num_fans; ++fan_idx) {
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++];
                    auto const root_n = triangulatedIndexes[ti_index++];
                    auto const root_v = triangulatedIndexes[ti_index++];
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        _normals.push_back( root_n );
                        _vertices.push_back( root_v );
                        
                        _normals.push_back( triangulatedIndexes[ti_index++] );
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                        
                        _normals.push_back( triangulatedIndexes[ti_index] );
                        _vertices.push_back( triangulatedIndexes[ti_index + 1] );
                    }
                    ti_index += 2;
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleStripe & d.m_usUsedEntitiesFlags) {
                auto const num_tri_stips = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto strip_idx = 0u; strip_idx < num_tri_stips; ++strip_idx) {
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++];
                    ti_index += 2;
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        auto const prev_n = triangulatedIndexes[ti_index - 2];
                        auto const prev_v = triangulatedIndexes[ti_index - 1];
                        auto const current_n = triangulatedIndexes[ti_index++];
                        auto const current_v = triangulatedIndexes[ti_index++];
                        auto const next_n = triangulatedIndexes[ti_index];
                        auto const next_v = triangulatedIndexes[ti_index + 1];
                        
                        _normals.push_back( current_n );
                        _vertices.push_back( current_v );
                        _normals.push_back( vert % 2 ? next_n : prev_n );
                        _vertices.push_back( vert % 2 ? next_v : prev_v );
                        _normals.push_back( vert % 2 ? prev_n : next_n );
                        _vertices.push_back( vert % 2 ? prev_v : next_v );
                    }
                    ti_index += 2;
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleOneNormal & d.m_usUsedEntitiesFlags) {
                auto const num_tris_1normal = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto tri = 0u; tri < num_tris_1normal; tri++) {
                    auto n = triangulatedIndexes[ti_index++];
                    for(auto vert = 0u; vert < 3u; vert++) {
                        _normals.push_back( n );
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                    }
                }
            }
            
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleFanOneNormal & d.m_usUsedEntitiesFlags) {
                auto const num_fans_1normal = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto fan_idx = 0u; fan_idx < num_fans_1normal; ++fan_idx) {
                    auto const has_vertex_normals = 0 == (d.m_puiSizesTriangulated[sz_tri_idx] & kA3DTessFaceDataNormalSingle);
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++] & kA3DTessFaceDataNormalMask;
                    auto const root_n = triangulatedIndexes[ti_index++];
                    auto const root_v = triangulatedIndexes[ti_index++];
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        auto const n = (has_vertex_normals ? triangulatedIndexes[ti_index++] : root_n);
                        auto const v = triangulatedIndexes[ti_index++];
                        
                        auto const next_n = (has_vertex_normals ? triangulatedIndexes[ti_index] : root_n);
                        auto const next_v = triangulatedIndexes[ti_index + (has_vertex_normals ? 1 : 0)];
                        
                        _normals.push_back( root_n );
                        _vertices.push_back( root_v );
                        _normals.push_back( n );
                        _vertices.push_back( v );
                        _normals.push_back( next_n );
                        _vertices.push_back( next_v );
                    }
                    ti_index += (has_vertex_normals ? 2 : 1);
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleStripeOneNormal & d.m_usUsedEntitiesFlags) {
                auto const num_tri_stips = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto strip_idx = 0u; strip_idx < num_tri_stips; ++strip_idx) {
                    auto const has_vertex_normals = 0 == (d.m_puiSizesTriangulated[sz_tri_idx] & kA3DTessFaceDataNormalSingle);
                    auto const series_normal = triangulatedIndexes[ti_index];
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++] & kA3DTessFaceDataNormalMask;
                    ti_index += 2;
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        auto const prev_n = (has_vertex_normals ? triangulatedIndexes[ti_index - 2] : series_normal);
                        auto const prev_v = triangulatedIndexes[ti_index - 1];
                        
                        auto const current_n = (has_vertex_normals ? triangulatedIndexes[ti_index++] : series_normal);
                        auto const current_v = triangulatedIndexes[ti_index++];
                        
                        auto const next_n = (has_vertex_normals ? triangulatedIndexes[ti_index] : series_normal);
                        auto const next_v = triangulatedIndexes[ti_index + (has_vertex_normals ? 1 : 0)];
                        
                        _normals.push_back( current_n );
                        _vertices.push_back( current_v );
                        _normals.push_back( vert % 2 ? next_n : prev_n );
                        _vertices.push_back( vert % 2 ? next_v : prev_v );
                        _normals.push_back( vert % 2 ? prev_n : next_n );
                        _vertices.push_back( vert % 2 ? prev_v : next_v );
                    }
                    ti_index += (has_vertex_normals ? 2 : 1);
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleTextured & d.m_usUsedEntitiesFlags) {
                auto const num_tris = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto tri_idx = 0u; tri_idx < num_tris; tri_idx++) {
                    for(auto vert_idx = 0u; vert_idx < 3u; vert_idx++) {
                        _normals.push_back( triangulatedIndexes[ti_index++] );
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            _texture.push_back( triangulatedIndexes[ti_index++] );
                        }
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                    }
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleFanTextured & d.m_usUsedEntitiesFlags) {
                auto const num_fans_textured = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto fan_idx = 0u; fan_idx < num_fans_textured; ++fan_idx) {
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++];
                    auto const n = triangulatedIndexes[ti_index++];
                    std::vector<A3DUns32> t;
                    for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                        t.push_back( triangulatedIndexes[ti_index++] );
                    }
                    auto const v = triangulatedIndexes[ti_index++];
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        _normals.push_back( n );
                        _texture.insert( _texture.end(), t.begin(), t.end() );
                        _vertices.push_back( v );
                        
                        _normals.push_back( triangulatedIndexes[ti_index++] );
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            _texture.push_back( triangulatedIndexes[ti_index++] );
                        }
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                        
                        _normals.push_back( triangulatedIndexes[ti_index++] );
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            _texture.push_back( triangulatedIndexes[ti_index++] );
                        }
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                    }
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleStripeTextured  & d.m_usUsedEntitiesFlags) {
                auto const num_tri_stips = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto strip_idx = 0u; strip_idx < num_tri_stips; ++strip_idx) {
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++];
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        auto const prev_n = triangulatedIndexes[ti_index - (2 + d.m_uiTextureCoordIndexesSize)];
                        std::vector<A3DUns32> prev_t;
                        for( auto i = ti_index - (1 + d.m_uiTextureCoordIndexesSize); i < ti_index - 1; ++i ) {
                            prev_t.push_back( triangulatedIndexes[i] );
                        }
                        auto const prev_v = triangulatedIndexes[ti_index - 1];
                        
                        auto const current_n = triangulatedIndexes[ti_index++];
                        std::vector<A3DUns32> current_t;
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            current_t.push_back( triangulatedIndexes[ti_index++] );
                        }
                        auto const current_v = triangulatedIndexes[ti_index++];
                        
                        auto const next_n = triangulatedIndexes[ti_index];
                        std::vector<A3DUns32> next_t;
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            next_t.push_back( triangulatedIndexes[ ti_index + i + 1] );
                        }
                        auto const next_v = triangulatedIndexes[ti_index + 1 + d.m_uiTextureCoordIndexesSize];
                        
                        _normals.push_back( current_n );
                        _texture.insert( _texture.end(), current_t.begin(), current_t.end() );
                        _vertices.push_back( current_v );
                        
                        _normals.push_back( vert % 2 ? next_n : prev_n );
                        _texture.insert( _texture.end(), vert % 2 ? next_t.begin() : prev_t.begin(), vert % 2 ? next_t.end() : prev_t.end() );
                        _vertices.push_back( vert % 2 ? next_v : prev_v );
                        
                        _normals.push_back( vert % 2 ? prev_n : next_n );
                        _texture.insert( _texture.end(), vert % 2 ? prev_t.begin() : next_t.begin(), vert % 2 ? prev_t.end() : next_t.end() );
                        _vertices.push_back( vert % 2 ? prev_v : next_v );
                    }
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleOneNormalTextured  & d.m_usUsedEntitiesFlags) {
                auto const has_vertex_normals = 0 == (d.m_puiSizesTriangulated[sz_tri_idx] & kA3DTessFaceDataNormalSingle);
                auto const series_normal = triangulatedIndexes[ti_index];
                auto const num_tris_1normal_textured = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto tri = 0u; tri < num_tris_1normal_textured; tri++) {
                    for(auto vert = 0u; vert < 3u; vert++) {
                        _normals.push_back( has_vertex_normals ? triangulatedIndexes[ti_index++] : series_normal );
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            _texture.push_back( triangulatedIndexes[ti_index++] );
                        }
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                    }
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleFanOneNormalTextured & d.m_usUsedEntitiesFlags) {
                auto const num_fans_textured = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto fan_idx = 0u; fan_idx < num_fans_textured; ++fan_idx) {
                    auto const root_n = triangulatedIndexes[ti_index++];
                    std::vector<A3DUns32> root_t;
                    for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                        root_t.push_back( triangulatedIndexes[ti_index++] );
                    }
                    auto const root_v = triangulatedIndexes[ti_index++];
                    auto const has_vertex_normals = 0 == (d.m_puiSizesTriangulated[sz_tri_idx] & kA3DTessFaceDataNormalSingle);
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++] & kA3DTessFaceDataNormalMask;
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        _normals.push_back( root_n );
                        _texture.insert( _texture.end(), root_t.begin(), root_t.end() );
                        _vertices.push_back( root_v );
                        
                        _normals.push_back( has_vertex_normals ? triangulatedIndexes[ti_index++] : root_n );
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            _texture.push_back( triangulatedIndexes[ti_index++] );
                        }
                        _vertices.push_back( triangulatedIndexes[ti_index++] );
                        
                        _normals.push_back( has_vertex_normals ? triangulatedIndexes[ti_index] : root_n );
                        for( auto i = 0u; i < d.m_uiTextureCoordIndexesSize; ++i ) {
                            _texture.push_back( triangulatedIndexes[ti_index + i + 1] );
                        }
                        _vertices.push_back( triangulatedIndexes[ti_index + 1 + (has_vertex_normals ? d.m_uiTextureCoordIndexesSize : 0)] );
                    }
                }
            }
            if(d.m_uiSizesTriangulatedSize > sz_tri_idx && kA3DTessFaceDataTriangleStripeOneNormalTextured & d.m_usUsedEntitiesFlags) {
                auto const num_tri_stips = d.m_puiSizesTriangulated[sz_tri_idx++];
                for(auto strip_idx = 0u; strip_idx < num_tri_stips; ++strip_idx) {
                    auto const has_vertex_normals = 0 == (d.m_puiSizesTriangulated[sz_tri_idx] & kA3DTessFaceDataNormalSingle);
                    auto const num_pts = d.m_puiSizesTriangulated[sz_tri_idx++] & kA3DTessFaceDataNormalMask;
                    auto const series_normal = triangulatedIndexes[ti_index];
                    ti_index += 2 + d.m_uiStyleIndexesSize;
                    for(auto vert = 1u; vert < num_pts - 1u; vert++) {
                        auto const prev_n = has_vertex_normals ? triangulatedIndexes[ti_index - (2 + d.m_uiTextureCoordIndexesSize)] : series_normal;
                        auto const prev_v = triangulatedIndexes[ti_index - 1];
                        
                        
                        auto const current_n = has_vertex_normals ? triangulatedIndexes[ti_index++] : series_normal;
                        ti_index += d.m_uiTextureCoordIndexesSize;
                        auto const current_v = triangulatedIndexes[ti_index++];
                        
                        auto const next_n = has_vertex_normals ? triangulatedIndexes[ti_index] : series_normal;
                        auto const next_v = triangulatedIndexes[ti_index + 1 + (has_vertex_normals ? d.m_uiTextureCoordIndexesSize : 0)];
                        
                        _normals.push_back( current_n );
                        _vertices.push_back( current_v );
                        _normals.push_back( vert % 2 ? next_n : prev_n );
                        _vertices.push_back( vert % 2 ? next_v : prev_v );
                        _normals.push_back( vert % 2 ? prev_n : next_n );
                        _vertices.push_back( vert % 2 ? prev_v : next_v );
                    }
                }
            }
            
            auto wi_index = d.m_uiStartWire;
            TessLoop current_loop;
            for( auto idx = 0u; idx < d.m_uiSizesWiresSize; ++idx ) {
                auto const nverts_with_flags = d.m_puiSizesWires[idx];
                auto const nvertices = nverts_with_flags & ~kA3DTessFaceDataWireIsClosing & ~kA3DTessFaceDataWireIsNotDrawn;
                auto const is_closing = nverts_with_flags & kA3DTessFaceDataWireIsClosing;
                auto const is_hidden = nverts_with_flags & kA3DTessFaceDataWireIsNotDrawn;
                TessEdge current_edge;
                current_edge._visible = !is_hidden;
                for(auto vidx = 0u; vidx < nvertices; ++vidx ) {
                    current_edge._vertices.push_back( wireIndexes[wi_index++] );
                }
                current_loop._edges.push_back( current_edge );
                
                if(is_closing) {
                    _loops.push_back( current_loop );
                    current_loop._edges.clear();
                }
            }
        }
        TessFaceDataHelper( TessFaceDataHelper const &other )
        : _vertices( other._vertices ), _normals( other._normals ), _texture( other._texture ) {
        }

        TessFaceDataHelper( TessFaceDataHelper &&other )
        : _vertices( std::move( other._vertices ) ), _normals( std::move( other._normals ) ), _texture( std::move( other._texture ) ) {
        }

        
        TessFaceDataHelper &operator=( TessFaceDataHelper const &other ) {
            _vertices = other._vertices;
            _normals = other._normals;
            _texture = other._texture;
            return *this;
        }
        TessFaceDataHelper &operator=( TessFaceDataHelper &&other ) {
            _vertices = std::move( other._vertices );
            _normals = std::move( other._normals );
            _texture = std::move( other._texture );
            return *this;
        }
        
        std::vector<A3DUns32> const &vertices( void ) const {
            return _vertices;
        }

        std::vector<A3DUns32> const &normals( void ) const {
            return _normals;
        }

        std::vector<A3DUns32> const &textures( void ) const {
            return _texture;
        }
        
        struct TessEdge {
            std::vector<A3DUns32> _vertices;
            bool _visible;
        };

        struct TessLoop {
            std::vector<TessEdge> _edges;
        };
        
        std::vector<TessLoop> const loops( void ) const {
            return _loops;
        }
        
    private:
        std::vector<A3DUns32> _vertices, _normals, _texture;
        std::vector<TessLoop> _loops;
    };

    class Tess3DInstance : public TessBaseInstance {
    public:
        Tess3DInstance( InstancePath const &path )
        : TessBaseInstance( path ) {
            if( kA3DTypeTess3D != leafType() ) {
                throw std::invalid_argument("Expected A3DTess3D leaf not type." );
            }
            _d.reset( leaf() );
        }

        double const *normals( void ) const {
            return _d->m_pdNormals;
        }

        A3DUns32 normalsSize( void ) const {
            return _d->m_uiNormalSize;
        }
        
        double const *texCoords( void ) const {
            return _d->m_pdTextureCoords;
        }

        A3DUns32 texCoordsSize( void ) const {
            return _d->m_uiTextureCoordSize;
        }
        
        A3DUns32 faceSize( void ) const {
            return _d->m_uiFaceTessSize;
        }

        TessFaceDataHelper getIndexMeshForFace( A3DUns32 const &face_idx ) const {
            if( face_idx >= _d->m_uiFaceTessSize ) {
                throw std::out_of_range( "Index of face requested for index mesh is out of range." );
            }
            return TessFaceDataHelper( _d->m_psFaceTessData[face_idx], _d->m_puiTriangulatedIndexes, _d->m_puiWireIndexes );
        }
        
    private:
        A3DTess3DWrapper _d;
    };

    class Tess3DWireInstance : public TessBaseInstance {
    public:
        Tess3DWireInstance( InstancePath const &path );
        
        A3DUns32 getNumberOfWires( void ) const;
        
        struct WireData {
            std::vector<A3DUns32> _vertices;
            bool _closed;
            bool _connected_to_previous;
        };
        
        enum class ColorSpec {
            RGB,
            RGBA
        };

        ColorSpec getColorSpecification( void ) const;
        
        enum class ColorApplication {
            PerVertex,
            PerSegment
        };
        
    private:
        A3DTess3DWireWrapper _d;
    };
}

namespace ts3d {
    class RepresentationItemInstance : public Instance {
    public:
        RepresentationItemInstance( InstancePath const &path )
        : Instance( path ) {
            if( !isRepresentationItem( leafType() ) ) {
                throw std::invalid_argument( "The leaf node in the instance path must be a representation item." );
            }
        }

        std::shared_ptr<TessBaseInstance> getTessellation( void ) const {
            A3DRiRepresentationItemWrapper d( leaf() );
            auto tess_type = kA3DTypeUnknown;
            A3DEntityGetType( d->m_pTessBase, &tess_type );
            auto tess_path = path();
            tess_path.push_back( d->m_pTessBase );
            switch( tess_type ) {
                case kA3DTypeTess3D:
                    return std::make_shared<Tess3DInstance>( tess_path );
                    break;
                case kA3DTypeTess3DWire:
                    break;
                default:
                    break;
            }
            return nullptr;
        }
        
        bool getNetRemoved( A3DUns32 const face_idx ) const {
            return A3D_TRUE == getCascadedAttributesData( face_idx )->m_bRemoved;
        }


        bool getNetShow( A3DUns32 const face_idx ) const {
            return A3D_TRUE == getCascadedAttributesData( face_idx )->m_bShow;
        }
        
        A3DGraphStyleData getNetStyle( A3DUns32 const face_idx ) const {
            return getCascadedAttributesData( face_idx )->m_sStyle;
        }
        
        A3DUns16 getNetLayer( A3DUns32 const face_idx ) const {
            return getCascadedAttributesData( face_idx )->m_usLayer;
        }
    protected:
        A3DMiscCascadedAttributesWrapper getCascadedAttributesData( A3DUns32 const face_idx ) const {
            if( _cascaded_attribs.empty() ) {
                getCascadedAttributes();
            }

            auto cascaded_attribs_copy = _cascaded_attribs;
            auto father = cascaded_attribs_copy.back();
            cascaded_attribs_copy.push_back( nullptr );
            CheckResult( A3DMiscCascadedAttributesCreate( &cascaded_attribs_copy.back() ) );

            A3DRiRepresentationItemWrapper d( leaf() );
            A3DTess3DWrapper tess_d( d->m_pTessBase );
            CheckResult( A3DMiscCascadedAttributesPushTessFace( cascaded_attribs_copy.back(), leaf(), d->m_pTessBase, &tess_d->m_psFaceTessData[face_idx], face_idx, father ) );
            auto result = A3DMiscCascadedAttributesWrapper( cascaded_attribs_copy.back() );
            CheckResult( A3DMiscCascadedAttributesDelete( cascaded_attribs_copy.back() ) );
            return result;
        }
    };
    
    inline A3DVector3dData zeroVector( void ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = result.m_dY = result.m_dZ = 0.;
        return result;

    }
    
    inline A3DVector3dData operator+(A3DVector3dData const &lhs, A3DVector3dData const &rhs ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = lhs.m_dX + rhs.m_dX;
        result.m_dY = lhs.m_dY + rhs.m_dY;
        result.m_dZ = lhs.m_dZ + rhs.m_dZ;
        return result;
    }
    
    inline A3DVector3dData &operator+=(A3DVector3dData &lhs, A3DVector3dData const &rhs ) {
        lhs = lhs + rhs;
        return lhs;
    }
    
    inline A3DVector3dData operator-(A3DVector3dData const &lhs, A3DVector3dData const &rhs ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = lhs.m_dX - rhs.m_dX;
        result.m_dY = lhs.m_dY - rhs.m_dY;
        result.m_dZ = lhs.m_dZ - rhs.m_dZ;
        return result;
    }
    
    inline A3DVector3dData operator-( A3DVector3dData const &lhs ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = -lhs.m_dX;
        result.m_dY = -lhs.m_dY;
        result.m_dZ = -lhs.m_dZ;
        return result;
    }

    inline A3DVector3dData &operator-=(A3DVector3dData &lhs, A3DVector3dData const &rhs ) {
        lhs = lhs - rhs;
        return lhs;
    }

    inline A3DVector3dData operator*(A3DVector3dData const &lhs, double const &rhs ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = lhs.m_dX * rhs;
        result.m_dY = lhs.m_dY * rhs;
        result.m_dZ = lhs.m_dZ * rhs;
        return result;
    }

    inline A3DVector3dData operator*(double const &lhs, A3DVector3dData const &rhs ) {
        return rhs * lhs;
    }

    inline A3DVector3dData &operator*=(A3DVector3dData &lhs, double const &rhs ) {
        lhs.m_dX *= rhs;
        lhs.m_dY *= rhs;
        lhs.m_dZ *= rhs;
        return lhs;
    }
    
    inline A3DVector3dData operator/(A3DVector3dData const &lhs, double const &rhs ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = lhs.m_dX / rhs;
        result.m_dY = lhs.m_dY / rhs;
        result.m_dZ = lhs.m_dZ / rhs;
        return result;
    }

    inline A3DVector3dData &operator/=(A3DVector3dData &lhs, double const &rhs ) {
        lhs.m_dX /= rhs;
        lhs.m_dY /= rhs;
        lhs.m_dZ /= rhs;
        return lhs;
    }
    
    inline A3DVector3dData cross( A3DVector3dData const &lhs, A3DVector3dData const &rhs ) {
        A3DVector3dData result;
        A3D_INITIALIZE_DATA( A3DVector3dData, result );
        result.m_dX = lhs.m_dY * rhs.m_dZ - lhs.m_dZ * rhs.m_dY;
        result.m_dY = lhs.m_dZ * rhs.m_dX - lhs.m_dX * rhs.m_dZ;
        result.m_dZ = lhs.m_dX * rhs.m_dY - lhs.m_dY * rhs.m_dX;
        return result;
    }

    inline double dot( A3DVector3dData const &lhs, A3DVector3dData const &rhs ) {
        return lhs.m_dX * rhs.m_dX + lhs.m_dY * rhs.m_dY + lhs.m_dZ * rhs.m_dZ;
    }
    
    inline double length2( A3DVector3dData const &v ) {
        return dot( v, v );
    }
    
    inline double length( A3DVector3dData const &v ) {
        return sqrt( length2( v ) );
    }
    
    inline A3DVector3dData& normalize( A3DVector3dData &v ) {
        v /= length( v );
        return v;
    }
    
    inline A3DVector3dData normalized( A3DVector3dData const &v ) {
        auto result = v;
        return normalize( result );
    }

    inline bool operator==(A3DVector3dData const &lhs, A3DVector3dData const &rhs ) {
        static auto const RESOLUTION = 1.e-9;
        return length( lhs - rhs ) < RESOLUTION;
    }

    inline bool operator!=(A3DVector3dData const &lhs, A3DVector3dData const &rhs ) {
        static auto const RESOLUTION = 1.e-9;
        return length( lhs - rhs ) > RESOLUTION;
    }
    
    inline A3DBoundingBoxData &include( A3DBoundingBoxData &bb, A3DVector3dData const &pt ) {
        bb.m_sMin.m_dX = std::min( bb.m_sMin.m_dX, pt.m_dX );
        bb.m_sMin.m_dY = std::min( bb.m_sMin.m_dY, pt.m_dY );
        bb.m_sMin.m_dZ = std::min( bb.m_sMin.m_dZ, pt.m_dZ );

        bb.m_sMax.m_dX = std::max( bb.m_sMax.m_dX, pt.m_dX );
        bb.m_sMax.m_dY = std::max( bb.m_sMax.m_dY, pt.m_dY );
        bb.m_sMax.m_dZ = std::max( bb.m_sMax.m_dZ, pt.m_dZ );
        
        return bb;
    }
    
    inline A3DVector3dData center( A3DBoundingBoxData const &bb ) {
        return bb.m_sMin + (bb.m_sMax - bb.m_sMin) * 0.5;
    }
}

#ifdef _MSC_VER
#pragma warning(pop)
#endif