public static string GetModifier(AccessModifier? access, MemberModifier? modifier) { if (modifier == null) return access.ToString().ToLower(); else return string.Format("{0} {1}", access.ToString().ToLower(), modifier.ToString().ToLower()); }
protected virtual SpecificationDefinition GetSpecificationDefinition(MemberModifier memberModifier) { switch (memberModifier) { case MemberModifier.Virtual: return(SpecificationDefinition.Virtual); case MemberModifier.Override: return(SpecificationDefinition.Override); case MemberModifier.New: return(SpecificationDefinition.New); case MemberModifier.NewVirtual: return(SpecificationDefinition.New | SpecificationDefinition.Virtual); default: throw new ArgumentOutOfRangeException("memberModifier"); } }
public void EmitConstructor(Action <CodeBlockBuilder> methodBody, Action <ParameterBuilder> parameters, AccessModifier accessModifier = AccessModifier.Private, MemberModifier methodModifers = MemberModifier.None, IEnumerable <Action <ExpressionBuilder> > baseArguments = null, IEnumerable <string> summary = null, Action <DocBuilder> docs = null, IEnumerable <string> attributes = null) { this.EmitMemberSpacing(); this.EmitMemberComments(accessModifier, summary, docs); if (attributes != null) { foreach (var attributeName in attributes) { this.writer.WriteLine($"[{attributeName}]"); } } string parameterList = parameters != null ? ParameterBuilder.Apply(parameters) : ""; this.writer.WriteLine($"{accessModifier.Emit()} {RenderMemberModifiers(methodModifers)}{this.name}({parameterList})"); if (baseArguments != null) { this.writer.IncreaseIndent(); this.writer.Write(": base("); ExpressionBuilder.EmitArguments(this.writer, baseArguments); this.writer.WriteLine(")"); this.writer.DecreaseIndent(); } using (var bodyEmitter = new CodeBlockBuilder(this.writer.GetSubWriter())) { methodBody(bodyEmitter); } }
public void EmitProperty(string type, string name, AccessModifier accessModifier = AccessModifier.Private, MemberModifier methodModifers = MemberModifier.None, Action <CodeBlockBuilder> getter = null, Action <CodeBlockBuilder> setter = null, IEnumerable <string> summary = null, Action <DocBuilder> docs = null) { this.EmitMemberSpacing(); this.EmitMemberComments(accessModifier, summary, docs); this.writer.WriteLine($"{accessModifier.Emit()} {RenderMemberModifiers(methodModifers)}{type} {name}"); this.writer.WriteLine("{"); this.writer.IncreaseIndent(); if (getter != null) { this.writer.WriteLine("get"); using (var getBuilder = new CodeBlockBuilder(this.writer)) { getter(getBuilder); } } if (setter != null) { this.writer.WriteLine("set"); using (var setBuilder = new CodeBlockBuilder(this.writer)) { setter(setBuilder); } } this.writer.DecreaseIndent(); this.writer.WriteLine("}"); }
public void EmitProperty(string type, string name, AccessModifier accessModifier = AccessModifier.Private, MemberModifier methodModifers = MemberModifier.None, AccessModifier?getter = null, AccessModifier?setter = null, IEnumerable <string> summary = null, Action <DocBuilder> docs = null) { this.EmitMemberSpacing(); this.EmitMemberComments(accessModifier, summary, docs); this.writer.WriteLine($"{accessModifier.Emit()} {RenderMemberModifiers(methodModifers)}{type} {name}"); this.writer.WriteLine("{"); this.writer.IncreaseIndent(); if (getter != null) { if (getter.HasValue && getter.Value != accessModifier) { this.writer.Write(getter.Value.Emit() + " "); } this.writer.WriteLine("get;"); } if (setter != null) { if (setter.HasValue && setter.Value != accessModifier) { this.writer.Write(setter.Value.Emit() + " "); } this.writer.WriteLine("set;"); } this.writer.DecreaseIndent(); this.writer.WriteLine("}"); }
public CodegenPropertyWGraph( string name, Type returnType, string returnTypeName, string optionalComment, CodegenBlock getterBlock, CodegenBlock setterBlock, bool isPublic, MemberModifier modifiers) { if (returnType == null && returnTypeName == null) { throw new ArgumentException("Invalid null return type"); } Name = name; GetterBlock = getterBlock; SetterBlock = setterBlock; IsPublic = isPublic; Modifiers = modifiers; ReturnType = returnType; ReturnTypeName = returnTypeName; OptionalComment = optionalComment; }
public void CanEmitMethodDeclaration( string expectedCode, MemberVisibility visibility, MemberModifier modifier, Delegate signaturePrototype) { //-- arrange var method = new MethodMember(signaturePrototype.GetMethodInfo()); method.Name = "TestMethod"; method.Visibility = visibility; method.Modifier = modifier; var emitterUnderTest = new MethodSyntaxEmitter(method); //-- act var actualSyntax = emitterUnderTest.EmitSyntax(); //-- assert actualSyntax.Should().BeEquivalentToCode(expectedCode); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public FieldMember(TypeMember declaringType, MemberVisibility visibility, MemberModifier modifier, TypeMember type, string name) : base(declaringType, visibility, modifier, name) { this.Type = type; }
private void ModifyButtonClick(object obj) { if (IsAllDataValid()) { using (MemberModifier memberModifier = modifierFactory.CreateMemberModifier()) { if (IsAttributesProfileChecked) { memberModifier.ModifyProfile(AttributesProfileText); } if (IsAttributesClassChecked) { memberModifier.ModifyClass((AttributesClassText)); } if (IsPositionRotationChecked) { memberModifier.ModifyRotation(Convert.ToDouble(PositionRotationText)); memberModifier.ModifyPositionRotationEnum(SelectedDataInPositionRotationComboBox); } if (IsPositionVerticalChecked) { memberModifier.ModifyPlaneEnum(SelectedDataInPositionVerticalComboBox); memberModifier.ModifyPlaneOffset(Convert.ToDouble(PositionVerticalText)); } if (IsPositionHorizontalChecked) { memberModifier.ModifyDepthEnum(SelectedDataInPositionHorizontalComboBox); memberModifier.ModifyDepthOffset(Convert.ToDouble(PositionHorizontalText)); } if (IsPositionLevelsTopChecked) { memberModifier.ModifyTopPosition(Convert.ToDouble(PositionLevelsTop)); } if (IsPositionLevelsBottomChecked) { memberModifier.ModifyBottomPosition(Convert.ToDouble(PositionLevelsBottom)); } if (IsAttributesFinishChecked) { memberModifier.ModifyFinish(AttributesFinishText); } if (IsAttributesMaterialChecked) { memberModifier.ModifyMaterial(AttributesMaterialText); } if (IsAttributesNameChecked) { memberModifier.ModifyName(AttributesNameText); } memberModifier.Regen(); } } }
public FluentModifier2(MemberModifier modifier) { GetContextOrThrow().PeekStateOrThrow <MemberModifierState>().Modifier = modifier; }
public FluentModifier(MemberModifier modifier) { CodeGeneratorContext.GetContextOrThrow().PeekStateOrThrow <MemberTraitsContext>().Modifier = modifier; }
//----------------------------------------------------------------------------------------------------------------------------------------------------- protected AbstractMember(TypeMember declaringType, MemberVisibility visibility, MemberModifier modifier, string name) : this(visibility, modifier, name) { this.DeclaringType = declaringType; }
public static string GetVisualBasicModifier(AccessModifier? access, MemberModifier? modifier) { return !modifier.HasValue ? GetVisualBasicModifier(access.ToString()) : String.Format("{0} {1}", GetVisualBasicModifier(access.ToString()), modifier); }
public static string GetModifier(AccessModifier? access, MemberModifier? modifier) { return !modifier.HasValue ? access.ToString().ToLower() : String.Format("{0} {1}", access.ToString().ToLower(), modifier.ToString().ToLower()); }
public static MemberModifier Disable( this MemberModifier modifier, MemberModifier flag) { return(modifier & ~flag); }
public static MemberModifier Enable( this MemberModifier modifier, MemberModifier flag) { return(modifier | flag); }
public static bool IsStatic(this MemberModifier modifier) { return((modifier & MemberModifier.STATIC) == MemberModifier.STATIC); }
public static bool IsVirtual(this MemberModifier modifier) { return((modifier & MemberModifier.VIRTUAL) == MemberModifier.VIRTUAL); }
public static bool IsOverride(this MemberModifier modifier) { return((modifier & MemberModifier.OVERRIDE) == MemberModifier.OVERRIDE); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public EventMember(MemberVisibility visibility, MemberModifier modifier, TypeMember delegateType, string name) : base(visibility, modifier, name) { this.DelegateType = delegateType; }
public static string FormatModifiers(MemberModifier value) { var modifiers = ""; if (value.HasFlag(MemberModifier.Public)) modifiers = "public"; else if (value.HasFlag(MemberModifier.Protected) && value.HasFlag(MemberModifier.Internal)) modifiers = "protected internal"; else if (value.HasFlag(MemberModifier.Protected)) modifiers = "protected"; else if (value.HasFlag(MemberModifier.Internal)) modifiers = "internal"; else if (value.HasFlag(MemberModifier.Private)) modifiers = "private"; if (value.HasFlag(MemberModifier.Abstract)) modifiers += " abstract"; else if (value.HasFlag(MemberModifier.Sealed)) modifiers += " sealed"; if (value.HasFlag(MemberModifier.Override)) modifiers += " override"; if (value.HasFlag(MemberModifier.Virtual)) modifiers += " virtual"; if (value.HasFlag(MemberModifier.Static)) modifiers += " static"; if (value.HasFlag(MemberModifier.ReadOnly)) modifiers += " readonly"; return modifiers; }