Example #1
0
 /// <summary>
 /// Saves the settings.
 /// </summary>
 public override void SaveSettings()
 {
     Settings.Default.Reorganizing_MemberTypeClasses      = Classes.Serialize();
     Settings.Default.Reorganizing_MemberTypeConstructors = Constructors.Serialize();
     Settings.Default.Reorganizing_MemberTypeDelegates    = Delegates.Serialize();
     Settings.Default.Reorganizing_MemberTypeDestructors  = Destructors.Serialize();
     Settings.Default.Reorganizing_MemberTypeEnums        = Enums.Serialize();
     Settings.Default.Reorganizing_MemberTypeEvents       = Events.Serialize();
     Settings.Default.Reorganizing_MemberTypeFields       = Fields.Serialize();
     Settings.Default.Reorganizing_MemberTypeIndexers     = Indexers.Serialize();
     Settings.Default.Reorganizing_MemberTypeInterfaces   = Interfaces.Serialize();
     Settings.Default.Reorganizing_MemberTypeMethods      = Methods.Serialize();
     Settings.Default.Reorganizing_MemberTypeProperties   = Properties.Serialize();
     Settings.Default.Reorganizing_MemberTypeStructs      = Structs.Serialize();
 }
 public void AddMethod(ClassMethod method)
 {
     if (method.Type == ClassMethod.MethodType.Regular)
     {
         Methods.Add(method);
     }
     else if (method.Type == ClassMethod.MethodType.Constructor)
     {
         Constructors.Add(method);
     }
     else
     {
         Destructors.Add(method);
     }
 }
Example #3
0
        static int Main(string[] args)
        {
            // print args
            Console.WriteLine("Printing args...");
            foreach (string arg in args)
            {
                Console.WriteLine("Arg: " + arg);
            }
            Console.WriteLine();

            // run basic tests
            Console.WriteLine("Running tests...");
            Log(ClassNesting.RunTest(), "ClassNesting");
            Log(ClassVsStruct.RunTest(), "ClassVsStruct");
            Log(Enums.RunTest(), "Enums");
            Log(RefOutParameters.RunTest(), "RefOutParameters");
            Log(FieldsAndProperties.RunTest(), "FieldsAndProperties");
            Log(FlowControlAndEnumerators.RunTest(), "FlowControlAndEnumerators");
            Log(ExtensionMethods.RunTest(), "ExtensionMethods");
            Log(Destructors.RunTest(), "Destructors");
            Log(TryCatch.RunTest(), "TryCatch");
            Log(Interop.RunTest(), "Interop");
            Log(VirtualMethods.RunTest(), "VirtualMethods");
            Log(Generics.RunTest(), "Generics");
            Log(Delegates.RunTest(), "Delegates");
            Log(Indexers.RunTest(), "Indexers");
            Log(Operators.RunTest(), "Operators");
            Log(StringEncoding.RunTest(), "StringEncoding");
            Log(CoreGenericCollections.RunTest(), "CoreGenericCollections");
            Log(NewOverrides.RunTest(), "NewOverrides");
            Log(NumbersToStrings.RunTest(), "NumbersToStrings");
            Console.WriteLine("TESTS DONE!");

            // return result code
            return(99);
        }
Example #4
0
        public void Add(TLDefinition tld, Stream srcStm)
        {
            TLFunction tlf = tld as TLFunction;

            if (tlf != null)
            {
                if (IsConstructor(tlf.Signature, tlf.Class))
                {
                    Constructors.Add(tlf, srcStm);
                }
                else if (tlf.Signature is SwiftClassConstructorType)
                {
                    if (ClassConstructor.Values.Count() == 0)
                    {
                        ClassConstructor.Add(tlf, srcStm);
                    }
                    else
                    {
                        throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 12, $"multiple type metadata accessors for {tlf.Class.ClassName.ToFullyQualifiedName ()}");
                    }
                }
                else if (IsDestructor(tlf.Signature, tlf.Class))
                {
                    Destructors.Add(tlf, srcStm);
                }
                else if (IsProperty(tlf.Signature, tlf.Class))
                {
                    if (IsSubscript(tlf.Signature, tlf.Class))
                    {
                        if (IsPrivateProperty(tlf.Signature, tlf.Class))
                        {
                            PrivateSubscripts.Add(tlf);
                        }
                        else
                        {
                            Subscripts.Add(tlf);
                        }
                    }
                    else
                    {
                        if (IsStaticProperty(tlf.Signature, tlf.Class))
                        {
                            if (IsPrivateProperty(tlf.Signature, tlf.Class))
                            {
                                StaticPrivateProperties.Add(tlf, srcStm);
                            }
                            else
                            {
                                StaticProperties.Add(tlf, srcStm);
                            }
                        }
                        else
                        {
                            if (IsPrivateProperty(tlf.Signature, tlf.Class))
                            {
                                PrivateProperties.Add(tlf, srcStm);
                            }
                            else
                            {
                                Properties.Add(tlf, srcStm);
                            }
                        }
                    }
                }
                else if (IsMethodOnClass(tlf.Signature, tlf.Class))
                {
                    if (tlf is TLMethodDescriptor)
                    {
                        MethodDescriptors.Add(tlf, srcStm);
                    }
                    else
                    {
                        Methods.Add(tlf, srcStm);
                    }
                }
                else if (IsStaticMethod(tlf.Signature, tlf.Class))
                {
                    StaticFunctions.Add(tlf, srcStm);
                }
                else if (IsWitnessTable(tlf.Signature, tlf.Class))
                {
                    WitnessTable.Add(tlf, srcStm);
                }
                else if (IsInitializer(tlf.Signature, tlf.Class))
                {
                    Initializers.Add(tlf, srcStm);
                }
                else
                {
                    FunctionsOfUnknownDestination.Add(tlf);
                }
                return;
            }
            var meta = tld as TLDirectMetadata;

            if (meta != null)
            {
                if (DirectMetadata != null)
                {
                    throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 13, $"duplicate direct metadata in class {DirectMetadata.Class.ClassName.ToFullyQualifiedName ()}");
                }
                DirectMetadata = meta;
                return;
            }
            var lazy = tld as TLLazyCacheVariable;

            if (lazy != null)
            {
                if (LazyCacheVariable != null)
                {
                    throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 14, $"duplicate lazy cache variable in class {LazyCacheVariable.Class.ClassName.ToFullyQualifiedName ()}");
                }
                LazyCacheVariable = lazy;
                return;
            }
            var mc = tld as TLMetaclass;

            if (mc != null)
            {
                if (Metaclass != null)
                {
                    throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 15, $"duplicate type meta data descriptor in class {Metaclass.Class.ClassName.ToFullyQualifiedName ()}");
                }
                Metaclass = mc;
                return;
            }
            var nom = tld as TLNominalTypeDescriptor;

            if (nom != null)
            {
                if (TypeDescriptor != null)
                {
                    throw ErrorHelper.CreateError(ReflectorError.kInventoryBase + 16, $"duplicate nominal type descriptor in class {TypeDescriptor.Class.ClassName.ToFullyQualifiedName ()}");
                }
                TypeDescriptor = nom;
                return;
            }
            var tlvar = tld as TLVariable;

            if (tlvar != null)
            {
                if (tlvar is TLPropertyDescriptor tlpropDesc)
                {
                    PropertyDescriptors.Add(tlpropDesc);
                }
                else
                {
                    Variables.Add(tlvar, srcStm);
                }
                return;
            }
            var tlprot = tld as TLProtocolConformanceDescriptor;

            if (tlprot != null)
            {
                ProtocolConformanceDescriptors.Add(tlprot);
                return;
            }
            DefinitionsOfUnknownDestination.Add(tld);
        }