index.cpp

//==================================================================================================
// This implementation-file is part of DoxygenXLinks - A doxygen post-processor that allows to
// define smarter <b>Doxygen</b>-links.
//
// \emoji :copyright: 2025-2026 A-Worx GmbH, Germany.
// Published under \ref mainpage_license "Boost Software License".
//==================================================================================================
 
#include "jobs.hpp"
#include "index.hpp"
#include "dxl.hpp"
#include "xlink.hpp"
#include "ALib.Containers.StringTreeIterator.H"
#include "ALib.System.H"
 
using namespace alib;
using namespace std;
 
namespace dxl {
 
bool  IndexLoader::Do()                                               { index.Load(); return true; }
 
// create the file name from the path
Index::Index(const PathString& tagFilePath, const String& baseURL, bool isMainTagFile )
: TreeType{ma, '@'}
, ma  {ALIB_DBG("DL Index", ) 1024, 200}
, entityMap    {ma}
, fileMap      {ma}
, anchorMap    {ma}
, FilePath     {tagFilePath}
, BaseURL      {baseURL}
, IsMainTagFile{isMainTagFile}  {
 
    #if ALIB_DEBUG_CRITICAL_SECTIONS
    nodeTable.dcs.DCSLock= &SLock;
    entityMap.dcs.DCSLock= &SLock;
    fileMap  .dcs.DCSLock= &SLock;
    anchorMap.dcs.DCSLock= &SLock;
    #endif
 
    ConstructRootValue(Target::GetRootNodeTarget());
 
    // create the file name from the path
    FileName= tagFilePath;
    integer slashPos= std::max(FileName.LastIndexOf('/'), FileName.LastIndexOf('\\'));
    if (slashPos > 0)
        FileName= FileName.Substring(slashPos+1);
 
    // split file-name by dots
    fileNameDotComponentsSize= 0;
    String backwardsParser= FileName;
    for (;;) {
        integer dotPos= backwardsParser.LastIndexOf('.');
        if (dotPos < 0) {
            fileNameDotComponents[fileNameDotComponentsSize++]= backwardsParser;
            break;
        }
        fileNameDotComponents[fileNameDotComponentsSize++]= backwardsParser.Substring(dotPos + 1);
        backwardsParser= backwardsParser.Substring(0, dotPos);
}   }
 
Index::~Index() {
    #if ALIB_DEBUG_CRITICAL_SECTIONS
    nodeTable.dcs.DCSLock= nullptr;
    entityMap.dcs.DCSLock= nullptr;
    fileMap  .dcs.DCSLock= nullptr;
    anchorMap.dcs.DCSLock= nullptr;
    #endif
    DestructRootValue();
    entityMap.Reset();
    fileMap  .Reset();
    anchorMap.Reset();
    Reset();
}
 
void Index::Load() {  // ReSharper disable CppDFAUnreachableCode
 
  ALIB_LOCK_WITH(SLock)
    Ticks startTime;
 
    // load the file
    loadTagFile();
 
    // count types
    StringTreeIterator<Index::TreeType> entityIterator;
    entityIterator.SetPathGeneration(lang::Switch::Off);
    entityIterator.Initialize(Root(), lang::Inclusion::Exclude);
    while (entityIterator.IsValid()) {
        KindStats.Add(Node(entityIterator.Node()).Kind());
        entityIterator.Next();
    }
 
    // reserve spaces
    entityMap   .Reserve(Size(), lang::ValueReference::Absolute);
 
    int expectedFileMapSize  = 0;
    int expectedAnchorMapSize= 0;
    expectedFileMapSize=     KindStats.Get(Target::Namespace  )
                           + KindStats.Get(Target::Struct     )
                           + KindStats.Get(Target::Class      )
                           + KindStats.Get(Target::Union      )
                           + KindStats.Get(Target::Concept    )
                           + KindStats.Get(Target::Page       )
                           + KindStats.Get(Target::File       )
                           + KindStats.Get(Target::Dir        );
 
    expectedAnchorMapSize=   KindStats.Get(Target::Macro      )
                           + KindStats.Get(Target::Typedef    )
                           + KindStats.Get(Target::Variable   )
                           + KindStats.Get(Target::Function   )
                           + KindStats.Get(Target::Enumeration)
                           + KindStats.Get(Target::EnumElement)
                           + KindStats.Get(Target::DocAnchor  );
 
    fileMap     .Reserve(expectedFileMapSize   , lang::ValueReference::Absolute );
    anchorMap   .Reserve(expectedAnchorMapSize , lang::ValueReference::Absolute );
 
 
    // loop over all entities and fill hashtables  entityMap, fileMap, and anchorMap
    entityIterator.SetPathGeneration(lang::Switch::On);
    entityIterator.Initialize(Root(), lang::Inclusion::Exclude);
    while (entityIterator.IsValid()) {
        Substring name= entityIterator.Node().Name();
        Target& tag= *entityIterator.Node().Value();
 
 
        // add an entry in the file-map for records, concepts, modules and namespaces
        if (tag.IsA(  Target::RECORD| Target::Concept| Target::Namespace
                    | Target::Page  | Target::File   | Target::Dir)) {
            fileMap.EmplaceUnique( tag.HTMLFile, entityIterator.Node().Export() );
        }
 
        // Note: We do not read modules, as of today, Doxygen obviously puts the wrong
        //       filename into the tag file. It seems to be the filename of the
        //       module-interface file (i.e. *.ixx) that defines the module instead of the
        //       module page. Otherwise, it had to go to the filemap as well. But we must not
        //       do it due to the uniqueness of the key.
        //       See other notes tagged DOXYMODFILENAME.
 
 
        // add Members to the anchor-map
        else if (auto* member= Cast<TGTMember>(&tag); member ) {
            auto result= anchorMap.InsertIfNotExistent(
                AnchorKey{ tag.HTMLFile, member->Anchor },
                entityIterator.Node().Export()  );
            if ( !result.second ) {
                Lox_Info( "In HTML file {!Q}, the anchor {!Q} already exists. (Skipped)\n"
                             "  Previous anchor: {}:{}  Kind: {:10} FileName: {}\n"
                             "  New anchor:      {}:{}  Kind: {:10} FileName: {}"
                    ,tag.HTMLFile, member->Anchor
                    , FilePath, ImportNode(result.first.Mapped()).LineNo()
                              , ImportNode(result.first.Mapped()).Kind()
                              , ImportNode(result.first.Mapped()).HTMLFile()
                    , FilePath, tag.LineNo, tag.Kind(), tag.HTMLFile
                    )
        }   }
        // add DocAnchors in the anchor-map used with local links for members
        else if (auto* docAnchor= Cast<TGTDocAnchor>(&tag); docAnchor ) {
            auto result= anchorMap.InsertIfNotExistent(
                AnchorKey{ tag.HTMLFile, docAnchor->Name },
                entityIterator.Node().Export()  );
            if ( !result.second ) {
                Lox_Warning( "In HTML file {!Q}, the DocAnchor {!Q} already exists. (Skipped)\n"
                                "  Previous anchor: {}:{}  Kind: {:10} FileName: {}\n"
                                "  New anchor:      {}:{}  Kind: {:10} FileName: {}"
                    ,tag.HTMLFile, docAnchor->Name
                    , FilePath, ImportNode(result.first.Mapped()).LineNo()
                              , ImportNode(result.first.Mapped()).Kind()
                              , ImportNode(result.first.Mapped()).HTMLFile()
                    , FilePath, tag.LineNo, tag.Kind(), tag.HTMLFile
                    )
        }   }
 
        // cut template specialization args from record names
        if (auto* scu= Cast<TGTRecord>(&tag); scu) {
            if ( scu->SpecializationArgs ) {
                integer bracePos= name.IndexOf('<');
                if (bracePos>0) {
                    name= name.Substring(0, bracePos);
                    name.TrimEnd();
            }   }
            ALIB_ASSERT_ERROR(name.IndexOf('<') < 0, "DXL/XLINK",
                "Parse error (only specialization args should appear in the name and those "
                "have been removed already.")
        }
 
        // cut parameters from function names
        else if ( auto* mf= Cast<TGTFunction>(&tag); mf ) {
            if (   mf->Args
                || mf->Qualifiers.IsNotEmpty() ) {
                integer bracePos= name.LastIndexOf('(');
                if ( bracePos > 0)
                    name= name.Substring(0, bracePos);
        }   }
 
        entityMap.Insert( {name, entityIterator.Node().Export()} );
        entityIterator.Next();
    }
 
    ALIB_ASSERT_ERROR(entityMap.Size() == Size(), "DXL/XLINK",
      "Expected size of entityMap {} != {} real size.", Size()               , entityMap.Size())
 
    ALIB_ASSERT_ERROR(expectedFileMapSize == fileMap.Size(), "DXL/XLINK",
      "Expected size of fileMap   {} != {} real size.", expectedFileMapSize  ,   fileMap.Size())
 
    ALIB_ASSERT_ERROR(expectedAnchorMapSize >= anchorMap.Size(), "DXL/XLINK",
      "Expected size of anchorMap {} < {} real size.", expectedAnchorMapSize, anchorMap.Size())
 
    LoadTime= startTime.Age();
 
} // ReSharper restore CppDFAUnreachableCode
 
Index::ConstCursorHandle Index::GetHTMLFileEntity(const FTFile& htmlFile) {
    ALIB_LOCK_SHARED_WITH(SLock)
    auto it= fileMap.Find(htmlFile.Name());
    if ( it == fileMap.end()) {
        Lox_Warning( "HTML-File {!Q} not found in index: ", htmlFile.Name() )
        return CursorHandle(0);
    }
    return it->second;
}
 
void  Index::ReplaceToTreeSeparator(AString& buffer, Target::Kinds kind, integer startPos) {
    if ( HasOneOf(kind, Target::Dir | Target::File | Target::FILEPATH_COMPONENT) )
        buffer.SearchAndReplace(DIRECTORY_SEPARATOR, Separator(), startPos);
    else
        buffer.SearchAndReplace( "::", String8(Separator()), startPos);
}
 
void  Index::ReplaceFromTreeSeparator(AString& buffer, Target::Kinds kind, integer startPos) {
    if ( buffer.CharAt(startPos) == Separator() )
        buffer.Delete(startPos, 1);
    if ( HasOneOf(kind, Target::Dir | Target::File | Target::FILEPATH_COMPONENT) )
        buffer.SearchAndReplace(Separator(), DIRECTORY_SEPARATOR);
    else
        buffer.SearchAndReplace(String8(Separator()), "::");
 
}
bool Index::ScopeHintMatch(Index::Node entry, XLink& searchLink) {
    if ( searchLink.HintsSize() == 0 )
        return true;
 
    // build path stack from string tree
    int stackSize= 0;
    String  pathNameStack[32];
    auto parent= entry.Parent();
    while (!parent.IsRoot()) {
        pathNameStack[stackSize++]= parent.Name();
        parent= parent.Parent();
    }
    for (int i= 0; i < fileNameDotComponentsSize; ++i)
        pathNameStack[stackSize++]= fileNameDotComponents[i];
 
    // add tag-file name
    {
        PathString tagFileName= entry.Index().FileName;
 
        for (;;) {
            integer dotPos= tagFileName.LastIndexOf('.');
            if (dotPos < 0) {
                pathNameStack[stackSize++]= tagFileName;
                break;
            }
            pathNameStack[stackSize++]= tagFileName.Substring(dotPos + 1);
            tagFileName= tagFileName.Substring(0, dotPos);
    }   }
 
 
    // search hints in the path-stack
    int     stackPointer= stackSize-1;
    integer pos= 0;
    int hintNo = 0;
    for (;;) {
        pos=  pathNameStack[stackPointer].IndexOf<CHK, lang::Case::Ignore>(
                                                           searchLink.Hint(hintNo), pos );
        if ( pos >= 0 ) {
            if (  ++hintNo == searchLink.HintsSize())
                return true;
            pos= pos + searchLink.Hint(hintNo).Length();
            continue;
        }
 
        if ( --stackPointer < 0)
            return false;
        pos= 0;
}   }
 
void Index::searchFile( XLink&  xLink ) {
    if (xLink.KindSpec != Target::File || !xLink.NoIndirectionWarning )
    {ALIB_LOCK_SHARED_WITH(SLock)
        for ( auto range= entityMap.EqualRange(xLink.Name()) ;
              range.first!=range.second ;
              ++range.first) {
            Node node= ImportNode(range.first->second);
            // String256 dbgPath;
            // node.AssemblePath(dbgPath);
            if ( !node.IsA(Target::File |Target::Dir) )
                continue;
 
            xLink.DidYouMeanSameName.emplace_back(node);
 
          //-------------------------------------- check scope -------------------------------------
          // check parent scope components (those attached with "::" to the target name. Have to match exactly)
            if ( xLink.ScopeSize() ) {
                Node parent= node.Parent();
                bool foundParentScope= true;
                for (int i= xLink.ScopeSize() - 1; i>= 0 ; --i) {
                    String componentName= xLink.Scope(i);
                    if (   !parent.IsValid() || !parent.Name().Equals(componentName) ) {
                        foundParentScope= false;
                        break;
                    }
                    parent= parent.Parent();
                }
 
                if (!foundParentScope)
                    continue;
            }
 
            // check path hints
            // (those prepended separated by a space to the target path. Substring match is enough)
            if (!ScopeHintMatch(node, xLink))
                continue;
 
            // check kind
            // (The first check is probably not needed, as only if the typespec is given, we search
            // for files and folders. But let's keep it in.)
            if (    xLink.KindSpec != Target::UNSPECIFIED
                &&  xLink.KindSpec != node.Kind() )
                continue;
 
            // add result
            xLink.Targets.push_back({  node
                                     ,BaseURL
                                     , node.HTMLFile()
                                     ,EMPTY_STRING
                                     ,0,false,false,false,false,false,false
                                   });
        }
    } // unlock index
 
    // dedup group entries (this is also done with other search methods)
    if (xLink.Targets.size() > 1)
        dedupGroupEntries(xLink.Targets);
}
 
void Index::evaluateEntity( XLink& xLink, Node node,
                            bool isIndirectByInheritance, bool isIndirectByTypeDef ) {
    const Target* target= node.Target();
 
    //------- searching a function, but the entry is not a function or a definition? ----
    if ( xLink.Args ) {
        if ( !target->IsA(Target::Function | Target::Macro) )
            return;
        xLink.DidYouMeanFunctionOverload.emplace_back(node);
    }
 
    //------ searching an array variable, but the entry is not a variable? ------
    if ( xLink.Subscript!=nullptr) {
        auto* var= Cast<TGTVariable>(target);
        if (!var)
            return;
        if (var->Subscript.IndexOf(xLink.Subscript) < 0) {
            xLink.DidYouMeanVariable.push_back(node);
            return;
    }   }
 
  //------------------------------------ searching template type? ----------------------------------
    if ( xLink.TemplateArgs) {
        // result is not a template?
        auto* rec= Cast<TGTRecord>(target);
        if ( !rec) {
            xLink.DidYouMeanNotATemplate.push_back(node);
            return;
        }
        if (!rec->TemplateArgs) {
            xLink.DidYouMeanNotATemplate.push_back(node);
            return;
        }
 
        // args don't match?
        int match= xLink.TemplateArgs->Match(*rec->TemplateArgs);
        if ( match == 0) {
            xLink.DidYouMeanTemplateType= node;
            return;
    }   }
 
  //------------------------------- searching template specialization? -----------------------------
    if ( xLink.SpecializationArgs) {
        // result is not a specialization?
        auto* rec= Cast<TGTRecord>(target);
        if ( !rec) {
            xLink.DidYouMeanSpecializations.push_back(node);
            return;
        }
        if (!rec->SpecializationArgs) {
            xLink.DidYouMeanSpecializations.push_back(node);
            return;
        }
 
        // args don't match?
        int match= xLink.SpecializationArgs->Match(*rec->SpecializationArgs);
        if ( match == 0) {
            xLink.DidYouMeanSpecializations.push_back(node);
            return;
    }   }
 
  //------------------------------ "Typedef in inner path" erasion rule ----------------------------
  // 1. Skip this result if it is "just" a typedef and a deeper object exists
    bool skipThis= false;
    if ( target->IsA(Target::Typedef) )
        for (auto& it : xLink.Targets ) {
            if ( it.Node.IsA(Target::RECORD | Target::Enumeration) ) {
 
                Node parent = it.Node.Parent();
                while (parent.IsValid()) {
                    if (parent == node.Parent()) {
                        skipThis= true;
                        break;
                    }
                    parent= parent.Parent();
            }   }
            if (skipThis) break;
        }
 
    if ( skipThis ) return;
 
    // 2. Erase an existing result if it is "just" a typedef while this is a deeper object
    if ( target->IsA(Target::RECORD | Target::Enumeration) )
        std::erase_if(xLink.Targets, [&](const auto& it) {
            if ( !it.Node.IsA(Target::Typedef) )
                return false;
            Node parent = node.Parent();
            while (parent.IsValid()) {
                if ( parent == it.Node.Parent())
                    return true;
                parent= parent.Parent();
            }
            return false; // Keep this result
        });
 
 
  //------------------------------ "Prefer outer entities" erasion rule ----------------------------
  // 1. Remove existing results that are children of this one
    std::erase_if(xLink.Targets, [&,node](const auto& it) {
        Node parent = it.Node.Parent();
        while (parent.IsValid()) {
            if (parent == node)
                return true; // Delete this result
            parent = parent.Parent();
        }
        return false; // Keep this result
    });
 
    // 2. Skip this result if it is a child of one of the others.
    for (auto& it : xLink.Targets) {
        Node parent = node.Parent();
        while (parent.IsValid()) {
            if (parent == it.Node) {
                skipThis= true;
                break;
            }
            parent= parent.Parent();
        }
        if (skipThis) break;
    }
    if (skipThis) return;
 
 
  //------------------------------------ check function arguments ----------------------------------
    int funcArgMatch= 1;
    if ( target->IsA(Target::Function | Target::Macro) ) {
        // with functions, we can use the MATCH method directly
        if ( target->IsA(Target::Function) )
            funcArgMatch= Target::FunctionArguments::MATCH( xLink.Args,
                                                            Cast<TGTFunction,NC>(target)->Args );
 
        // with definitions, we have to check if the target is a prepro macro or a
        // prepro constant
        else {
            auto* targetArgs= Cast<TGTMacro,NC>(target)->Args;
            if ( xLink.Args && !targetArgs)
                funcArgMatch= 0;
            else
                funcArgMatch= Target::FunctionArguments::MATCH(xLink.Args, targetArgs);
        }
 
        if ( funcArgMatch == 0)
            return;
 
        // check if one had a better result before.
        bool hasBetterMatch= false;
        std::erase_if(xLink.Targets, [&](const auto& it) {
            if ( it.FunctionArgumentMatch < funcArgMatch)
                return true;
            if ( it.FunctionArgumentMatch > funcArgMatch)
                hasBetterMatch= true;
            return false;
        });
 
        if ( hasBetterMatch)
            return;
    }
 
    // check qualifiers
    bool qualifiersHintMatch= false;
    if (xLink.Qualifiers.IsNotNull()) {
        if (    !target->IsA(Target::Function)
             || Cast<TGTFunction,NC>(target)->Qualifiers.IndexOf(xLink.Qualifiers) < 0)
            return;
        qualifiersHintMatch= true;
 
        // remove functions that did not match in respect to Qualifiers
        std::erase_if(xLink.Targets, [&,node](const auto& it) {
            return    it.Node.IsA(Target::Function)
                   && Cast<TGTFunction,NC>(it.Node)->Qualifiers.IsEmpty();
        });
    }
    else {
        if ( auto* func= Cast<TGTFunction>(target); func ) {
            if ( func->Qualifiers.IsNotEmpty()) {
                bool hasBetterMatch= false;
                for ( auto& it : xLink.Targets) {
                    if ( auto* f= Cast<TGTFunction>(it.Node); f ) {
                        hasBetterMatch= f->Qualifiers.IsEmpty();
                        break;
                }   }
                if ( hasBetterMatch)
                    return;
            }
            else // todo: the case where no qualifiers are given is now resolved later in dxl
                 //       disambiguation. So this can be deleted I guess (have a try)
                 //       In general: we have to check again what goes where best.
                std::erase_if(xLink.Targets, [&,node](const auto& it) {
                    return   it.Node.IsA(Target::Function)
                          && Cast<TGTFunction,NC>(it.Node)->Qualifiers.IsNotEmpty();
                });
 
    }   }
 
    // rule: Template class beats deduction guide if no function args are given
    {
        std::erase_if(xLink.Targets, [&](const auto& it) {
 
            // within the same scope?
            if ( it.Node.Parent() == node.Parent() ) {
                if (target->IsA(Target::RECORD)) {
                    if (   it.Node.IsA(Target::Function)
                        && xLink.Args==nullptr)
                        return true;
            }   }
 
            return false;
        });
    }
 
 
    // add result
    xLink.Targets.push_back({ node
                             ,BaseURL
                             ,target->HTMLFile
                             ,  target->IsA(Target::MEMBER)    ? Cast<TGTMember   ,NC>(target)->Anchor
                              : target->IsA(Target::DocAnchor) ? Cast<TGTDocAnchor,NC>(target)->Name
                                                               : EMPTY_STRING
                             ,funcArgMatch
                             ,qualifiersHintMatch
                             ,isIndirectByInheritance
                             ,isIndirectByTypeDef
                             ,false ,false, false
                           });
 
}
 
//--------------------------------------------------------------------------------------------------
//---------------------------------------------- Search --------------------------------------------
//--------------------------------------------------------------------------------------------------
void Index::Search( XLink& xLink ) {
    // special treatment for files
    if ( HasOneOf(xLink.KindSpec, Target::Dir | Target::File) ) {
        searchFile(xLink);
        return;
    }
 
  //--------------------------- loop over all entities of the target name --------------------------
  // first we collect the results. Otherwise, we have a problem with recursive locking,
  // because when resolving the possible entities, recursive searches in all indices might
  // occur. (Currently this is done for example with GetLinkToParent())
    LocalAllocator1K la;
    StdVectorMA<CursorHandle> results(la);
    results.reserve(1024/sizeof(CursorHandle) - 4);
    {ALIB_LOCK_SHARED_WITH(SLock)
        for ( auto range= entityMap.EqualRange( xLink.Name()) ; range.first!=range.second ; ++range.first)
            results.push_back(range.first->second);
    }
 
    for ( auto handle : results ) {
 
        // get cursor and check if it is a real target
        Node node= ImportNode(handle);
        if (   node.IsA(Target::UNKNOWN_COMPOUND)
            || node.IsA(Target::FILEPATH_COMPONENT) )
            continue;
 
        // store in general "did you mean..." list
        xLink.DidYouMeanSameName.emplace_back(node);
 
        // check if kind is specified and if so, whether it fits
        if (   xLink.KindSpec != Target::UNSPECIFIED
            && !HasOneOf(xLink.KindSpec, node.Kind() ) )
            continue;
 
      //---------------------------------------- check scope ---------------------------------------
        bool scopeMatches= true;
        {
            Node parent= node.Parent();
 
            // check parent scope components
            if ( xLink.ScopeSize() ) {
                int fileNameComponentIdx= -1;
                for (int i= xLink.ScopeSize() - 1; i>= 0 ; --i) {
                    String componentName= xLink.Scope(i);
                    integer templatePos= componentName.IndexOf('<');
                    if ( templatePos > 0 )
                        componentName= componentName.Substring(0, templatePos);
 
                    if ( !parent.IsRoot() ) {
                        if ( !componentName.Equals( parent.Name() ) ) {
                            scopeMatches= false;
                            break;
                        }
                        parent= parent.Parent();
                    } else {
                        if (    ++fileNameComponentIdx >= fileNameDotComponentsSize
                             || !componentName.Equals( fileNameDotComponents[fileNameComponentIdx] ) ){
                            scopeMatches= false;
                            break;
            }   }   }       }
            if ( scopeMatches && xLink.IsLocal)
                scopeMatches &= (parent.Export().value == xLink.LocalLinkEntity.value);
 
            // check path hints
            // (those prepended separated by a space to the target path. Substring match is enough)
            scopeMatches= scopeMatches && ScopeHintMatch(node, xLink);
        }
 
        // if the scope matched, we give it a chance
        if ( scopeMatches )
            evaluateEntity(xLink, node, false, false); // if it fits, the node is added to the XLink's Targets.
    } // loop over all entities
 
    // if we now have exactly one match, we stop here.
    if (xLink.Targets.size() == 1)
        return;
 
  //--------- wrong scope? Search for inherited members and Type definition target's members -------
    if ( xLink.ScopeSize() || xLink.IsLocal ) {
        // get the parent XLink. This call also creates the vector link.BaseTypes
        xLink.GetLinkToParent();
 
      //------------------------- loop over all entities of the target name ------------------------
        for ( auto cursorHandle : results ) {
            Node  node   = ImportNode(cursorHandle);
 
          //----------- check inheritance: is the current node a member of a parent type? ----------
            if ( xLink.BaseTypes )
                for (Node& inheritanceParent : *xLink.BaseTypes) {
                    if (inheritanceParent == node.Parent())
                        evaluateEntity(xLink, node, true, false);
            }
 
          //--------------------- if not inherited, check if it is through a type ------------------
            if ( xLink.TypeDefinitionTargets)
                for (auto& typeDefTarget : *xLink.TypeDefinitionTargets) {
                    if (typeDefTarget == node.Parent() )
                        evaluateEntity(xLink, node, false, true);
            }
        } // loop over entities
    } // XLink has outer scope
 
 
    // finally dedup group entries (this is also done with other search methods)
    if (xLink.Targets.size() > 1)
        dedupGroupEntries(xLink.Targets);
}
 
void   Index::dedupGroupEntries( StdVectorMA<SearchResult>& targets ) {
 
    bool hasNonGroupResults= false;
    for (auto& it : targets)
        if (     it.Node.Parent().IsRoot()
             || !it.Node.Parent().IsA(Target::Group)   ) {
            hasNonGroupResults= true;
            break;
        }
    if ( hasNonGroupResults)
        std::erase_if(targets, [](const auto& it) {
            return     !it.Node.Parent().IsRoot()
                    && it.Node.Parent().IsA(Target::Group);
        });
}
 
} //namespace [dxl]