public ParameterSetDefinitionTranslation(
     MethodInfo method,
     ITranslationSettings settings)
     : this((MethodBase)method, settings)
 {
     if (method.IsExtensionMethod())
     {
         _isExtensionMethod = true;
         TranslationSize   += "this ".Length;
         FormattingSize    += settings.GetKeywordFormattingSize();
     }
 }
        public PropertyDefinitionTranslation(
            PropertyInfo property,
            MethodInfo[] accessors,
            ITranslationSettings settings)
        {
            _accessibility = GetAccessibility(property);
            _modifiers     = GetModifiers(accessors[0]);

            _propertyTypeTranslation =
                new TypeNameTranslation(property.PropertyType, settings);

            _propertyName = property.Name;

            var translationSize =
                _accessibility.Length +
                _modifiers.Length +
                _propertyTypeTranslation.TranslationSize +
                _propertyName.Length;

            var keywordFormattingSize = settings.GetKeywordFormattingSize();

            var formattingSize =
                keywordFormattingSize + // <- For modifiers
                _propertyTypeTranslation.FormattingSize;

            if (property.DeclaringType != null)
            {
                _declaringTypeNameTranslation =
                    new TypeNameTranslation(property.DeclaringType, settings);

                translationSize += _declaringTypeNameTranslation.TranslationSize + ".".Length;
                formattingSize  += _declaringTypeNameTranslation.FormattingSize;
            }

            _accessorTranslations = new ITranslatable[accessors.Length];

            for (var i = 0; i < accessors.Length; ++i)
            {
                var accessorTranslation =
                    new PropertyAccessorDefinitionTranslation(this, accessors[i], settings);

                translationSize += accessorTranslation.TranslationSize;
                formattingSize  += accessorTranslation.FormattingSize;

                _accessorTranslations[i] = accessorTranslation;
            }

            TranslationSize = translationSize;
            FormattingSize  = formattingSize;
        }
        public TypeDefinitionTranslation(Type type, ITranslationSettings settings)
        {
            _accessibility        = GetAccessibility(type);
            _modifiers            = GetModifiers(type);
            _typeNameTranslatable = new TypeNameTranslation(type, settings);

            TranslationSize =
                _accessibility.Length +
                _modifiers.Length +
                _typeNameTranslatable.TranslationSize;

            FormattingSize =
                settings.GetKeywordFormattingSize() + // <- For modifiers
                _typeNameTranslatable.FormattingSize;
        }
        public ConstructorDefinitionTranslation(
            ConstructorInfo ctor,
            ITranslationSettings settings)
        {
            _accessibility         = GetAccessibility(ctor);
            _typeNameTranslation   = new TypeNameTranslation(ctor.DeclaringType, settings);
            _parametersTranslation = new ParameterSetDefinitionTranslation(ctor, settings);

            TranslationSize =
                _typeNameTranslation.TranslationSize +
                _parametersTranslation.TranslationSize;

            FormattingSize =
                settings.GetKeywordFormattingSize() + // <- for modifiers
                _typeNameTranslation.FormattingSize +
                _parametersTranslation.FormattingSize;
        }
            public PropertyAccessorDefinitionTranslation(
                PropertyDefinitionTranslation parent,
                MethodInfo accessor,
                ITranslationSettings settings)
            {
                var accessibility = GetAccessibility(accessor);

                _accessor = accessor.ReturnType != typeof(void) ? "get" : "set";

                TranslationSize = _accessor.Length + "; ".Length;
                FormattingSize  = settings.GetKeywordFormattingSize();

                if (accessibility == parent._accessibility)
                {
                    return;
                }

                _accessor        = accessibility + _accessor;
                TranslationSize += accessibility.Length;
            }
Exemple #6
0
        public OperatorDefinitionTranslation(
            MethodInfo @operator,
            string typeKeyword,
            ITranslationSettings settings)
        {
            _modifiers = GetAccessibility(@operator) + "static " + typeKeyword + " operator ";

            _returnTypeTranslation =
                new TypeNameTranslation(@operator.ReturnType, settings);

            _parametersTranslation = new ParameterSetDefinitionTranslation(@operator, settings);

            TranslationSize =
                _modifiers.Length +
                _returnTypeTranslation.TranslationSize +
                _parametersTranslation.TranslationSize;

            FormattingSize =
                settings.GetKeywordFormattingSize() + // <- For modifiers
                _returnTypeTranslation.FormattingSize +
                _parametersTranslation.FormattingSize;
        }
        public ParameterSetDefinitionTranslation(
            MethodBase method,
            ITranslationSettings settings)
        {
            _settings       = settings;
            _parameters     = method.GetParameters();
            _parameterCount = _parameters.Length;

            if (_parameterCount == 0)
            {
                _parameterTranslations = Enumerable <ITranslatable> .EmptyArray;
                TranslationSize        = 2;
                return;
            }

            _parameterTranslations = new ITranslatable[_parameterCount];
            var translationSize       = 6;
            var formattingSize        = 0;
            var keywordFormattingSize = settings.GetKeywordFormattingSize();
            var finalParameterIndex   = _parameterCount - 1;

            for (var i = 0; ;)
            {
                var parameter     = _parameters[i];
                var parameterType = parameter.ParameterType;

                if (parameter.IsOut)
                {
                    parameterType   = parameterType.GetElementType();
                    formattingSize += keywordFormattingSize;
                }
                else if (parameterType.IsByRef)
                {
                    parameterType   = parameterType.GetElementType();
                    formattingSize += keywordFormattingSize;
                }
                else if (i == finalParameterIndex && parameter.IsParamsArray())
                {
                    formattingSize += keywordFormattingSize;
                }

                var typeNameTranslation = new TypeNameTranslation(parameterType, settings);

                translationSize += typeNameTranslation.TranslationSize;
                formattingSize  += typeNameTranslation.FormattingSize;

                _parameterTranslations[i] = typeNameTranslation;

                ++i;

                if (i == _parameterCount)
                {
                    break;
                }

                translationSize += 3;
            }

            TranslationSize = translationSize;
            FormattingSize  = formattingSize;
        }
Exemple #8
0
        private MethodDefinitionTranslation(
            MethodInfo method,
            ITranslationSettings settings)
        {
            _accessibility = GetAccessibility(method);
            _modifiers     = GetModifiers(method);

            _returnTypeTranslation =
                new TypeNameTranslation(method.ReturnType, settings);

            if (method.DeclaringType != null)
            {
                _declaringTypeNameTranslation =
                    new TypeNameTranslation(method.DeclaringType, settings);
            }

            _methodName = method.Name;

            if (method.IsGenericMethod)
            {
                TranslationSize += 2;

                var genericArguments = method.GetGenericArguments();
                _genericArgumentCount = genericArguments.Length;

                _genericArgumentTranslations = new ITranslatable[_genericArgumentCount];

                for (var i = 0; ;)
                {
                    var argumentTranslation = new TypeNameTranslation(genericArguments[i], settings);

                    TranslationSize += argumentTranslation.TranslationSize;
                    FormattingSize  += argumentTranslation.FormattingSize;
                    _genericArgumentTranslations[i] = argumentTranslation;

                    ++i;

                    if (i == _genericArgumentCount)
                    {
                        break;
                    }

                    TranslationSize += ", ".Length;
                }
            }
            else
            {
                _genericArgumentTranslations = Enumerable <ITranslatable> .EmptyArray;
            }

            _parametersTranslation = new ParameterSetDefinitionTranslation(method, settings);

            TranslationSize =
                _accessibility.Length +
                _modifiers.Length +
                _returnTypeTranslation.TranslationSize +
                _methodName.Length;

            var keywordFormattingSize = settings.GetKeywordFormattingSize();

            FormattingSize =
                keywordFormattingSize + // <- For modifiers
                _returnTypeTranslation.FormattingSize;

            if (_declaringTypeNameTranslation != null)
            {
                TranslationSize += _declaringTypeNameTranslation.TranslationSize + 1;
                FormattingSize  += _declaringTypeNameTranslation.FormattingSize;
            }
        }