WfCpp_AssignClassDeclsToFiles.cpp

#include "WfCpp.h"

namespace

{

namespace

workflow

{

namespace

cppcodegen

{

using

namespace

analyzer

;

using

namespace

collections

;

#define ASSIGN_INDEX_KEY(INDEX_DECL, INDEX_KEY, STRING_KEY) \

INDEX_DECL INDEX_KEY = globalDep.allTds.Keys().IndexOf(STRING_KEY); \

CHECK_ERROR(INDEX_KEY != -1, L"WfCppConfig::AssignClassDeclsToFiles()#Internal error.") \

/*********************************************************************** WfCppConfig::GenerateGlobalDep ***********************************************************************/

void

WfCppConfig

ExpandClassDeclGroup

(

Ptr

WfClassDeclaration

parent

GlobalDep

globalDep

) {

vint

index

classDecls

Keys

().

IndexOf

(

parent

Obj

());

(

index

== -

)

return

;

FOREACH(Ptr<WfClassDeclaration>, subDecl, classDecls.GetByIndex(index))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfClassDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

classDecls

GetByIndex

(

index

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfClassDeclaration

subDecl

;

__foreach_iterator__

(

subDecl

);)

{

ExpandClassDeclGroup

(

subDecl

globalDep

); }

auto

directChildren

From

(

classDecls

GetByIndex

(

index

)) .

Select

([&](

Ptr

WfClassDeclaration

decl

) {

auto

stringKey

manager

declarationTypes

[

decl

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(auto, indexKey, stringKey);

auto

indexKey

globalDep

allTds

Keys

().

IndexOf

(

stringKey

);

{

(!(

indexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

return

indexKey

; });

auto

indirectChildren

From

(

classDecls

GetByIndex

(

index

)) .

Select

([&](

Ptr

WfClassDeclaration

subDecl

) {

auto

stringKey

manager

declarationTypes

[

subDecl

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(auto, indexKey, stringKey);

auto

indexKey

globalDep

allTds

Keys

().

IndexOf

(

stringKey

);

{

(!(

indexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

return

globalDep

expandedClassDecls

Keys

().

IndexOf

(

indexKey

); }) .

Where

([](

vint

index

) {

return

index

!= -

; }) .

SelectMany

([&](

vint

index

) {

return

From

(

globalDep

expandedClassDecls

GetByIndex

(

index

)); });

vint

indexKey

= -

;

(

parent

) {

auto

stringKey

manager

declarationTypes

[

parent

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(, indexKey, stringKey);

indexKey

globalDep

allTds

Keys

().

IndexOf

(

stringKey

);

{

(!(

indexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

}

FOREACH(vint, subDecl, directChildren.Concat(indirectChildren))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

directChildren

Concat

(

indirectChildren

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

subDecl

;

__foreach_iterator__

(

subDecl

);)

{

globalDep

expandedClassDecls

Add

(

indexKey

subDecl

); } }

void

WfCppConfig

GenerateClassDependencies

(

GlobalDep

globalDep

) {

FOREACH_INDEXER(ITypeDescriptor*, td, tdIndex, globalDep.allTds.Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ITypeDescriptor

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

globalDep

allTds

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

tdIndex

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ITypeDescriptor

;

__foreach_iterator__

(

);

tdIndex

++)

{

vint

count

GetBaseTypeDescriptorCount

();

for

(

vint

;

count

;

++) {

auto

baseTd

GetBaseTypeDescriptor

(

);

vint

baseTdIndex

globalDep

allTds

Keys

().

IndexOf

(

baseTd

GetTypeName

());

(

baseTdIndex

!= -

) {

globalDep

dependencies

Add

(

tdIndex

baseTdIndex

); } } } }

void

WfCppConfig

GenerateGlobalDep

(

GlobalDep

globalDep

) {

FOREACH_INDEXER(ITypeDescriptor*, td, index, tdDecls.Keys())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

ITypeDescriptor

*>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

tdDecls

Keys

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

(

bool

__scope_variable_flag__

true

)

for

(

vint

index

;

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

ITypeDescriptor

;

__foreach_iterator__

(

);

index

++)

{

(

tdDecls

Values

()

[

index

Cast

WfClassDeclaration

>()) {

globalDep

allTds

Add

(

GetTypeName

(),

); } }

ExpandClassDeclGroup

(

nullptr

globalDep

);

GenerateClassDependencies

(

globalDep

); }

/*********************************************************************** WfCppConfig::GenerateClassLevelDep ***********************************************************************/

void

WfCppConfig

CollectExpandedDepGroup

(

vint

parentIndexKey

GlobalDep

globalDep

ClassLevelDep

classLevelDep

) {

const

auto

items

globalDep

expandedClassDecls

[

parentIndexKey

];

FOREACH(vint, subDecl, items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

subDecl

;

__foreach_iterator__

(

subDecl

);)

{

vint

index

globalDep

dependencies

Keys

().

IndexOf

(

subDecl

);

(

index

!= -

) {

FOREACH(vint, dep, globalDep.dependencies.GetByIndex(index))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

globalDep

dependencies

GetByIndex

(

index

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

dep

;

__foreach_iterator__

(

dep

);)

{

(

items

Contains

(

dep

)) {

classLevelDep

depGroup

Add

(

subDecl

dep

); } } } } }

void

WfCppConfig

CollectExpandedSubClass

(

vint

subDeclIndexKey

GlobalDep

globalDep

ClassLevelDep

classLevelDep

) {

classLevelDep

subClass

Add

(

subDeclIndexKey

);

vint

index

globalDep

expandedClassDecls

Keys

().

IndexOf

(

subDeclIndexKey

);

(

index

!= -

) {

FOREACH(vint, expandDecl, globalDep.expandedClassDecls.GetByIndex(index))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

vint

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

globalDep

expandedClassDecls

GetByIndex

(

index

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

vint

expandDecl

;

__foreach_iterator__

(

expandDecl

);)

{

classLevelDep

subClass

Add

(

expandDecl

subDeclIndexKey

); } } }

void

WfCppConfig

GenerateClassLevelDep

(

Ptr

WfClassDeclaration

parent

GlobalDep

globalDep

ClassLevelDep

classLevelDep

) {

classLevelDep

parentClass

parent

;

(

parent

) {

auto

parentStringKey

manager

declarationTypes

[

parent

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(, classLevelDep.parentIndexKey, parentStringKey);

classLevelDep

parentIndexKey

globalDep

allTds

Keys

().

IndexOf

(

parentStringKey

);

{

(!(

classLevelDep

parentIndexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

}

const

auto

items

globalDep

expandedClassDecls

[

classLevelDep

parentIndexKey

];

// for any specified class (or top level if nullptr)

// find all direct and indirect internal classes

// copy their dependencies, and generate sub classes by grouping them using the second level of classes

CollectExpandedDepGroup

(

classLevelDep

parentIndexKey

globalDep

classLevelDep

);

FOREACH(Ptr<WfClassDeclaration>, subDecl, classDecls.Get(parent.Obj()))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfClassDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

classDecls

Get

(

parent

Obj

()));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfClassDeclaration

subDecl

;

__foreach_iterator__

(

subDecl

);)

{

auto

subDeclStringKey

manager

declarationTypes

[

subDecl

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(auto, subDeclIndexKey, subDeclStringKey);

auto

subDeclIndexKey

globalDep

allTds

Keys

().

IndexOf

(

subDeclStringKey

);

{

(!(

subDeclIndexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

CollectExpandedSubClass

(

subDeclIndexKey

globalDep

classLevelDep

); } }

/*********************************************************************** WfCppConfig::Collect ***********************************************************************/

void

WfCppConfig

SortClassDecls

(

GlobalDep

globalDep

) {

// sort top level classes and all internal classes inside any classes

for

(

vint

classDecls

Count

() -

;

--) {

// for any specified class (or top level if nullptr)

// find all direct and indirect internal classes

// copy their dependencies, and generate sub classes by grouping them using the second level of classes

auto

parent

classDecls

Keys

()

[

];

ClassLevelDep

classLevelDep

;

GenerateClassLevelDep

(

parent

globalDep

classLevelDep

);

// sort them

PartialOrderingProcessor

pop

;

const

auto

items

globalDep

expandedClassDecls

[

classLevelDep

parentIndexKey

];

pop

InitWithSubClass

(

items

classLevelDep

depGroup

classLevelDep

subClass

);

pop

Sort

();

// using the partial ordering result to sort the corresponding value list in classDecls

{

auto

values

const_cast

List

Ptr

WfClassDeclaration

>>&>(

classDecls

GetByIndex

(

));

for

(

vint

;

pop

components

Count

();

++) {

auto

component

pop

components

[

];

// check error

(

component

nodeCount

) {

List

ITypeDescriptor

tds

;

for

(

vint

;

component

nodeCount

;

++) {

auto

node

pop

nodes

[

component

firstNode

[

]];

auto

indexKey

classLevelDep

subClass

[

items

[

node

firstSubClassItem

[

]]];

tds

Add

(

globalDep

allTds

Values

()

[

indexKey

]); }

Sort

ITypeDescriptor

*>(&

tds

[

tds

Count

(), [](

ITypeDescriptor

) {

return

WString

Compare

(

GetTypeName

(),

GetTypeName

()); });

manager

errors

Add

(

WfErrors

CppUnableToDecideClassOrder

(

tdDecls

[

tds

[

]].

Cast

WfClassDeclaration

>().

Obj

(),

tds

)); }

auto

node

pop

nodes

[

component

firstNode

[

]];

auto

subDeclIndexKey

classLevelDep

subClass

[

items

[

node

firstSubClassItem

[

]]];

auto

subDecl

tdDecls

[

globalDep

allTds

Values

()

[

subDeclIndexKey

]].

Cast

WfClassDeclaration

>();

values

[

]

subDecl

; } }

parent

manager

errors

Count

() ==

) {

for

(

vint

;

classLevelDep

subClass

Count

();

++) {

vint

index

classLevelDep

subClass

Values

()

[

];

globalDep

topLevelClasses

Contains

(

index

)) {

globalDep

topLevelClasses

Add

(

index

); } }

for

(

vint

;

pop

nodes

Count

();

++) {

auto

keyNode

pop

nodes

[

];

vint

keyIndex

classLevelDep

subClass

[

items

[

keyNode

firstSubClassItem

[

]]];

for

(

vint

;

keyNode

ins

Count

();

++) {

auto

valueNode

pop

nodes

[

keyNode

ins

Get

(

)];

vint

valueIndex

classLevelDep

subClass

[

items

[

valueNode

firstSubClassItem

[

]]];

globalDep

topLevelClassDep

Contains

(

keyIndex

valueIndex

)) {

globalDep

topLevelClassDep

Add

(

keyIndex

valueIndex

); } } } } } }

void

WfCppConfig

GenerateFileClassMaps

(

GlobalDep

globalDep

) {

(

classDecls

Keys

().

Contains

(

nullptr

)) {

PartialOrderingProcessor

popSubClass

;

Array

vint

customFirstItems

;

// popSubClass.nodes's index

Array

vint

nonCustomFirstItems

;

// popSubClass.nodes's index

Array

bool

isCustomItems

;

// popSubClass.nodes's index to boolean (true means custom item)

Group

vint

subClassDepGroup

;

// popSubClass.nodes's index to index

{

// generate sub class using @cpp:File

// globalDep.allTds.Keys()'s index to file name

Dictionary

vint

WString

subClass

;

for

(

vint

;

customFilesClasses

Count

();

++) {

WString

key

customFilesClasses

Keys

()

[

];

(

key

L""

) {

FOREACH(Ptr<WfClassDeclaration>, decl, customFilesClasses.GetByIndex(i))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfClassDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

customFilesClasses

GetByIndex

(

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfClassDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

auto

stringKey

manager

declarationTypes

[

decl

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(auto, indexKey, stringKey);

auto

indexKey

globalDep

allTds

Keys

().

IndexOf

(

stringKey

);

{

(!(

indexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

subClass

Add

(

indexKey

key

); } } }

// check if all components contains either all classes of the same @cpp:File or a single non-@cpp:File class

popSubClass

InitWithSubClass

(

globalDep

topLevelClasses

globalDep

topLevelClassDep

subClass

);

popSubClass

Sort

();

for

(

vint

;

popSubClass

components

Count

();

++) {

auto

component

popSubClass

components

[

];

// check error

(

component

nodeCount

) {

List

ITypeDescriptor

tds

;

for

(

vint

;

component

nodeCount

;

++) {

auto

node

popSubClass

nodes

[

component

firstNode

[

]];

for

(

vint

;

node

subClassItemCount

;

++) {

auto

indexKey

globalDep

topLevelClasses

[

node

firstSubClassItem

[

]];

tds

Add

(

globalDep

allTds

Values

()

[

indexKey

]); } }

Sort

ITypeDescriptor

*>(&

tds

[

tds

Count

(), [](

ITypeDescriptor

) {

return

WString

Compare

(

GetTypeName

(),

GetTypeName

()); });

manager

errors

Add

(

WfErrors

CppUnableToSeparateCustomFile

(

tdDecls

[

tds

[

]].

Cast

WfClassDeclaration

>().

Obj

(),

tds

)); } }

(

manager

errors

Count

() !=

) {

return

; }

// generate two item list, one have all @cpp:File classes put in front, one have all non-@cpp:File classes put in front

// popSubClass.nodes's index

{

List

vint

customItems

;

List

vint

nonCustomItems

;

// categorize popSubClass.nodes's index to customItems and nonCustomItems

for

(

vint

;

popSubClass

nodes

Count

();

++) {

auto

node

popSubClass

nodes

[

];

(

subClass

Keys

().

Contains

(

globalDep

topLevelClasses

[

node

firstSubClassItem

[

]])) {

customItems

Add

(

); }

else

{

nonCustomItems

Add

(

); } }

// sort items using allTds.Keys()'s index

auto

SortNodes

= [&](

List

vint

items

) {

(

items

Count

() >

) {

Sort

vint

>(&

items

[

items

Count

(), [&](

vint

) {

auto

nodeA

popSubClass

nodes

[

];

auto

nodeB

popSubClass

nodes

[

];

vint

indexA

From

(

nodeA

firstSubClassItem

nodeA

firstSubClassItem

nodeA

subClassItemCount

) .

Select

([&](

vint

index

) {

return

globalDep

topLevelClasses

[

index

]; }) .

Min

();

vint

indexB

From

(

nodeB

firstSubClassItem

nodeB

firstSubClassItem

nodeB

subClassItemCount

) .

Select

([&](

vint

index

) {

return

globalDep

topLevelClasses

[

index

]; }) .

Min

();

return

indexA

indexB

; }); } };

SortNodes

(

customItems

);

SortNodes

(

nonCustomItems

);

// prepare customFirstItems, nonCustomFirstItems and isCustomItems

isCustomItems

Resize

(

customItems

Count

() +

nonCustomItems

Count

());

for

(

vint

;

customItems

Count

();

++) {

isCustomItems

[

customItems

[

]] =

true

; }

for

(

vint

;

nonCustomItems

Count

();

++) {

isCustomItems

[

nonCustomItems

[

]] =

false

; }

CopyFrom

(

customFirstItems

customItems

);

CopyFrom

(

nonCustomFirstItems

nonCustomItems

);

CopyFrom

(

nonCustomFirstItems

customItems

true

);

CopyFrom

(

customFirstItems

nonCustomItems

true

); } }

// copy popSubClass's sub class dependencies to subClassDepGroup

for

(

vint

;

popSubClass

nodes

Count

();

++) {

auto

node

popSubClass

nodes

[

];

for

(

vint

;

node

ins

Count

();

++) {

subClassDepGroup

Add

(

node

ins

Get

(

)); } }

// sort using inputs of two orders

PartialOrderingProcessor

popCustomFirst

;

popCustomFirst

InitWithGroup

(

customFirstItems

subClassDepGroup

);

popCustomFirst

Sort

();

PartialOrderingProcessor

popNonCustomFirst

;

popNonCustomFirst

InitWithGroup

(

nonCustomFirstItems

subClassDepGroup

);

popNonCustomFirst

Sort

();

CHECK_ERROR(popCustomFirst.components.Count() == customFirstItems.Count(), L"WfCppConfig::AssignClassDeclsToFiles()#Internal error: Unexpected circle dependency found, this should have been caught by code above.");

{

(!(

popCustomFirst

components

Count

() ==

customFirstItems

Count

()))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error: Unexpected circle dependency found, this should have been caught by code above."

);}

while

(

);

CHECK_ERROR(popNonCustomFirst.components.Count() == nonCustomFirstItems.Count(), L"WfCppConfig::AssignClassDeclsToFiles()#Future error: Unexpected circle dependency found, this should have been caught by code above.");

{

(!(

popNonCustomFirst

components

Count

() ==

nonCustomFirstItems

Count

()))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Future error: Unexpected circle dependency found, this should have been caught by code above."

);}

while

(

);

CHECK_ERROR(popCustomFirst.components.Count() == popNonCustomFirst.components.Count(), L"WfCppConfig::AssignClassDeclsToFiles()#Future error: Unexpected circle dependency found, this should have been caught by code above.");

{

(!(

popCustomFirst

components

Count

() ==

popNonCustomFirst

components

Count

()))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Future error: Unexpected circle dependency found, this should have been caught by code above."

);}

while

(

);

// translate popCustomFirst's sorting result

// popSubClass.nodes's index

Array

vint

customFirstOrder

(

popCustomFirst

components

Count

());

for

(

vint

;

popCustomFirst

components

Count

();

++) {

auto

component

popCustomFirst

components

[

];

customFirstOrder

[

] =

customFirstItems

[

component

firstNode

[

]]; }

// translate popNonCustomFirst's sorting result

// popSubClass.nodes's index

Array

vint

nonCustomFirstOrder

(

popNonCustomFirst

components

Count

());

for

(

vint

;

popNonCustomFirst

components

Count

();

++) {

auto

component

popNonCustomFirst

components

[

];

nonCustomFirstOrder

[

] =

nonCustomFirstItems

[

component

firstNode

[

]]; }

// dispatch non-@cpp:File classes to non-@cpp:File headers

vint

currentHeaderIndex

;

vint

nonCustomFirstOrderPicked

;

vint

customFirstOrderPicked

;

Array

bool

visited

(

customFirstOrder

Count

());

for

(

vint

;

visited

Count

();

++) {

visited

[

] =

false

; }

auto

pickItems

= [&](

Array

vint

order

vint

picked

bool

customItem

) {

while

(

picked

order

Count

()) {

vint

item

order

[

picked

];

(

visited

[

item

]) {

picked

++; }

else

(

isCustomItems

[

item

] ==

customItem

) {

visited

[

item

] =

true

;

picked

++;

customItem

) {

auto

node

popSubClass

nodes

[

item

];

for

(

vint

;

node

subClassItemCount

;

++) {

auto

indexKey

globalDep

topLevelClasses

[

node

firstSubClassItem

[

]];

auto

globalDep

allTds

Values

()

[

indexKey

];

headerFilesClasses

Add

(

currentHeaderIndex

tdDecls

[

Cast

WfClassDeclaration

>()); } } }

else

{

break

; } } };

while

(

nonCustomFirstOrderPicked

nonCustomFirstOrder

Count

() ||

customFirstOrderPicked

customFirstOrder

Count

()) {

pickItems

(

nonCustomFirstOrder

nonCustomFirstOrderPicked

false

);

pickItems

(

customFirstOrder

customFirstOrderPicked

false

);

pickItems

(

nonCustomFirstOrder

nonCustomFirstOrderPicked

true

);

pickItems

(

customFirstOrder

customFirstOrderPicked

true

);

currentHeaderIndex

++; }

// calculate header includes

// globalDep.allTds.keys()'s index to header index

Dictionary

vint

headers

;

auto

addToHeaders

= [&](

const

List

Ptr

WfClassDeclaration

>>&

decls

vint

headerIndex

) {

FOREACH(Ptr<WfClassDeclaration>, decl, decls)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfClassDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

decls

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfClassDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

auto

stringKey

manager

declarationTypes

[

decl

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(auto, indexKey, stringKey);

auto

indexKey

globalDep

allTds

Keys

().

IndexOf

(

stringKey

);

{

(!(

indexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

headers

Add

(

indexKey

headerIndex

); } };

auto

calculateIncludes

= [&](

const

List

Ptr

WfClassDeclaration

>>&

decls

SortedList

vint

includes

) {

FOREACH(Ptr<WfClassDeclaration>, decl, decls)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfClassDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

decls

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfClassDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

auto

stringKey

manager

declarationTypes

[

decl

Obj

()]

GetTypeName

();

ASSIGN_INDEX_KEY(auto, indexKey, stringKey);

auto

indexKey

globalDep

allTds

Keys

().

IndexOf

(

stringKey

);

{

(!(

indexKey

!= -

))

throw

Error

(

L"WfCppConfig::AssignClassDeclsToFiles()#Internal error."

);}

while

(

);

vint

index

globalDep

topLevelClassDep

Keys

().

IndexOf

(

indexKey

);

(

index

!= -

) {

const

auto

values

globalDep

topLevelClassDep

GetByIndex

(

index

);

for

(

vint

;

values

Count

();

++) {

vint

headers

[

values

[

]];

(

header

&& !

includes

Contains

(

header

)) {

includes

Add

(

header

); } } } } };

for

(

vint

;

customFilesClasses

Count

();

++) {

(

customFilesClasses

Keys

()

[

]

L""

) {

addToHeaders

(

customFilesClasses

GetByIndex

(

); } }

for

(

vint

;

headerFilesClasses

Count

();

++) {

addToHeaders

(

headerFilesClasses

GetByIndex

(

), -

headerFilesClasses

Keys

()

[

]); }

for

(

vint

;

customFilesClasses

Count

();

++) {

(

customFilesClasses

Keys

()

[

]

L""

) {

SortedList

vint

includes

;

calculateIncludes

(

customFilesClasses

GetByIndex

(

includes

);

for

(

vint

;

includes

Count

();

++) {

headerIncludes

Add

(

includes

[

]); } } }

for

(

vint

;

headerFilesClasses

Count

();

++) {

(

headerFilesClasses

Keys

()

[

] !=

) {

SortedList

vint

includes

;

calculateIncludes

(

headerFilesClasses

GetByIndex

(

includes

);

for

(

vint

;

includes

Count

();

++) {

headerIncludes

Add

headerFilesClasses

Keys

()

[

includes

[

]); } } } } }

void

WfCppConfig

SortFileClassMaps

(

GlobalDep

globalDep

) {

// sort customFilesClasses and headerFilesClasses according to classDecls[nullptr]

(

classDecls

Keys

().

Contains

(

nullptr

)) {

List

Ptr

WfClassDeclaration

ordered

;

CopyFrom

(

ordered

classDecls

[

nullptr

]);

for

(

vint

;

customFilesClasses

Count

();

++) {

auto

values

const_cast

List

Ptr

WfClassDeclaration

>>&>(

customFilesClasses

GetByIndex

(

));

Sort

Ptr

WfClassDeclaration

>>(&

values

[

values

Count

(), [&](

Ptr

WfClassDeclaration

Ptr

WfClassDeclaration

) {

vint

aIndex

ordered

IndexOf

(

Obj

());

vint

bIndex

ordered

IndexOf

(

Obj

());

return

aIndex

bIndex

; }); }

for

(

vint

;

headerFilesClasses

Count

();

++) {

auto

values

const_cast

List

Ptr

WfClassDeclaration

>>&>(

headerFilesClasses

GetByIndex

(

));

Sort

Ptr

WfClassDeclaration

>>(&

values

[

values

Count

(), [&](

Ptr

WfClassDeclaration

Ptr

WfClassDeclaration

) {

vint

aIndex

ordered

IndexOf

(

Obj

());

vint

bIndex

ordered

IndexOf

(

Obj

());

return

aIndex

bIndex

; }); } } }

void

WfCppConfig

AssignClassDeclsToFiles

() {

GlobalDep

globalDep

;

GenerateGlobalDep

(

globalDep

);

(

manager

errors

Count

() ==

)

SortClassDecls

(

globalDep

);

(

manager

errors

Count

() ==

)

GenerateFileClassMaps

(

globalDep

);

(

manager

errors

Count

() ==

)

SortFileClassMaps

(

globalDep

); }

#undef ASSIGN_INDEX_KEY

} } }