ECReportNode.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once

#include <DgnPlatform/XDataTreeManager.h>
#include <DgnPlatform/XDataTreeNode.h>
#include <DgnPlatform/XDataNodeCollection.h>
#include <DgnPlatform/TextTableHandler.h>
#include <DgnPlatform/DgnStoreHandlers.h>

DGNPLATFORM_TYPEDEFS(ECReportNode)
DGNPLATFORM_REF_COUNTED_PTR(ECReportNode)
DGNPLATFORM_TYPEDEFS(SortingGroupNode)
DGNPLATFORM_REF_COUNTED_PTR(SortingGroupNode)
DGNPLATFORM_TYPEDEFS(ColumnGroupNode)
DGNPLATFORM_REF_COUNTED_PTR(ColumnGroupNode)
DGNPLATFORM_TYPEDEFS(ReportDefinitionNode)
DGNPLATFORM_REF_COUNTED_PTR(ReportDefinitionNode)
DGNPLATFORM_TYPEDEFS(ReportCategoryNode)
DGNPLATFORM_REF_COUNTED_PTR(ReportCategoryNode)
DGNPLATFORM_TYPEDEFS(ColumnDefinitionNode)
DGNPLATFORM_REF_COUNTED_PTR(ColumnDefinitionNode)
DGNPLATFORM_TYPEDEFS(SortingRuleNode)
DGNPLATFORM_REF_COUNTED_PTR(SortingRuleNode)
DGNPLATFORM_TYPEDEFS(DgnECHost)
DGNPLATFORM_TYPEDEFS(DgnECHostIterable)
DGNPLATFORM_REF_COUNTED_PTR(DgnECHost)
DGNPLATFORM_TYPEDEFS(HostExpressionContext)
DGNPLATFORM_REF_COUNTED_PTR(HostExpressionContext)
DGNPLATFORM_TYPEDEFS(HostExpressionCriterion)
DGNPLATFORM_REF_COUNTED_PTR(HostExpressionCriterion)
DGNPLATFORM_TYPEDEFS(ReportResultsRow)
DGNPLATFORM_TYPEDEFS(ReportResultsIterator)
DGNPLATFORM_REF_COUNTED_PTR(ReportResultsIterator)
DGNPLATFORM_TYPEDEFS(ReportResults)
DGNPLATFORM_TYPEDEFS(ReportResultsEntry)
DGNPLATFORM_TYPEDEFS(DgnECHostSpecification)
DGNPLATFORM_TYPEDEFS(DgnECHostSpecificationsContext)
DGNPLATFORM_TYPEDEFS(DgnECHostRelationshipSpecification)
DGNPLATFORM_TYPEDEFS(ReportScope)
DGNPLATFORM_TYPEDEFS(ReportColumnAccessor)


BEGIN_BENTLEY_DGNPLATFORM_NAMESPACE

/*---------------------------------------------------------------------------------**/
enum class ECReportNodeType : UInt8
    {
    Unknown             = 0,        
    Category            = 1 << 0,   
    ReportDefinition    = 1 << 1,   
    ColumnGroup         = 1 << 2,   
    SortingGroup        = 1 << 3,   
    ColumnDefinition    = 1 << 4,   
    SortingRule         = 1 << 5,   
    };

typedef bvector<ECReportNodePtr>    ECReportNodeList;
typedef ECReportNodeList const*     ECReportNodeListCP;


/*---------------------------------------------------------------------------------**/
struct ECReportNode : XDataTreeNode
    {
    DEFINE_T_SUPER(XDataTreeNode)
public:
    DGNPLATFORM_EXPORT ECReportNodePtr          GetParentNode();
    DGNPLATFORM_EXPORT ECReportNodeCP           GetParentNode() const;
    DGNPLATFORM_EXPORT ECReportNodeType         GetNodeType() const;
    DGNPLATFORM_EXPORT ECReportNodeListCP       GetChildNodes() const;
    DGNPLATFORM_EXPORT ECReportNodePtr          GetChildByName (WCharCP name);
    DGNPLATFORM_EXPORT WString                  GetDisplayLabel() const;
    DGNPLATFORM_EXPORT DgnFileR                 GetDgnFile() const;
    DGNPLATFORM_EXPORT ReportDefinitionNodePtr  GetAssociatedReportDefinition() const;

    DGNPLATFORM_EXPORT static ECReportNodePtr   FindByElementId (ElementId elemId, DgnFileR dgnfile);
    DGNPLATFORM_EXPORT static ECReportNodePtr   FindByElementId (ElementId elemId, XDataTreeOwnerR owner);
    DGNPLATFORM_EXPORT static ECReportNodePtr   FromXDataTreeNode (XDataTreeNodeR node);
    };

/*---------------------------------------------------------------------------------**/
struct SortingRuleNode : ECReportNode
    {
private:
    SortingRuleNode();
public:
    DGNPLATFORM_EXPORT static SortingRuleNodePtr        From (ECReportNodeR node);

    DGNPLATFORM_EXPORT WCharCP         GetColumnName() const;
    DGNPLATFORM_EXPORT bool            IsAscending() const;
    DGNPLATFORM_EXPORT bool            IsCaseSensitive() const;
    DGNPLATFORM_EXPORT bool            ApplyBeforeFormatting() const;
    DGNPLATFORM_EXPORT bool            HideDuplicateValues() const;

    DGNPLATFORM_EXPORT bool            SetColumnName (WCharCP name);
    DGNPLATFORM_EXPORT bool            SetAscending (bool asc);
    DGNPLATFORM_EXPORT bool            SetCaseSensitive (bool cs);
    DGNPLATFORM_EXPORT bool            SetApplyBeforeFormatting (bool apply);
    DGNPLATFORM_EXPORT bool            SetHideDuplicateValues (bool hide);

    };

/*---------------------------------------------------------------------------------**/
struct ReportColumnAccessor
    {
    /*---------------------------------------------------------------------------------**/
    enum class ArrayOption : wchar_t
        {
        AllMembers      = L'*',     
        First           = L'^',     
        Last            = L'$',     
        Count           = L'#',     
        List            = L',',     
        None            = L'\0'     
        };

    /*---------------------------------------------------------------------------------**/
    struct ArrayAccessor
        {
        typedef ReportColumnAccessor::ArrayOption Option;
    private:
        WString         m_memberAccessor;
        Option          m_option;
    public:
        ArrayAccessor (WCharCP memberAccessor, ReportColumnAccessor::ArrayOption memberArrayOption = ArrayOption::None) : m_memberAccessor (memberAccessor), m_option (memberArrayOption) { }
        ArrayAccessor() : m_option (ReportColumnAccessor::ArrayOption::None) { }

        WCharCP                             GetAccessString() const { return m_memberAccessor.c_str(); }
        ReportColumnAccessor::ArrayOption   GetOption() const       { return m_option; }
        };

    typedef bvector<ArrayAccessor>      ArrayAccessorList;
private:
    ECN::QualifiedECAccessor            m_accessor;
    ArrayOption                         m_arrayOption;
    ArrayAccessorList                   m_arrayAccessors;
public:
    ReportColumnAccessor() : m_arrayOption (ArrayOption::None) { }
    ReportColumnAccessor (ECN::QualifiedECAccessorCR accessor, ArrayOption arrayOption = ArrayOption::None) : m_accessor (accessor), m_arrayOption (arrayOption) { }
    ReportColumnAccessor (WCharCP schemaName, WCharCP className, WCharCP accessString, ArrayOption arrayOption = ArrayOption::None) : m_accessor (schemaName, className, accessString), m_arrayOption (arrayOption) { }

    ECN::QualifiedECAccessorCR          GetAccessor() const         { return m_accessor; }
    ECN::QualifiedECAccessorR           GetAccessor()               { return m_accessor; }
    ArrayOption                         GetArrayOption() const      { return m_arrayOption; }
    ArrayAccessorList const&            GetArrayAccessors() const   { return m_arrayAccessors; }
    ArrayAccessorList&                  GetArrayAccessors()         { return m_arrayAccessors; }

    };

typedef bvector<ReportColumnAccessor>       ReportColumnAccessorList;
typedef ReportColumnAccessorList const&     ReportColumnAccessorListCR;

/*---------------------------------------------------------------------------------**/
struct ColumnDefinitionNode : ECReportNode
    {
private:
    ColumnDefinitionNode();
public:
    DGNPLATFORM_EXPORT static ColumnDefinitionNodePtr   From (ECReportNodeR node);

    DGNPLATFORM_EXPORT UInt32                       GetNumAccessors() const;
    DGNPLATFORM_EXPORT ReportColumnAccessorList     GetAccessors() const;
    DGNPLATFORM_EXPORT bool                         SetAccessors (ReportColumnAccessorListCR accessors);

    DGNPLATFORM_EXPORT ECN::IECInstancePtr          GetFormattingOptions (bool createIfNotFound);
    DGNPLATFORM_EXPORT ECN::IECInstanceCP           GetFormattingOptions() const;

    DGNPLATFORM_EXPORT ECN::IECInstancePtr          GetArraySortingOptions (bool createIfNotFound);
    DGNPLATFORM_EXPORT ECN::IECInstanceCP           GetArraySortingOptions() const;

    DGNPLATFORM_EXPORT WString                      GetListDelimiter() const;
    DGNPLATFORM_EXPORT bool                         SetListDelimiter (WCharCP delimiter);

    };

typedef bvector<SortingRuleNodePtr>             SortingRuleList;
typedef bvector<ColumnDefinitionNodePtr>        ColumnDefinitionList;
typedef SortingRuleList const*                  SortingRuleListCP;
typedef ColumnDefinitionList const*             ColumnDefinitionListCP;
typedef bvector<ECN::SchemaNameClassNamePair>   SchemaClassNameList;
typedef SchemaClassNameList const&              SchemaClassNameListCR;
typedef SchemaClassNameList&                    SchemaClassNameListR;

/*---------------------------------------------------------------------------------**/
struct DgnECHostRelationshipSpecification
    {
    /*---------------------------------------------------------------------------------**/
    enum Flags
        {
        kFlag_Required                  = 1 << 0,   
        kFlag_Backward                  = 1 << 1,   
        kFlag_RelatedPolymorphic        = 1 << 2,   
        kFlag_RelationshipPolymorphic   = 1 << 3,   

        kFlags_None                     = 0,        
        kFlags_Default                  = (kFlag_RelatedPolymorphic | kFlag_RelationshipPolymorphic)    
        };
private:
    ECN::SchemaNameClassNamePair        m_relationshipName;
    ECN::SchemaNameClassNamePair        m_relatedClassName;
    DgnECHostRelationshipSpecification* m_related;
    Flags                               m_flags;
    QueryRelatedClassSpecifierPtr       m_querySpec;

    bool                                GetFlag (Flags flag) const      { return 0 != (m_flags & flag); }
    void                                SetFlag (Flags flag, bool set)  { m_flags = (Flags)(set ? (m_flags | flag) : (m_flags & (~flag))); }

public:
    DGNPLATFORM_EXPORT DgnECHostRelationshipSpecification (ECN::SchemaNameClassNamePairCR relationship, ECN::SchemaNameClassNamePairCR related, ECN::ECRelatedInstanceDirection dir=ECN::STRENGTHDIRECTION_Forward,
                                               bool required=false, bool relationshipPolymorphic=true, bool relatedPolymorphic=true);
    DGNPLATFORM_EXPORT DgnECHostRelationshipSpecification (DgnECHostRelationshipSpecificationCR rhs);
    DgnECHostRelationshipSpecification() : m_related(nullptr), m_flags(kFlags_Default) { }
    DGNPLATFORM_EXPORT ~DgnECHostRelationshipSpecification();
    DGNPLATFORM_EXPORT DgnECHostRelationshipSpecification&  operator=(DgnECHostRelationshipSpecificationCR rhs);

    ECN::SchemaNameClassNamePairCR          GetRelationshipClass() const    { return m_relationshipName; }
    ECN::SchemaNameClassNamePairCR          GetRelatedClass() const         { return m_relatedClassName; }
    DgnECHostRelationshipSpecificationCP    GetNestedSpecification() const  { return m_related; }
    
    bool                            IsRequired() const                  { return GetFlag (kFlag_Required); }
    bool                            IsRelatedPolymorphic() const        { return GetFlag (kFlag_RelatedPolymorphic); }
    bool                            IsRelationshipPolymorphic() const   { return GetFlag (kFlag_RelationshipPolymorphic); }
    ECN::ECRelatedInstanceDirection GetDirection() const                { return GetFlag (kFlag_Backward) ? ECN::STRENGTHDIRECTION_Backward : ECN::STRENGTHDIRECTION_Forward; }

    void                    SetRelationshipClass (ECN::SchemaNameClassNamePairCR pair)          { m_relationshipName = pair; }
    void                    SetRelatedClass (ECN::SchemaNameClassNamePairCR pair)               { m_relatedClassName = pair; }
    DGNPLATFORM_EXPORT void SetNestedSpecification (DgnECHostRelationshipSpecificationCP spec);

    void        SetRequired (bool required)                                 { SetFlag (kFlag_Required, required); }
    void        SetRelationshipPolymorphic (bool poly)                      { SetFlag (kFlag_RelationshipPolymorphic, poly); }
    void        SetRelatedPolymorphic (bool poly)                           { SetFlag (kFlag_RelatedPolymorphic, poly); }
    void        SetDirection (ECN::ECRelatedInstanceDirection dir)          { SetFlag (kFlag_Backward, dir == ECN::STRENGTHDIRECTION_Backward); }

    };

typedef bvector<DgnECHostRelationshipSpecification>     DgnECHostRelationshipSpecificationList;
typedef DgnECHostRelationshipSpecificationList&         DgnECHostRelationshipSpecificationListR;
typedef DgnECHostRelationshipSpecificationList const&   DgnECHostRelationshipSpecificationListCR;

/*---------------------------------------------------------------------------------**/
struct DgnECHostSpecification
    {
private:
    SchemaClassNameList                     m_primaryClasses;
    DgnECHostRelationshipSpecificationList  m_relationships;
public:
    SchemaClassNameListCR                       GetPrimaryClasses() const   { return m_primaryClasses; }
    SchemaClassNameListR                        GetPrimaryClasses()         { return m_primaryClasses; }
    DgnECHostRelationshipSpecificationListCR    GetRelationships() const    { return m_relationships; }
    DgnECHostRelationshipSpecificationListR     GetRelationships()          { return m_relationships; }

    void    SetPrimaryClasses (SchemaClassNameListCR classes)               { m_primaryClasses = classes; }
    void    SetRelationships (DgnECHostRelationshipSpecificationListCR rels){ m_relationships = rels; }      

    };

typedef bvector<DgnECHostSpecification>     DgnECHostSpecificationList;
typedef DgnECHostSpecificationList&         DgnECHostSpecificationListR;
typedef DgnECHostSpecificationList const&   DgnECHostSpecificationListCR;

/*---------------------------------------------------------------------------------**/
struct DgnECHostSpecificationsContext
    {
private:
    DgnECHostSpecificationList  m_hostSpecs;
    DgnFileP                    m_currentDgnFile;

public:
    DGNPLATFORM_EXPORT DgnECHostSpecificationsContext (DgnECHostSpecificationListCR hostSpecs);
    };

/*---------------------------------------------------------------------------------**/
struct ReportScope
    {
public:
    /*---------------------------------------------------------------------------------**/
    enum class Type
        {
        Model       = 0,    
        File        = 1,    
        Path        = 2     
        };

    /*---------------------------------------------------------------------------------**/
    enum class ReferencedModelOption
        {
        All         = 0,    
        None        = 2     
        };
private:

    Type                    m_type;
    ReferencedModelOption   m_refOpt;
    bool                    m_includeChildElements;
    WString                 m_location;
    WString                 m_qualifier;
public:
    ReportScope() : m_type(Type::Model), m_refOpt(ReferencedModelOption::None), m_includeChildElements(false) { }

    DGNPLATFORM_EXPORT void     InitForPath (WCharCP cfgVarExpression);
    DGNPLATFORM_EXPORT void     InitForFile (DgnDocumentMonikerCP moniker);

    DGNPLATFORM_EXPORT void     InitForActiveModel(ReferencedModelOption refOpt = ReferencedModelOption::None);
    DGNPLATFORM_EXPORT void     InitForDefaultModel (DgnDocumentMonikerCP moniker, ReferencedModelOption refOpt = ReferencedModelOption::None);
    DGNPLATFORM_EXPORT void     InitForModel (WCharCP modelName, DgnDocumentMonikerCP moniker, ReferencedModelOption refOpt = ReferencedModelOption::None);

    Type                        GetType() const                     { return m_type; }
    WCharCP                     GetLocation() const                 { return m_location.c_str(); }
    WCharCP                     GetQualifier() const                { return m_qualifier.c_str(); }
    ReferencedModelOption       GetReferencedModelOption() const    { return m_refOpt; }
    bool                        IncludesChildElements() const       { return m_includeChildElements; }
    
    DgnDocumentMonikerPtr       GetMoniker (DgnFileR fileContainingReportDefinition) const;

    void                        SetReferencedModelOption (ReferencedModelOption opt)    { if (GetType() == Type::Model) m_refOpt = opt; }
    void                        SetIncludeChildElements (bool include)                  { m_includeChildElements = include; }
    };

/*---------------------------------------------------------------------------------**/
struct ReportDefinitionNode : ECReportNode
    {
private:
    typedef ReportScope::ReferencedModelOption ReferencedModelOption;

    ReportDefinitionNode();

public:
    DGNPLATFORM_EXPORT ReportScope::Type        GetScopeType() const;

    DGNPLATFORM_EXPORT bool                     IsReferenced() const;
    DGNPLATFORM_EXPORT ReportCategoryNodePtr    GetCategory() const;

    DGNPLATFORM_EXPORT ReportDefinitionNodePtr  Import (DgnFileR destinationFile, bool renameIfNecessary) const;

    DGNPLATFORM_EXPORT UInt32                   GetColumnCount() const;
    DGNPLATFORM_EXPORT ColumnGroupNodePtr       GetColumnGroupNode (bool createIfNotFound);
    DGNPLATFORM_EXPORT SortingGroupNodePtr      GetSortingGroupNode (bool createIfNotFound);
    DGNPLATFORM_EXPORT ColumnGroupNodeCP        GetColumnGroupNode() const;
    DGNPLATFORM_EXPORT SortingGroupNodeCP       GetSortingGroupNode() const;

    DGNPLATFORM_EXPORT ColumnDefinitionNodePtr  CreateColumnDefinition (WCharCP name, int sortPriority);
    DGNPLATFORM_EXPORT SortingRuleNodePtr       CreateSortingRule (WCharCP columnName, int sortPriority);

    DGNPLATFORM_EXPORT ColumnDefinitionNodeCP   GetColumnByName (WCharCP name) const;
    DGNPLATFORM_EXPORT ColumnDefinitionNodePtr  GetColumnByName (WCharCP name);

    DGNPLATFORM_EXPORT bool                     GetHostSpecifications (DgnECHostSpecificationListR specs) const;
    DGNPLATFORM_EXPORT bool                     SetHostSpecifications (DgnECHostSpecificationListCR specs);

    DGNPLATFORM_EXPORT ReportScope              GetScope() const;
    DGNPLATFORM_EXPORT bool                     SetScope (ReportScopeCR scope);

    DGNPLATFORM_EXPORT WString                  GetRowFilter() const;
    DGNPLATFORM_EXPORT bool                     SetRowFilter (WCharCP expr);

    DGNPLATFORM_EXPORT static ReportDefinitionNodePtr   FindById (ElementId id, DgnFileR dgnfile);
    DGNPLATFORM_EXPORT static ReportDefinitionNodePtr   FindByPath (WCharCP path, DgnFileR dgnfile);

    DGNPLATFORM_EXPORT static ReportDefinitionNodePtr   From (ECReportNodeR node);
    };

/*---------------------------------------------------------------------------------**/
struct ReportCategoryNode : ECReportNode
    {
private:
    ReportCategoryNode();
public:
    DGNPLATFORM_EXPORT static ReportCategoryNodePtr     Create (WCharCP name, int sortPriority, DgnFileR dgnfile);
    DGNPLATFORM_EXPORT static ReportCategoryNodePtr     From (ECReportNodeR node);
    DGNPLATFORM_EXPORT static ReportCategoryNodePtr     FindByName (WCharCP name, DgnFileR dgnfile);
    DGNPLATFORM_EXPORT ReportDefinitionNodePtr  CreateReportDefinition (WCharCP name, int sortPriority);

    DGNPLATFORM_EXPORT ReportDefinitionNodePtr  GenerateReportFromClass (ECN::ECClassCR ecClass, WCharCP name, int sortPriority = -1);
    };

/*---------------------------------------------------------------------------------**/
struct ColumnGroupNode : ECReportNode
    {
private:
    ColumnGroupNode();
public:
    DGNPLATFORM_EXPORT static ColumnGroupNodePtr    From (ECReportNodeR node);
    DGNPLATFORM_EXPORT ColumnDefinitionListCP   GetColumnDefinitions() const;
    DGNPLATFORM_EXPORT ColumnDefinitionNodePtr  CreateColumnDefinition (WCharCP name, int sortPriority);
    };

/*---------------------------------------------------------------------------------**/
struct SortingGroupNode : ECReportNode
    {
private:
    SortingGroupNode();
public:
    DGNPLATFORM_EXPORT static SortingGroupNodePtr   From (ECReportNodeR node);

    DGNPLATFORM_EXPORT SortingRuleListCP        GetSortingRules() const;
    DGNPLATFORM_EXPORT SortingRuleNodeCP        GetRuleForColumn (WCharCP columnName) const;
    DGNPLATFORM_EXPORT SortingRuleNodePtr       CreateSortingRule (WCharCP columnName, int priority);
    };

/*---------------------------------------------------------------------------------**/
struct DgnECHost : RefCountedBase
    {
    };

/*---------------------------------------------------------------------------------**/
struct DgnECHostIterable
    {
    struct const_iterator : std::iterator<std::forward_iterator_tag, DgnECHost>
        {
        friend struct DgnECHostIterable;
    private:
        DgnECInstanceIterable::const_iterator       m_impl;
        DgnECHostPtr                                m_host;
        DgnECHostIterable const&                    m_iterable;

        const_iterator (DgnECHostIterable const& iterable, bool isEnd)
            : m_impl(isEnd ? iterable.m_primaryInstances.end() : iterable.m_primaryInstances.begin()), m_iterable(iterable)
                {
                CreateHost();
                }

    DGNPLATFORM_EXPORT void CreateHost();
    public:
        const_iterator (const_iterator const& other)
            : m_impl(other.m_impl), m_host(other.m_host), m_iterable(other.m_iterable) { }

        DgnECHostR              operator*() const { BeAssert (m_host.IsValid()); return *m_host; }
        DgnECHostP              operator->() const { return &(**this); }
        bool                    operator== (const_iterator const& rhs) const { return &m_iterable == &rhs.m_iterable && m_impl == rhs.m_impl; }
        bool                    operator!= (const_iterator const& rhs) const { return !(*this == rhs); }
        const_iterator&         operator++() { ++m_impl; CreateHost(); return *this; }
        };

    typedef const_iterator      iterator;
private:
    friend struct const_iterator;

    DgnECInstanceIterable                   m_primaryInstances;
    mutable DgnECHostSpecificationsContext  m_context;
public:
    DgnECHostIterable (DgnECInstanceIterable primaryInstances, DgnECHostSpecificationsContextCR context)
        : m_primaryInstances(primaryInstances), m_context(context) { }

    const_iterator              begin() const   { return const_iterator (*this, false); }
    const_iterator              end() const     { return const_iterator (*this, true); }
    bool                        empty() const   { return m_primaryInstances.empty(); }
    };

/*---------------------------------------------------------------------------------**/
struct HostExpressionContext : ECN::InstanceListExpressionContext
    {
    };

/*---------------------------------------------------------------------------------**/
struct HostExpressionCriterion : ECExpressionCriterion
    {
    DGNPLATFORM_EXPORT static HostExpressionCriterionPtr    Create (WCharCP expressionString, WCharCP hostSymbolName, DgnECHostSpecificationsContextCR hostSpecContext);
    };

/*---------------------------------------------------------------------------------**/
struct ReportResultsEntry
    {
private:
    WString                 m_content;
    WString                 m_instanceId;
    ECN::ECValue            m_value;
    ReportColumnAccessorCP  m_accessor;
    WString                 m_sourceFileName;
public:
    ReportResultsEntry();
    // Returns the string value of this entry
    WStringCR               GetContent() const { return m_content; }
    // Returns the ID of the IECInstance from which this entry's value was obtained
    WStringCR               GetSourceInstanceId() const { return m_instanceId; }
    // Returns the ReportColumnAccessor by which this entry's value was obtained from the IECInstance
    ReportColumnAccessorCP  GetSourceAccessor() const { return m_accessor; }
    // Returns the value of the underlying type. Useful for e.g. sorting or comparing numeric or date properties.
    // If the underlying property has units they will have been applied.
    ECN::ECValueCR          GetValue() const { return m_value; }
    // Returns the name of the DgnFile from which this entry's IECInstance originated
    WStringCR               GetSourceFileName() const { return m_sourceFileName; }
    };

/*---------------------------------------------------------------------------------**/
struct ReportResultsRow : bvector<ReportResultsEntry> { };

/*---------------------------------------------------------------------------------**/
struct ReportResultsIterator : RefCountedBase, std::iterator<std::forward_iterator_tag, ReportResultsRow const>
    {
public:
    typedef ReportResultsRowCR reference;

    virtual bool                IsDifferent (ReportResultsIterator const& rhs) const = 0;
    virtual void                MoveToNext() = 0;
    virtual reference           GetCurrent() const = 0;
    };

/*---------------------------------------------------------------------------------**/
struct ReportResults
    {
    typedef VirtualCollectionIterator<ReportResultsIterator>    const_iterator;
    typedef const_iterator                                      iterator;

private:
    ReportDefinitionNodeCR              m_reportDefinition;
    DgnModelP                           m_defaultModel;
    DgnECHostIterable                   m_hosts;
    bvector<ReportColumnAccessorList>   m_accessorsByColumnIndex;
    bool                                m_allowHideRepeatedValues;
public:
    DGNPLATFORM_EXPORT ReportResults(ReportDefinitionNodeCR reportDef, DgnModelP defaultModel);

    ReportDefinitionNodeCR      GetReportDefinition() const             { return m_reportDefinition; }
    bool                        AllowHideRepeatedValues() const         { return m_allowHideRepeatedValues; }
    void                        SetAllowHideRepeatedValues (bool allow) { m_allowHideRepeatedValues = allow; }

    DGNPLATFORM_EXPORT const_iterator   begin() const;
    DGNPLATFORM_EXPORT const_iterator   end() const;

    DGNPLATFORM_EXPORT bool     WriteToCsv (BeTextFileR file) const;
    };

/*---------------------------------------------------------------------------------**/
struct ReportDefinitionCollectionIterator : std::iterator<std::forward_iterator_tag, ReportDefinitionNodeP const>
    {
private:
    friend struct ReportDefinitionCollection;

    XDataNodeCollection                     m_categories;
    XDataNodeCollection                     m_definitions;
    XDataNodeCollection::const_iterator     m_curCategory;
    XDataNodeCollection::const_iterator     m_curDefinition;

    DGNPLATFORM_EXPORT ReportDefinitionCollectionIterator (XDataTreeOwnerP owner, bool isEnd);
public:
    DGNPLATFORM_EXPORT ReportDefinitionCollectionIterator (ReportDefinitionCollectionIterator const& other);
    DGNPLATFORM_EXPORT ReportDefinitionCollectionIterator();

    DGNPLATFORM_EXPORT ReportDefinitionCollectionIterator&  operator++();
    DGNPLATFORM_EXPORT ReportDefinitionNodeP                operator*() const;
                       ReportDefinitionNodeP                operator->() const { return this->operator*(); }
    DGNPLATFORM_EXPORT bool                                 operator== (ReportDefinitionCollectionIterator const& other) const;
                       bool                                 operator!= (ReportDefinitionCollectionIterator const& other) const { return !(*this == other); }
    };

/*---------------------------------------------------------------------------------**/
struct ReportDefinitionCollection
    {
private:
    XDataTreeOwnerP         m_owner;
public:
    DGNPLATFORM_EXPORT ReportDefinitionCollection (DgnFileR dgnfile);
    DGNPLATFORM_EXPORT ReportDefinitionCollection();

    typedef ReportDefinitionCollectionIterator const_iterator;
    typedef const_iterator iterator;

    const_iterator          begin() const   { return ReportDefinitionCollectionIterator (m_owner, false); }
    const_iterator          end() const     { return ReportDefinitionCollectionIterator (m_owner, true); }
    };

END_BENTLEY_DGNPLATFORM_NAMESPACE