BillOfMaterial.hpp File Reference

Go to the source code of this file.

Data Structures
struct	BomEntry

Functions
void	CreateBomForMainDoc (Dtk_MainDocPtr inMainDoc, Dtk_tab< BomEntry > &outBomEntries)
void	PrintBom (const Dtk_tab< BomEntry > &inBomEntries)
void	PrintBomSummary (const Dtk_tab< BomEntry > &inBomEntries)
void	TraverseBom (Dtk_ComponentPtr inComponent, Dtk_tab< BomEntry > &outBomEntries, Dtk_Int32 inDepth=0)

Function Documentation

CreateBomForMainDoc()

void CreateBomForMainDoc	(	Dtk_MainDocPtr	inMainDoc,
		Dtk_tab< BomEntry > &	outBomEntries
	)

{
     Dtk_ComponentPtr rootComponent = inMainDoc->RootComponent();
     if( rootComponent.IsNULL() )
     {
          std::cout << "Warning: document has no root component." << std::endl;
          
     }
     else
     {
          TraverseBom( rootComponent, outBomEntries, 0 );
     }
}

PrintBom()

void PrintBom

(

const Dtk_tab< BomEntry > &

inBomEntries

)

{
    std::cout << std::endl;
    std::cout << "Bill of Materials" << std::endl;
    std::cout << "-----------------" << std::endl;
 
    if (inBomEntries.size() == 0)
    {
        std::cout << "  (no components found)" << std::endl;
        return;
    }
 
    for (Dtk_Size_t i = 0; i < inBomEntries.size(); ++i)
    {
        const BomEntry &entry  = inBomEntries[i];
        const Dtk_Int32 depth  = entry.depth;
 
        // Build the prefix: one "|   " per ancestor level, then "|-- " for the branch.
        std::string prefix;
        for (Dtk_Int32 d = 0; d < depth - 1; ++d)
            prefix += "|   ";
        if (depth > 0)
            prefix += "|-- ";
 
        std::cout << prefix;
 
        // Print instance name if available.
        if (entry.instanceName.is_not_NULL() && entry.instanceName.len() > 0)
            std::cout << "[" << entry.instanceName.c_str() << "]  ->  ";
 
        std::cout << entry.partName.c_str();
 
        // Append availability tags.
        if (entry.isMissing)
            std::cout << "  [MISSING]";
 
        std::cout << std::endl;
    }
}

PrintBomSummary()

void PrintBomSummary

(

const Dtk_tab< BomEntry > &

inBomEntries

)

{
    std::cout << std::endl;
    std::cout << "Summary (flattened occurrence count)" << std::endl;
    std::cout << "------------------------------------" << std::endl;
 
    if (inBomEntries.size() == 0)
    {
        std::cout << "  (no components found)" << std::endl;
        return;
    }
 
    // Accumulate per part name: occurrence count and availability flags.
    std::map<std::string, int>  countMap;
    std::map<std::string, bool> missingMap;
 
    for (Dtk_Size_t i = 0; i < inBomEntries.size(); ++i)
    {
        const BomEntry &entry = inBomEntries[i];
        std::string key = entry.partName.is_not_NULL() ? entry.partName.c_str() : "(unnamed)";
        countMap[key]++;
        if (entry.isMissing)
            missingMap[key] = true;
    }
 
    // Print the table header.
    std::cout << "  Part Name                          | Count | Status" << std::endl;
    std::cout << "  ---------------------------------- | ----- | --------------------" << std::endl;
 
    for (std::map<std::string, int>::const_iterator it = countMap.begin();
         it != countMap.end(); ++it)
    {
        const std::string &key = it->first;
 
        // Left-align the part name in a 34-character field.
        std::string name = key;
        if (name.size() > 34)
            name = name.substr(0, 31) + "...";
 
        std::cout << "  ";
        std::cout << name;
        for (size_t pad = name.size(); pad < 34; ++pad)
            std::cout << ' ';
 
        // Count column (5 chars wide).
        std::cout << " | ";
        std::string countStr = std::to_string(it->second);
        for (size_t pad = countStr.size(); pad < 5; ++pad)
            std::cout << ' ';
        std::cout << countStr;
 
        // Status column.
        std::cout << " | ";
        bool hasMissing = missingMap.count(key) > 0;
        if (hasMissing )
               std::cout << "  [MISSING]";
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

TraverseBom()

void TraverseBom	(	Dtk_ComponentPtr	inComponent,
		Dtk_tab< BomEntry > &	outBomEntries,
		Dtk_Int32	inDepth = 0
	)

{
    if (inComponent.IsNULL())
        return;
 
    Dtk_Component::ComponentTypeEnum type = inComponent->ComponentType();
 
    if (type == Dtk_Component::InstanceComponentType)
    {
        // An instance holds a placement (transformation) and references a prototype.
        Dtk_string instanceName = inComponent->InstanceName();
 
        // The prototype is the first (and only) child of an instance.
        if (inComponent->GetNumChildren() > 0)
        {
            Dtk_ComponentPtr prototype = inComponent->GetChild(0);
            if (prototype.IsNotNULL())
            {
                BomEntry entry;
                entry.partName             = prototype->Name();
                entry.instanceName         = instanceName;
                entry.depth                = inDepth;
                entry.occurrenceCount      = 1;
                entry.isMissing            = prototype->IsAvailabilityFlaggedAs(Dtk_Component::ComponentMissing)            == DTK_TRUE;
                outBomEntries.push_back(entry);
 
                // Only recurse into the prototype's children if it is not missing.
                if (!entry.isMissing)
                    TraverseBom(prototype, outBomEntries, inDepth + 1);
            }
        }
    }
    else if (type == Dtk_Component::PrototypeComponentType)
    {
        // A prototype may have sub-components (instances of sub-parts).
        Dtk_Size_t numChildren = inComponent->GetNumChildren();
        for (Dtk_Size_t i = 0; i < numChildren; ++i)
        {
            TraverseBom(inComponent->GetChild(i), outBomEntries, inDepth);
        }
    }
    else if (type == Dtk_Component::CatalogComponentType)
    {
        // A catalog holds multiple alternative configurations.
        // Only the activated children contribute to the BOM; if none are activated
        // the default child is used.
        Dtk_Size_t numChildren = inComponent->GetNumChildren();
        if (numChildren > 0)
        {
            Dtk_tab<Dtk_Int32> activatedIndices = inComponent->GetActivatedChildrenInCatalog();
            if (activatedIndices.size() > 0)
            {
                for (Dtk_Size_t i = 0; i < activatedIndices.size(); ++i)
                {
                    TraverseBom(inComponent->GetChild(activatedIndices[i]), outBomEntries, inDepth);
                }
            }
            else
            {
                // Fall back to the default child.
                Dtk_Int32 defaultIndex = inComponent->GetDefaultChildInCatalog();
                if (defaultIndex >= 0 && static_cast<Dtk_Size_t>(defaultIndex) < numChildren)
                {
                    TraverseBom(inComponent->GetChild(defaultIndex), outBomEntries, inDepth);
                }
            }
        }
    }
    else if (type == Dtk_Component::VirtualComponentType)
    {
        // A virtual component is a transparent grouping node with no geometry of
        // its own. Traverse all its children without adding a BOM entry.
        Dtk_Size_t numChildren = inComponent->GetNumChildren();
        for (Dtk_Size_t i = 0; i < numChildren; ++i)
        {
            TraverseBom(inComponent->GetChild(i), outBomEntries, inDepth);
        }
    }
}