예제 #1
0
 internal ProjectionBuilder(
     ICatalogReader catalogReader,
     IMappingReader mappingReader,
     IDiagnosticsCallback diagnosticsCallbackProxy)
 {
     _catalogReader            = catalogReader;
     _mappingReader            = mappingReader;
     _diagnosticsCallbackScope = new DiagnosticsCallbackScope(diagnosticsCallbackProxy);
 }
예제 #2
0
        private void LoadFile(IMappingReader reader)
        {
            loadTime = 0;
            LoadTimer timer = new LoadTimer("File Parsing");

            reader.Load();

            loadTime += timer.Stop();
            timer     = new LoadTimer("Items Processing");

            modules.Clear();
            namespaces.Clear();
            namespacesObfuscated.Clear();
            classes.Clear();
            classesCache.Clear();
            haveSystemEntities = false;
            methodsCount       = classesCount = subclassesCount = skippedCount = 0;

            List <RenamedClass> subclasses = new List <RenamedClass>();

            foreach (IMappingEntity entity in reader.Entities)
            {
                if (entity.Type == EntityType.Resource)
                {
                    RenamedResource resource = new RenamedResource(entity);
                    resources.Add(resource);
                    continue;
                }

                RenamedClass c = new RenamedClass(entity, this);
                classesCount++;

                if (c.SkipReason != null)
                {
                    skippedCount++;
                }

                if (c.OwnerClassName == null)
                {
                    classes.Add(c);
                    if (c.Name.NameOld != null && c.Name.NameOld.Namespace != null)
                    {
                        haveSystemEntities |= c.Name.NameOld.Namespace.StartsWith("System.");
                    }
                }
                else
                {
                    subclasses.Add(c);
                }

                methodsCount += c.MethodsCount;

                if (c.ModuleNew != null)
                {
                    modules.Add(c.ModuleNew);
                }
                if (c.Name.NameOld != null)
                {
                    classesCache[c.NameOld]     = c;
                    classesCache[c.NameOldFull] = c;

                    if (!string.IsNullOrEmpty(c.Name.NameOld.Namespace))
                    {
                        namespaces.Add(c.Name.NameOld.Namespace);
                    }
                }
                if (c.Name.NameNew != null)
                {
                    classesCache[c.NameNew]     = c;
                    classesCache[c.NameNewFull] = c;

                    if (!string.IsNullOrEmpty(c.Name.NameNew.Namespace))
                    {
                        namespacesObfuscated.Add(c.Name.NameNew.Namespace);
                    }
                }
            }

            loadTime += timer.Stop();
            timer     = new LoadTimer("Subclasses Processing");

            foreach (RenamedClass subclass in subclasses)
            {
                RenamedClass c;
                if (classesCache.TryGetValue(subclass.OwnerClassName, out c))
                {
                    c.Items.Add(subclass);
                    subclass.OwnerClass = c;
                    subclassesCount++;
                    continue;
                }

                Debug.WriteLine("Failed to find root class: " + subclass.OwnerClassName);
                classes.Add(subclass);
            }

            loadTime += timer.Stop();
            timer     = new LoadTimer("Values Updating");

            foreach (RenamedClass c in classes)
            {
                c.UpdateNewNames(this);
            }

            loadTime += timer.Stop();
            Debug.WriteLine("Total Elapsed: {0} ms", loadTime);
        }