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;
}
