public Method(string name, string returnType, IEnumerable <MethodParameter> parameters, VisibilityModifier visibility) { Name = name; ReturnType = returnType; Parameters = parameters; Visibility = visibility; }
private void AssertMethod(IMethod m, VisibilityModifier expectedVisibility, string expectedName, string expectedReturnType = "void") { Assert.IsNotNull(m, "unexpected null"); Assert.AreEqual(expectedVisibility, m.Visibility, "unexpected method visiblity"); Assert.AreEqual(expectedName, m.Name, "unexpected method name"); Assert.AreEqual(expectedReturnType, m.ReturnType, "unexpected return type"); }
public void t14_Parse_Method_VisibilityModifier(string modifier, VisibilityModifier expectedVisibility) { var tokens = TokenStreamBuilder.FromStrings("[", "a", "|", "|", modifier, "methodName", "(", ")", "]"); var classDiagram = new ClassDiagramParser(tokens).ParseClassDiagram(); var m = classDiagram.Classes.ToList()[0].Methods.ToList()[0]; Assert.AreEqual(expectedVisibility, m.Visibility, "unexpected visibility"); }
public void CastingShouldVisibilityModifier(string value, VisibilityModifier expected) { // Act ClassMember member = value; // Assert member.Visibility.Should().Be(expected); }
public void RegisterPersistentVisibility(VisibilityModifier modifier) { m_PersistentModifierList.Add(modifier); if (m_PersistentModifierList.Count >= 4) { Debug.LogWarning("[Aether Visibility] More persistent visibility modifiers are present than expected!"); } }
public void t13_Parse_Field_With_AccessModifier(String modifier, VisibilityModifier expectedVm) { var tokens = TokenStreamBuilder.FromStrings("[", "a", "|", modifier, "fieldName", ":", "fieldType", "]"); var classDiagram = new ClassDiagramParser(tokens).ParseClassDiagram(); var f = classDiagram.Classes.ToList()[0].Fields.ToList()[0]; Assert.IsNotNull(classDiagram, "field parsing failed"); Assert.AreEqual("fieldName", f.Name); Assert.AreEqual("fieldType", f.Type); Assert.AreEqual(expectedVm, f.Visibility, "wrong visibility modifier"); }
private void DispatchModifier(VisibilityModifier mod, bool isInstant) { // Let the center of the texture be world origin (0,0), so every position should be // offset by adding half of texture width and height Vector2 modPosTangentSpace = new Vector2(mod.m_Position.x, mod.m_Position.z) + new Vector2(m_TextureSizeX / 2, m_TextureSizeY / 2); int numThreadGroupX = Mathf.Max(1, (int)Mathf.Ceil((mod.m_Radius * 2) / THREADGROUP_SIZE_X)); int numThreadGroupY = Mathf.Max(1, (int)Mathf.Ceil((mod.m_Radius * 2) / THREADGROUP_SIZE_Y)); m_VisibilityCS.SetVector("ModifierPosition", modPosTangentSpace); m_VisibilityCS.SetFloat("ModifierRadius", mod.m_Radius); m_VisibilityCS.SetFloat("UpdateSpeed", isInstant ? 1 : Time.deltaTime * 6); m_VisibilityCS.SetBool("IsUnreveal", mod.m_IsUnreveal); m_VisibilityCS.SetTexture(COMPUTE_KERNEL, "WorldVisibilityResult", m_WorldVisibilityTexture); m_VisibilityCS.Dispatch(COMPUTE_KERNEL, numThreadGroupX, numThreadGroupY, 1); }
public static string GetDisplayText(this VisibilityModifier modifier) { switch (modifier) { case VisibilityModifier.Public: return("+"); case VisibilityModifier.Protected: return("#"); case VisibilityModifier.Private: return("~"); case VisibilityModifier.Internal: return("-"); } throw new ArgumentException("unexpected visibility modifier: " + modifier.ToString()); }
private void TryConsumeVisibilityModifier(out VisibilityModifier mod) { mod = VisibilityModifier.Public; if (_genericTokens.TryConsume(TokenType.Plus)) { mod = VisibilityModifier.Public; } else if (_genericTokens.TryConsume(TokenType.Dash)) { mod = VisibilityModifier.Private; } else if (_genericTokens.TryConsume(TokenType.Hash)) { mod = VisibilityModifier.Protected; } else if (_genericTokens.TryConsume(TokenType.Tilde)) { mod = VisibilityModifier.Internal; } }
internal static void VisibilityChar(this StringBuilder stringBuilder, VisibilityModifier visibility) { switch (visibility) { case VisibilityModifier.Private: stringBuilder.Append(Constant.Private); break; case VisibilityModifier.Protected: stringBuilder.Append(Constant.Protected); break; case VisibilityModifier.PackagePrivate: stringBuilder.Append(Constant.PackagePrivate); break; case VisibilityModifier.Public: stringBuilder.Append(Constant.Public); break; } }
private void Update() { for (int i = 0; i < m_NumDispatchPerFrame; ++i) { if (m_OneShotModifierQueue.Count <= 0) { break; } VisibilityModifier mod = m_OneShotModifierQueue.Dequeue(); DispatchModifier(mod, true); } foreach (VisibilityModifier mod in m_PersistentModifierList) { DispatchModifier(mod, false); } VisibilityUpdate(); VisibilityDebugger(); }
private static IEnumerable <SyntaxToken> GetModifiersFor(VisibilityModifier modifier) { switch (modifier) { case VisibilityModifier.Public: return(new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword) }); case VisibilityModifier.Internal: return(new[] { SyntaxFactory.Token(SyntaxKind.InternalKeyword) }); case VisibilityModifier.Protected: return(new[] { SyntaxFactory.Token(SyntaxKind.ProtectedKeyword) }); case VisibilityModifier.ProtectedInternal: return(new[] { SyntaxFactory.Token(SyntaxKind.ProtectedKeyword), SyntaxFactory.Token(SyntaxKind.InternalKeyword) }); case VisibilityModifier.Private: return(new[] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword) }); default: throw new ArgumentOutOfRangeException(nameof(modifier), modifier, $"Unknown modifier '{modifier}'."); } }
/// <summary> /// Renders the beginning of a class. /// </summary> /// <param name="name">The name of the class. The name can't contain spaces.</param> /// <param name="displayName">Optional display name. The display name can contain spaces.</param> /// <param name="visibility">Optional visibility.</param> /// <param name="isAbstract">Indicates wheter the class is abstract. Default <c>false</c>.</param> /// <param name="generics">Optional class extension.</param> /// <param name="stereotype">Optional stereo type.</param> /// <param name="customSpot">Optional custom spot.</param> /// <param name="tag">Optional tag.</param> /// <param name="url">Optional URL.</param> /// <param name="backgroundColor">Optional background color.</param> /// <param name="lineColor">Optional line color.</param> /// <param name="lineStyle">Optional line style.</param> /// <param name="extends">Optional extends.</param> /// <param name="implements">Optional implements.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="stringBuilder"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <paramref name="name"/> is <c>null</c>, empty of only white space.</exception> public static void ClassStart(this StringBuilder stringBuilder, string name, string displayName = default, VisibilityModifier visibility = VisibilityModifier.None, bool isAbstract = false, string generics = default, string stereotype = default, CustomSpot customSpot = default, string tag = default, Uri url = default, Color backgroundColor = default, Color lineColor = default, LineStyle lineStyle = LineStyle.None, string[] extends = default, string[] implements = default) { if (stringBuilder is null) { throw new ArgumentNullException(nameof(stringBuilder)); } stringBuilder.VisibilityChar(visibility); stringBuilder.Class(name, displayName, isAbstract, generics, stereotype, customSpot, tag, url, backgroundColor, lineColor, lineStyle, extends, implements); stringBuilder.TrimEnd(); stringBuilder.ClassBaseStart(); }
public AstVisibilityModifier(VisibilityModifier value) { Value = value; }
public static ConstructorDeclarationSyntax WithVisibilityModifier(this ConstructorDeclarationSyntax constructorDeclaration, VisibilityModifier modifier) { Contract.Requires(constructorDeclaration != null); Contract.Ensures(Contract.Result <ConstructorDeclarationSyntax>() != null); var oldModifiers = constructorDeclaration.Modifiers.Where(m => !m_visibilityModifierKinds.Contains(m.Kind())); var modifiers = new SyntaxTokenList() .AddRange(GetModifiersFor(modifier)) .AddRange(oldModifiers); return(constructorDeclaration.WithModifiers(modifiers)); }
public Field(string name, string type, VisibilityModifier visibilityModifier = VisibilityModifier.Public) { Name = name; Type = type; Visibility = visibilityModifier; }
public void RegisterVisibilityOneShot(VisibilityModifier modifier) { m_OneShotModifierQueue.Enqueue(modifier); }