/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public override IParameter GetParam(ParameterNames.ProgramParameterName name)
{
IParameter parameter;
switch (name)
{
case ParameterNames.ProgramParameterName.OscMode:
parameter = EnumParameter.Instance.Set(Root, Root.Content, ByteOffset + 10, 2, 0,
new List <string> {
"Single", "Double", "Drums"
}, this);
break;
case ParameterNames.ProgramParameterName.Category:
FixedParameter fixedParameter = new FixedParameter();
fixedParameter.Set(PcgRoot, PcgRoot.Content, FixedParameter.EType.Category, this);
parameter = fixedParameter;
break;
default:
parameter = (IFixedParameter)base.GetParam(name);
break;
}
return(parameter);
}
public ServiceConstructorInjector Create(
BufferedTokenStream tokenStream,
string constructorClassName,
string constructorClassNamespace,
string serviceIdentifier,
string serviceNamespace,
string serviceInterfaceType,
FieldDeclaration fieldDeclaration,
FixedParameter constructorParameter,
SimpleAssignment constructorAssignment,
ConstructorDeclaration constructorDeclaration,
string tabString = null)
{
return(new ServiceConstructorInjector(
_stringUtilService,
_cSharpParserService,
_cSharpCommonStgService,
_logger,
tokenStream,
constructorClassName,
constructorClassNamespace,
serviceIdentifier,
serviceNamespace,
serviceInterfaceType,
fieldDeclaration,
constructorParameter,
constructorAssignment,
constructorDeclaration,
tabString));
}
public string InjectServiceIntoConstructor(
CSharpParserWrapper constructorInjectorParser,
string constructorClassName,
string constructorClassNamespace,
string serviceIdentifier,
string serviceNamespace,
string serviceInterfaceType,
FieldDeclaration fieldDeclaration,
FixedParameter constructorParameter,
SimpleAssignment constructorAssignment,
ConstructorDeclaration constructorDeclaration,
string tabString = null)
{
var controllerInjectorTree = constructorInjectorParser.GetParseTree();
var serviceControllerInjector = _serviceConstructorInjectorFactory.Create(
tokenStream: constructorInjectorParser.Tokens,
constructorClassName: constructorClassName,
constructorClassNamespace: constructorClassNamespace,
serviceIdentifier: serviceIdentifier,
serviceNamespace: serviceNamespace,
serviceInterfaceType: serviceInterfaceType,
fieldDeclaration: fieldDeclaration,
constructorParameter: constructorParameter,
constructorAssignment: constructorAssignment,
constructorDeclaration: constructorDeclaration,
tabString: tabString);
serviceControllerInjector.Visit(controllerInjectorTree);
return(serviceControllerInjector.IsModified ? serviceControllerInjector.Rewriter.GetText() : null);
}
public string RenderFixedParameter(FixedParameter fixedParam = null)
{
var stringTemplate = _cSharpCommonGroupFile.GetInstanceOf(StgCSharpCommon.FixedParameter.Name);
stringTemplate.Add(StgCSharpCommon.FixedParameter.Params.Attributes, fixedParam.Attributes);
stringTemplate.Add(StgCSharpCommon.FixedParameter.Params.ParameterModifier, fixedParam.ParameterModifier);
stringTemplate.Add(StgCSharpCommon.FixedParameter.Params.Type, fixedParam.Type);
stringTemplate.Add(StgCSharpCommon.FixedParameter.Params.Identifier, fixedParam.Identifier);
stringTemplate.Add(StgCSharpCommon.FixedParameter.Params.DefaultArgument, fixedParam.DefaultArgument);
return(stringTemplate.Render());
}
public AlphaCutoffParameter()
{
Type = new Value.Enum <ParameterType>(ParameterType.Fixed);
Fixed = new FixedParameter();
FourPointInterpolation = new FourPointInterpolationParameter();
Easing = new FloatEasingParamater(0.0f, 1.0f, 0.0f);
FCurve = new Value.FCurveScalar(0.0f, 100.0f);
Fixed.Threshold.CanSelectDynamicEquation = true;
Easing.Start.CanSelectDynamicEquation = true;
Easing.End.CanSelectDynamicEquation = true;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public override IParameter GetParam(ParameterNames.ProgramParameterName name)
{
IParameter parameter = null;
switch (name)
{
// No OSC Mode
case ParameterNames.ProgramParameterName.Category:
parameter = new FixedParameter();
((FixedParameter)parameter).Set(PcgRoot, PcgRoot.Content, FixedParameter.EType.Category, this);
break;
}
return(parameter);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public override IParameter GetParam(string name)
{
IParameter parameter;
switch (name)
{
case "Category":
parameter = new FixedParameter();
((FixedParameter)parameter).Set(Root, Root.Content, FixedParameter.EType.Category, this);
break;
default:
throw new ApplicationException("Illegal case");
}
return(parameter);
}
public ServiceConstructorInjector(
IStringUtilService stringUtilService,
ICSharpParserService cSharpParserService,
ICSharpCommonStgService cSharpCommonStgService,
ILogger logger,
BufferedTokenStream tokenStream,
string constructorClassName,
string constructorClassNamespace,
string serviceIdentifier,
string serviceNamespace,
string serviceInterfaceType,
FieldDeclaration fieldDeclaration,
FixedParameter constructorParameter,
SimpleAssignment constructorAssignment,
ConstructorDeclaration constructorDeclaration,
string tabString = null)
{
_stringUtilService = stringUtilService;
_cSharpParserService = cSharpParserService;
_cSharpCommonStgService = cSharpCommonStgService;
_logger = logger;
Tokens = tokenStream;
Rewriter = new TokenStreamRewriter(tokenStream);
_constructorClassName = constructorClassName;
_constructorClassNamespace = constructorClassNamespace;
_serviceIdentifier = serviceIdentifier;
_serviceNamespace = serviceNamespace;
_serviceInterfaceType = serviceInterfaceType;
_fieldDeclaration = fieldDeclaration;
_constructorParameter = constructorParameter;
_constructorAssignment = constructorAssignment;
_constructorDeclaration = constructorDeclaration;
_tabString = tabString;
_currentNamespace = new Stack <string>();
IsModified = false;
_isConstructorClassFound = false;
_isRewritten = false;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public override IParameter GetParam(ParameterNames.ProgramParameterName name)
{
IParameter parameter;
switch (name)
{
// No OSC Mode
case ParameterNames.ProgramParameterName.Category:
parameter = new FixedParameter();
((FixedParameter)parameter).Set(PcgRoot, PcgRoot.Content, FixedParameter.EType.Genre, this);
break;
case ParameterNames.ProgramParameterName.SubCategory:
parameter = new FixedParameter();
((FixedParameter)parameter).Set(PcgRoot, PcgRoot.Content, FixedParameter.EType.Category, this);
break;
default:
throw new ApplicationException("Illegal case");
}
return(parameter);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public override IParameter GetParam(ParameterNames.ProgramParameterName name)
{
IParameter parameter;
switch (name)
{
case ParameterNames.ProgramParameterName.OscMode:
parameter = EnumParameter.Instance.Set(Root, Root.Content, ByteOffset + 10, 2, 0,
new List <string> {
"Single", "Double", "Drums"
}, this);
break;
case ParameterNames.ProgramParameterName.Category:
parameter = new FixedParameter();
((FixedParameter)parameter).Set(PcgRoot, PcgRoot.Content, FixedParameter.EType.Category, this);
break;
default:
throw new NotSupportedException("Unsupported case");
}
return(parameter);
}
public override object VisitClass_declaration([NotNull] CSharpParser.Class_declarationContext context)
{
_currentClass.Push(context.identifier().GetText());
var classBaseType = context?.class_base()?.class_type()?.GetText();
_isControllerClass.Push(classBaseType == "Controller");
_isClassModified.Push(false);
VisitChildren(context);
if (_isClassModified.Peek() && _isControllerClass.Peek())
{
var currentClass = GetCurrentClass();
var serviceInterfaceName = GetServiceInterfaceName();
var controllerServiceIdentifier = "breadcrumbService";
var fieldDeclaration = new FieldDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Private, Keywords.Readonly
},
Type = serviceInterfaceName,
VariableDeclarator = new VariableDeclarator()
{
Identifier = $"_{controllerServiceIdentifier}"
}
};
var constructorParameter = new FixedParameter()
{
Type = serviceInterfaceName,
Identifier = controllerServiceIdentifier
};
var constructorAssignment = new SimpleAssignment()
{
LeftHandSide = $"_{controllerServiceIdentifier}",
RightHandSide = controllerServiceIdentifier
};
var constructorDeclaration = new ConstructorDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = currentClass,
FormalParameterList = new FormalParameterList()
{
FixedParameters = new List <FixedParameter>()
{
constructorParameter
}
},
Body = new ConstructorBody()
{
Statements = new List <Statement>()
{
new Statement()
{
SimpleAssignment = constructorAssignment
}
}
}
};
var preclassWhitespace = Tokens.GetHiddenTokensToLeft(context.Start.TokenIndex, Lexer.Hidden);
int classBodyTabLevels = 1 + ((preclassWhitespace?.Count ?? 0) > 0 ?
_stringUtilService.CalculateTabLevels(preclassWhitespace[0]?.Text ?? string.Empty, _tabString) : 0);
int ctorBodyTabLevels = classBodyTabLevels + 1;
int?finalConstantOrField = null;
int?finalField = null;
int?finalProperty = null;
CSharpParser.Constructor_declarationContext constructorContext = null;
bool hasServiceField = false;
bool hasCtorParam = false;
bool hasCtorAssignment = false;
var members = context?.class_body()?.class_member_declarations()?.class_member_declaration();
if (members != null)
{
foreach (var member in members)
{
if (member.constant_declaration() != null)
{
finalConstantOrField = member.constant_declaration().Stop.TokenIndex;
}
else if (member.field_declaration() != null)
{
var fieldDec = member.field_declaration();
finalField = fieldDec.Stop.TokenIndex;
finalConstantOrField = fieldDec.Stop.TokenIndex;
if (fieldDec.type_().GetText() == serviceInterfaceName)
{
foreach (var varDec in fieldDec.variable_declarators().variable_declarator())
{
if (varDec.identifier().GetText() ==
$"_{controllerServiceIdentifier}")
{
hasServiceField = true;
break;
}
}
}
}
else if (member.property_declaration() != null)
{
finalProperty = member.property_declaration().Stop.TokenIndex;
}
else if (member.constructor_declaration() != null)
{
constructorContext ??= member.constructor_declaration();
}
}
}
int fieldStopIndex = finalField
?? finalConstantOrField
?? context.class_body().OPEN_BRACE().Symbol.TokenIndex;
int?constructorStopIndex = null;
var fieldStringBuilder = new StringBuilder();
StringBuilder constructorStringBuilder = null;
if (!hasServiceField)
{
fieldStringBuilder.Append(_cSharpParserService.GenerateFieldDeclaration(
fieldDeclaration,
classBodyTabLevels,
_tabString));
}
if (constructorContext is null)
{
constructorStopIndex = finalProperty
?? finalConstantOrField
?? fieldStopIndex;
constructorStringBuilder = constructorStopIndex == fieldStopIndex
? fieldStringBuilder : new StringBuilder();
constructorStringBuilder.Append(
_cSharpParserService.GenerateConstructorDeclaration(
constructorDeclaration,
classBodyTabLevels,
_tabString));
}
else
{
CSharpParser.Fixed_parameterContext finalFixedParam = null;
var formalParamList = constructorContext?.constructor_declarator()?.formal_parameter_list();
if (formalParamList != null)
{
var fixedParams = formalParamList.fixed_parameters();
if (fixedParams != null)
{
foreach (var fixedParam in fixedParams.fixed_parameter())
{
if (fixedParam.type_().GetText() == serviceInterfaceName &&
fixedParam.identifier().GetText() == controllerServiceIdentifier)
{
hasCtorParam = true;
break;
}
}
finalFixedParam = fixedParams.fixed_parameter().Last();
}
}
if (!hasCtorParam)
{
var ctorParam = _cSharpCommonStgService.RenderFixedParameter(constructorParameter);
int fixedParamStopIndex = finalFixedParam?.Stop?.TokenIndex
?? constructorContext.constructor_declarator().OPEN_PARENS().Symbol.TokenIndex;
var paramStringBuilder = new StringBuilder();
if (finalFixedParam != null)
{
var preFinalParamWhitespace = Tokens.GetHiddenTokensToLeft(
finalFixedParam?.Start?.TokenIndex ?? -1, Lexer.Hidden);
int finalParamtabs = (preFinalParamWhitespace?.Count ?? 0) > 0 ?
_stringUtilService.CalculateTabLevels(
preFinalParamWhitespace?[0]?.Text ?? string.Empty, _tabString) : 0;
if (finalParamtabs > 0)
{
paramStringBuilder.Append(",\r\n");
paramStringBuilder.Append(_stringUtilService.TabString(
ctorParam,
finalParamtabs,
_tabString));
if (formalParamList?.parameter_array() != null)
{
var preParamArrayWhitespaceArray = Tokens.GetHiddenTokensToLeft(
formalParamList.parameter_array().Start.TokenIndex, Lexer.Hidden);
string preParamArrayWhitespace =
preParamArrayWhitespaceArray.Count > 0 ?
preParamArrayWhitespaceArray[0].Text : string.Empty;
if (!Regex.IsMatch(preParamArrayWhitespace, @"\r?\n"))
{
IsModified = true;
Rewriter.InsertBefore(
formalParamList.parameter_array().Start.TokenIndex,
"\r\n" +
_stringUtilService.TabString(string.Empty, finalParamtabs, _tabString));
}
}
}
else
{
paramStringBuilder.Append(", ");
paramStringBuilder.Append(ctorParam);
}
}
else
{
paramStringBuilder.Append("\r\n");
paramStringBuilder.Append(
_stringUtilService.TabString(ctorParam, ctorBodyTabLevels, _tabString));
if (formalParamList?.parameter_array() != null)
{
var preParamArrayWhitespaceArray = Tokens.GetHiddenTokensToLeft(
formalParamList.parameter_array().Start.TokenIndex, Lexer.Hidden);
string preParamArrayWhitespace =
preParamArrayWhitespaceArray.Count > 0 ?
preParamArrayWhitespaceArray[0].Text : string.Empty;
if (!Regex.IsMatch(preParamArrayWhitespace, $"\r?\n"))
{
IsModified = true;
Rewriter.InsertBefore(
formalParamList.parameter_array().Start.TokenIndex,
"\r\n" +
_stringUtilService.TabString(string.Empty, ctorBodyTabLevels, _tabString));
}
}
}
var paramString = paramStringBuilder.ToString();
if (paramString.Length > 0)
{
IsModified = true;
Rewriter.InsertAfter(fixedParamStopIndex, paramString);
}
}
string ctorAssignString = _cSharpCommonStgService.RenderSimpleAssignment(constructorAssignment);
var constructorBody = constructorContext?.constructor_body();
if (constructorBody.SEMICOLON() != null)
{
IsModified = true;
Rewriter.Replace(constructorBody.SEMICOLON().Symbol.TokenIndex, _stringUtilService.TabString(
$@"\r\n{{\r\n{_tabString}{ctorAssignString}\r\n}}",
classBodyTabLevels,
_tabString));
}
else
{
var block = constructorBody.block();
var statementList = block?.statement_list()?.GetText();
if (statementList != null)
{
var assignmentMatchString =
$@"[\s;{{]_{controllerServiceIdentifier}\s*=\s*{controllerServiceIdentifier}\s*;";
hasCtorAssignment = Regex.Match(statementList, assignmentMatchString).Success;
}
if (!hasCtorAssignment)
{
int?finalAssignment = block.statement_list().statement().Last().Stop.TokenIndex;
int assignmentStopIndex = finalAssignment
?? block.OPEN_BRACE().Symbol.TokenIndex;
var assignmentStringBuilder = new StringBuilder();
assignmentStringBuilder.Append("\r\n");
assignmentStringBuilder.Append(_stringUtilService.TabString(
ctorAssignString, ctorBodyTabLevels, _tabString));
var postAssignmentStopWhitespaceArray = Tokens.GetHiddenTokensToRight(
assignmentStopIndex, Lexer.Hidden);
string postAssignmentStopWhitespace =
postAssignmentStopWhitespaceArray.Count > 0 ?
postAssignmentStopWhitespaceArray[0].Text : string.Empty;
if (!Regex.IsMatch(postAssignmentStopWhitespace, @"\r?\n"))
{
assignmentStringBuilder.Append("\r\n");
}
var assignmentString = assignmentStringBuilder.ToString();
if (assignmentString.Length > 0)
{
IsModified = true;
Rewriter.InsertAfter(assignmentStopIndex, assignmentString);
}
}
}
}
var fieldString = fieldStringBuilder.ToString();
if (fieldString.Length > 0)
{
IsModified = true;
Rewriter.InsertAfter(fieldStopIndex, fieldString);
}
if (constructorStringBuilder != null &&
constructorStopIndex != fieldStopIndex)
{
var constructorString = constructorStringBuilder.ToString();
if (constructorString.Length > 0)
{
IsModified = true;
Rewriter.InsertAfter(Tokens.Get(constructorStopIndex ?? -1), constructorString);
}
}
}
_ = _isClassModified.Pop();
_ = _isControllerClass.Pop();
_ = _currentClass.Pop();
return(null);
}
