/// <summary>
/// Initializes a new instance of the <see cref="TransformManager"/> class.
/// </summary>
public TransformManager(
GlobalNamespaceProvider globalNamespace,
NamingRulesManager namingRules,
Logger logger,
TypeRegistry typeRegistry,
IDocumentationLinker docLinker,
ConstantManager constantManager,
AssemblyManager assemblyManager)
{
GlobalNamespace = globalNamespace;
Logger = logger;
NamingRules = namingRules;
this.docLinker = docLinker;
this.typeRegistry = typeRegistry;
this.constantManager = constantManager;
this.assemblyManager = assemblyManager;
namespaceRegistry = new NamespaceRegistry(logger, assemblyManager);
marshalledElementFactory = new MarshalledElementFactory(Logger, GlobalNamespace, typeRegistry);
EnumTransform = new EnumTransform(namingRules, logger, namespaceRegistry, typeRegistry);
StructTransform = new StructTransform(namingRules, logger, namespaceRegistry, typeRegistry, marshalledElementFactory);
FunctionTransform = new MethodTransform(namingRules, logger, groupRegistry, marshalledElementFactory, globalNamespace, typeRegistry);
InterfaceTransform = new InterfaceTransform(namingRules, logger, globalNamespace, FunctionTransform, FunctionTransform, typeRegistry, namespaceRegistry);
}
private void ProcessMappings(CppElementFinder elementFinder, ConfigFile file)
{
// Perform all mappings from <mappings> tag
foreach (var configRule in file.Mappings)
{
var ruleUsed = false;
if (configRule is MappingRule mappingRule)
{
if (mappingRule.Enum != null)
{
ruleUsed = elementFinder.ExecuteRule <CppEnum>(mappingRule.Enum, mappingRule);
}
else if (mappingRule.EnumItem != null)
{
ruleUsed = elementFinder.ExecuteRule <CppEnumItem>(mappingRule.EnumItem, mappingRule);
}
else if (mappingRule.Struct != null)
{
ruleUsed = elementFinder.ExecuteRule <CppStruct>(mappingRule.Struct, mappingRule);
}
else if (mappingRule.Field != null)
{
ruleUsed = elementFinder.ExecuteRule <CppField>(mappingRule.Field, mappingRule);
}
else if (mappingRule.Interface != null)
{
ruleUsed = elementFinder.ExecuteRule <CppInterface>(mappingRule.Interface, mappingRule);
}
else if (mappingRule.Function != null)
{
ruleUsed = elementFinder.ExecuteRule <CppFunction>(mappingRule.Function, mappingRule);
}
else if (mappingRule.Method != null)
{
ruleUsed = elementFinder.ExecuteRule <CppMethod>(mappingRule.Method, mappingRule);
}
else if (mappingRule.Parameter != null)
{
ruleUsed = elementFinder.ExecuteRule <CppParameter>(mappingRule.Parameter, mappingRule);
}
else if (mappingRule.Element != null)
{
ruleUsed = elementFinder.ExecuteRule <CppElement>(mappingRule.Element, mappingRule);
}
else if (mappingRule.DocItem != null)
{
docLinker.AddOrUpdateDocLink(mappingRule.DocItem, mappingRule.MappingNameFinal);
ruleUsed = true;
}
}
else if (configRule is ContextRule contextRule)
{
HandleContextRule(elementFinder, file, contextRule);
ruleUsed = true;
}
else if (configRule is RemoveRule removeRule)
{
if (removeRule.Enum != null)
{
ruleUsed = RemoveElements <CppEnum>(elementFinder, removeRule.Enum);
}
else if (removeRule.EnumItem != null)
{
ruleUsed = RemoveElements <CppEnumItem>(elementFinder, removeRule.EnumItem);
}
else if (removeRule.Struct != null)
{
ruleUsed = RemoveElements <CppStruct>(elementFinder, removeRule.Struct);
}
else if (removeRule.Field != null)
{
ruleUsed = RemoveElements <CppField>(elementFinder, removeRule.Field);
}
else if (removeRule.Interface != null)
{
ruleUsed = RemoveElements <CppInterface>(elementFinder, removeRule.Interface);
}
else if (removeRule.Function != null)
{
ruleUsed = RemoveElements <CppFunction>(elementFinder, removeRule.Function);
}
else if (removeRule.Method != null)
{
ruleUsed = RemoveElements <CppMethod>(elementFinder, removeRule.Method);
}
else if (removeRule.Parameter != null)
{
ruleUsed = RemoveElements <CppParameter>(elementFinder, removeRule.Parameter);
}
else if (removeRule.Element != null)
{
ruleUsed = RemoveElements <CppElement>(elementFinder, removeRule.Element);
}
}
else if (configRule is MoveRule moveRule)
{
ruleUsed = true;
if (moveRule.Struct != null)
{
StructTransform.MoveStructToInner(moveRule.Struct, moveRule.To);
}
else if (moveRule.Method != null)
{
InterfaceTransform.MoveMethodsToInnerInterface(moveRule.Method, moveRule.To, moveRule.Property, moveRule.Base);
}
}
if (!ruleUsed)
{
Logger.Warning(LoggingCodes.UnusedMappingRule, "Mapping rule [{0}] did not match any elements.", configRule);
}
}
}
