public DefaultField(IReturnType type, string name, ModifierEnum m, DomRegion region, IClass declaringType)
     : base(declaringType, name)
 {
     this.ReturnType = type;
     this.Region = region;
     this.Modifiers = m;
 }

 int GetAccessSortValue(ModifierEnum mods)
 {
     if ((mods & ModifierEnum.Private) != 0) return 0;
     if ((mods & ModifierEnum.Internal) != 0) return 1;
     if ((mods & ModifierEnum.Protected) != 0) return 2;
     if ((mods & ModifierEnum.Public) != 0) return 3;
     return 4;
 }

		ModifierEnum ConvertModifier(AST.Modifiers m, ModifierEnum defaultVisibility)
		{
			ModifierEnum r = (ModifierEnum)m;
			if ((r & ModifierEnum.VisibilityMask) == ModifierEnum.None)
				return r | defaultVisibility;
			else
				return r;
		}

 public DefaultMethod(string name, IReturnType type, ModifierEnum m, DomRegion region, DomRegion bodyRegion, IClass declaringType)
     : base(declaringType, name)
 {
     this.ReturnType = type;
     this.Region     = region;
     this.BodyRegion = bodyRegion;
     Modifiers = m;
 }

		public DefaultEvent(string name, IReturnType type, ModifierEnum m, DomRegion region, DomRegion bodyRegion, IClass declaringType) : base(declaringType, name)
		{
			this.ReturnType = type;
			this.Region     = region;
			this.BodyRegion = bodyRegion;
			Modifiers       = (ModifierEnum)m;
			if (Modifiers == ModifierEnum.None) {
				Modifiers = ModifierEnum.Private;
			}
		}

		static int GetModifierOffset(ModifierEnum modifier)
		{
			if ((modifier & ModifierEnum.Public) == ModifierEnum.Public) {
				return 0;
			}
			if ((modifier & ModifierEnum.Protected) == ModifierEnum.Protected) {
				return protectedModifierOffset;
			}
			if ((modifier & ModifierEnum.Internal) == ModifierEnum.Internal) {
				return internalModifierOffset;
			}
			return privateModifierOffset;
		}

		public static AST.TypeMemberModifiers ConvertVisibilityBack(ModifierEnum modifier)
		{
			AST.TypeMemberModifiers r = AST.TypeMemberModifiers.None;
			if ((modifier & ModifierEnum.Public) == ModifierEnum.Public)
				r |= AST.TypeMemberModifiers.Public;
			if ((modifier & ModifierEnum.Protected) == ModifierEnum.Protected)
				r |= AST.TypeMemberModifiers.Protected;
			if ((modifier & ModifierEnum.Internal) == ModifierEnum.Internal)
				r |= AST.TypeMemberModifiers.Internal;
			if ((modifier & ModifierEnum.Private) == ModifierEnum.Private)
				r |= AST.TypeMemberModifiers.Private;
			return r;
		}

		string ConvertAccessibility(ModifierEnum modifier)
		{
			if (ShowAccessibility) {
				if (ModifierIsSet(modifier, ModifierEnum.Public)) {
					return "public ";
				} else if (ModifierIsSet(modifier, ModifierEnum.Private)) {
					return "private ";
				} else if (ModifierIsSet(modifier, ModifierEnum.ProtectedAndInternal)) {
					return "protected internal ";
				} else if (ModifierIsSet(modifier, ModifierEnum.Internal)) {
					return "internal ";
				} else if (ModifierIsSet(modifier, ModifierEnum.Protected)) {
					return "protected ";
				}
			}
			
			return string.Empty;
		}

        /// <summary>
        /// Defines and returns a constructor for the given type
        /// </summary>
        /// <param name="container"></param>
        /// <param name="modifier"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static CodeConstructor DefineConstructor(CodeTypeDeclaration container,
            ModifierEnum modifier, params ParameterInfo[] parameters)
        {
            CodeConstructor ctor = new CodeConstructor();
            ctor.Attributes = (ctor.Attributes & ~MemberAttributes.AccessMask) | (MemberAttributes)modifier;

            if (parameters != null)
            {
                foreach (ParameterInfo parameter in parameters)
                {
                    CodeParameterDeclarationExpression codeParameter = new CodeParameterDeclarationExpression(
                        parameter.ParameterType, parameter.Name);
                    ctor.Parameters.Add(codeParameter);
                }
            }

            container.Members.Add(ctor);
            return ctor;
        }

		public override string Convert(ModifierEnum modifier)
		{
			StringBuilder builder = new StringBuilder();
			if (ShowAccessibility) {
				if ((modifier & ModifierEnum.Public) == ModifierEnum.Public) {
					builder.Append("Public");
				} else if ((modifier & ModifierEnum.Private) == ModifierEnum.Private) {
					builder.Append("Private");
				} else if ((modifier & (ModifierEnum.Protected | ModifierEnum.Internal)) == (ModifierEnum.Protected | ModifierEnum.Internal)) {
					builder.Append("Protected Friend");
				} else if ((modifier & ModifierEnum.Internal) == ModifierEnum.Internal) {
					builder.Append("Friend");
				} else if ((modifier & ModifierEnum.Protected) == ModifierEnum.Protected) {
					builder.Append("Protected");
				}
				builder.Append(' ');
			}
			return builder.ToString();
		}

		public override string Convert(ModifierEnum modifier, ConversionFlags conversionFlags)
		{
			if (ShowAccessibility(conversionFlags)) {
				if (ModifierIsSet(modifier, ModifierEnum.Public)) {
					return "public ";
				} else if (ModifierIsSet(modifier, ModifierEnum.Private)) {
					return "private ";
				} else if (ModifierIsSet(modifier, ModifierEnum.ProtectedAndInternal)) {
					return "protected internal ";
				} else if (ModifierIsSet(modifier, ModifierEnum.ProtectedOrInternal)) {
					return "internal protected ";
				} else if (ModifierIsSet(modifier, ModifierEnum.Internal)) {
					return "internal ";
				} else if (ModifierIsSet(modifier, ModifierEnum.Protected)) {
					return "protected ";
				}
			}
			
			return string.Empty;
		}

        /// <summary>
        /// Defines an accessor (get/set)
        /// </summary>
        /// <param name="container"></param>
        /// <param name="modifier"></param>
        /// <param name="typeInfo"></param>
        /// <param name="hasGet"></param>
        /// <param name="hasSet"></param>
        /// <param name="memberVariableName"></param>
        /// <returns></returns>
        public static CodeMemberProperty DefineAccessor(CodeTypeDeclaration container,
            ModifierEnum modifier, ParameterInfo typeInfo, bool hasGet, bool hasSet, string memberVariableName)
        {
            CodeMemberProperty property = DefineProperty(container, modifier, typeInfo, hasGet, hasSet);

            if (hasGet)
            {
                property.GetStatements.Add(new CodeMethodReturnStatement(
                    new CodeFieldReferenceExpression(
                        new CodeThisReferenceExpression(), memberVariableName
                    )
                )
                );
            }

            if (hasSet)
            {
                property.SetStatements.Add(new CodeAssignStatement(
                    new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), memberVariableName),
                    new CodePropertySetValueReferenceExpression()));
            }

            return property;
        }

 public abstract string Convert(ModifierEnum modifier);

		public Constructor(ModifierEnum m, IReturnType returnType, IClass declaringType)
			: base((m & ModifierEnum.Static) != 0 ? "#cctor" : "#ctor",
			       returnType, m, DomRegion.Empty, DomRegion.Empty, declaringType)
		{
		}

		public string Convert(ModifierEnum modifier)
		{
			return String.Empty;
		}

		bool ModifierIsSet(ModifierEnum modifier, ModifierEnum query)
		{
			return (modifier & query) == query;
		}

		public CodeGetterOrSetterFunction(IProperty property, ModifierEnum modifier)
			: base(property)
		{
			this.modifier = modifier;
		}

		public DefaultClass(ICompilationUnit compilationUnit, ClassType classType, ModifierEnum modifiers, DomRegion region, IClass declaringType) : base(declaringType)
		{
			if (compilationUnit == null)
				throw new ArgumentNullException("compilationUnit");
			this.compilationUnit = compilationUnit;
			this.region = region;
			this.classType = classType;
			Modifiers = modifiers;
			this.UsingScope = compilationUnit.UsingScope;
		}

		public abstract string ConvertAccessibility(ModifierEnum accessibility);

		public override string ConvertAccessibility(ModifierEnum accessibility)
		{
			return String.Empty;
		}