public CodeTypeDeclaration(string name) { this.attributes = System.Reflection.TypeAttributes.Public; this.baseTypes = new CodeTypeReferenceCollection(); this.members = new CodeTypeMemberCollection(); base.Name = name; }
public void AddRange(CodeTypeReferenceCollection value) { foreach (CodeTypeReference e in value) { List.Add(e); } }
public void AddRange(CodeTypeReferenceCollection value) { foreach(CodeTypeReference e in value) { List.Add(e); } }
public void Constructor1_NullItem () { CodeTypeReference[] refs = new CodeTypeReference[] { new CodeTypeReference (string.Empty), null }; CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ( refs); }
public void Constructor0 () { CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection (); Assert.IsFalse (((IList) coll).IsFixedSize, "#1"); Assert.IsFalse (((IList) coll).IsReadOnly, "#2"); Assert.AreEqual (0, coll.Count, "#3"); Assert.IsFalse (((ICollection) coll).IsSynchronized, "#4"); }
public static CodeTypeReferenceCollection Clone(this CodeTypeReferenceCollection collection) { if (collection == null) return null; CodeTypeReferenceCollection c = new CodeTypeReferenceCollection(); foreach (CodeTypeReference reference in collection) c.Add(reference.Clone()); return c; }
public void AddRange(CodeTypeReferenceCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int count = value.Count; for (int i = 0; i < count; i++) { this.Add(value[i]); } }
public void Constructor1 () { CodeTypeReference ref1 = new CodeTypeReference (string.Empty); CodeTypeReference ref2 = new CodeTypeReference (string.Empty); CodeTypeReference[] refs = new CodeTypeReference[] { ref1, ref2 }; CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ( refs); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (ref1), "#2"); Assert.AreEqual (1, coll.IndexOf (ref2), "#3"); }
public void Constructor1_Deny_Unrestricted () { CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection (array); coll.CopyTo (array, 0); Assert.AreEqual (1, coll.Add (ctr), "Add"); Assert.AreSame (ctr, coll[0], "this[int]"); coll.AddRange (array); coll.AddRange (coll); Assert.IsTrue (coll.Contains (ctr), "Contains"); Assert.AreEqual (0, coll.IndexOf (ctr), "IndexOf"); coll.Insert (0, ctr); coll.Remove (ctr); }
/// <devdoc> /// <para> /// Adds the contents of another <see cref='System.CodeDom.CodeTypeReferenceCollection'/> to the end of the collection. /// </para> /// </devdoc> public void AddRange(CodeTypeReferenceCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int currentCount = value.Count; for (int i = 0; i < currentCount; i = ((i) + (1))) { this.Add(value[i]); } }
public void AddRange(CodeTypeReferenceCollection value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } int currentCount = value.Count; for (int i = 0; i < currentCount; i++) { Add(value[i]); } }
string GetTypeArguments (CodeTypeReferenceCollection collection) { StringBuilder sb = new StringBuilder (" <"); foreach (CodeTypeReference r in collection) { sb.Append (GetTypeOutput (r)); sb.Append (", "); } sb.Length--; sb [sb.Length - 1] = '>'; return sb.ToString (); }
public void AddRange(CodeTypeReferenceCollection value) { throw new NotImplementedException(); }
private string GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArgs) { int count; if (typeArgs != null && (count = typeArgs.Count) > 0) { StringBuilder sb = new StringBuilder(); sb.Append(Tokens.GenericBracketLeft); sb.Append(GetTypeOutput(typeArgs[0])); for (int i = 1; i < count; i++) { sb.Append(Tokens.Comma + WhiteSpace.Space); sb.Append(GetTypeOutput(typeArgs[i])); } sb.Append(Tokens.GenericBracketRight); return sb.ToString(); } else return String.Empty; }
/// <summary> /// Outputs reference to an instance or static member. /// </summary> /// <param name="target">An expression denoting the instance or type (if <B>null</B>, <c>$this</c> is assumed). /// </param> /// <param name="name">The member name.</param> /// <param name="variable"><B>True</B> if the member is a variable (i.e. property), <b>false</b> otherwise.</param> /// <param name="typeArgs">Optional type arguments if this is a method reference.</param> private void OutputMemberReference(CodeExpression target, string name, bool variable, CodeTypeReferenceCollection typeArgs) { CodeTypeReferenceExpression type_ref; CodeBaseReferenceExpression base_ref = null; if ((type_ref = target as CodeTypeReferenceExpression) != null || (base_ref = target as CodeBaseReferenceExpression) != null) { // "static" reference if (type_ref != null) OutputType(type_ref.Type); else GenerateBaseReferenceExpression(base_ref); Output.Write(Tokens.DoubleColon); if (variable) { if (type_ref != null && IsFieldConstant(type_ref, name)) Output.Write(name); else OutputVariable(name); } else Output.Write(name); } else { // instance reference if (target == null) { // let's suppose this is $this->NAME (might also be self::NAME but that cannot be // decided according to the provided information OutputVariable(SpecialWords.This); } else GenerateExpression(target); Output.Write(Tokens.Arrow); Output.Write(name); } Output.Write(GetTypeArgumentsOutput(typeArgs)); }
public void interf_declr( CodeTypeReferenceCollection baseTypes ) //throws RecognitionException, TokenStreamException { returnAST = null; ASTPair currentAST = new ASTPair(); AST interf_declr_AST = null; AST name_AST = null; try { // for error handling { switch ( LA(1) ) { case LITERAL_interface: { AST tmp52_AST = null; tmp52_AST = astFactory.create(LT(1)); astFactory.makeASTRoot(ref currentAST, tmp52_AST); match(LITERAL_interface); break; } case LITERAL_dispinterface: { AST tmp53_AST = null; tmp53_AST = astFactory.create(LT(1)); astFactory.makeASTRoot(ref currentAST, tmp53_AST); match(LITERAL_dispinterface); break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } identifier(); if (0 == inputState.guessing) { name_AST = (AST)returnAST; astFactory.addASTChild(ref currentAST, returnAST); } if (0==inputState.guessing) { baseTypes.Add(name_AST.getText()); } interf_declr_AST = currentAST.root; } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex); recover(ex,tokenSet_11_); } else { throw ex; } } returnAST = interf_declr_AST; }
protected void Rewrite(CodeTypeReferenceCollection target, CodeTypeReferenceCollection source, ref bool didRewrite) { foreach (CodeTypeReference item in source) { target.Add(this.Rewrite(item, ref didRewrite)); } }
private void GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments, int start, int length, StringBuilder sb) { sb.Append('<'); bool first = true; for( int i = start; i < start+length; i++) { if( first) { first = false; } else { sb.Append(", "); } // it's possible that we call GetTypeArgumentsOutput with an empty typeArguments collection. This is the case // for open types, so we want to just output the brackets and commas. if (i < typeArguments.Count) sb.Append(GetTypeOutput(typeArguments[i])); } sb.Append('>'); }
public CodeTypeReferenceCollection(CodeTypeReferenceCollection value) { return(default(CodeTypeReferenceCollection)); }
private InterfaceList TranslateToInterfaceList(CodeTypeReferenceCollection interfaces){ int n = interfaces == null ? 0 : interfaces.Count; InterfaceList interfaceList = new InterfaceList(n); for (int i = 0; i < n; i++) interfaceList.Add(this.TranslateToInterface(interfaces[i])); return interfaceList; }
private string GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments) { StringBuilder sb = new StringBuilder(128); this.GetTypeArgumentsOutput(typeArguments, 0, typeArguments.Count, sb); return sb.ToString(); }
private TypeNodeList Translate(CodeTypeReferenceCollection types){ int n = types == null ? 0 : types.Count; TypeNodeList typeList = new TypeNodeList(n); for (int i = 0; i < n; i++) typeList.Add(this.TranslateToTypeNode(types[i])); return typeList; }
/// <summary> /// For the marshalling method to be invoked, create the appropriate method type (generic type). /// </summary> /// <param name="exprInvoke">Marshalling method being created.</param> /// <param name="elementTypes">Array types of marshalling method.</param> protected virtual void BuildMethodInvokeMethodTypes(CodeMethodInvokeExpression exprInvoke, CodeTypeReferenceCollection elementTypes) { if (elementTypes != null && elementTypes.Count > 0) { // Bit of a hack, but essentially in every case (the most annoying being dictionary), the last type is the one that needs fixing up. CodeTypeReference[] arrayAdjustedElementTypes = new CodeTypeReference[elementTypes.Count]; int iter = 0; for (; iter < elementTypes.Count - 1; ++iter) { arrayAdjustedElementTypes[iter] = elementTypes[iter]; } // Ends loop copying all but last element // Since dictionary values support covariance about as well as Republicans support healthcare, // we have to stick with arrays as part of the interface. arrayAdjustedElementTypes[iter] = elementTypes[iter];// CodeBuilderCommon.ArrayTypeToEnumerableType(elementTypes[iter]); exprInvoke.Method.TypeArguments.AddRange(arrayAdjustedElementTypes); } }
protected override void BuildMethodInvokeMethodTypes(CodeMethodInvokeExpression exprInvoke, CodeTypeReferenceCollection elementTypes) { if (this.QuSubArray && !this.QuSubArrayIsArray) // If got sub-array which holds a value { base.BuildMethodInvokeMethodTypes(exprInvoke, elementTypes); } // Ends if got sub-array which holds a value }
private void OutputTypeArguments (CodeTypeReferenceCollection typeArguments, StringBuilder sb, int count) { if (count == 0) { return; } else if (typeArguments.Count == 0) { // generic type definition sb.Append ("<>"); return; } sb.Append ('<'); // write first type argument sb.Append (GetTypeOutput (typeArguments[0])); // subsequent type argument are prefixed by ', ' separator for (int i = 1; i < count; i++) { sb.Append (", "); sb.Append (GetTypeOutput (typeArguments[i])); } sb.Append ('>'); }
private static void ValidateTypeReferences(CodeTypeReferenceCollection refs) { for (int i=0; i<refs.Count; i++) { ValidateTypeReference(refs[i]); } }
public void Constructor2 () { CodeTypeReference ref1 = new CodeTypeReference (string.Empty); CodeTypeReference ref2 = new CodeTypeReference (string.Empty); CodeTypeReferenceCollection c = new CodeTypeReferenceCollection (); c.Add (ref1); c.Add (ref2); CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection (c); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (ref1), "#2"); Assert.AreEqual (1, coll.IndexOf (ref2), "#3"); }
private void OutputImplementationTypes (CodeTypeReferenceCollection implementationTypes, string member) { IEnumerator enumerator = implementationTypes.GetEnumerator (); if (enumerator.MoveNext ()) { Output.Write (" Implements "); CodeTypeReference typeReference = (CodeTypeReference) enumerator.Current; OutputType (typeReference); Output.Write ('.'); OutputIdentifier (member); while (enumerator.MoveNext ()) { Output.Write (" , "); typeReference = (CodeTypeReference) enumerator.Current; OutputType (typeReference); Output.Write ('.'); OutputIdentifier (member); } } }
public void Constructor1_Null () { CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ( (CodeTypeReference[]) null); }
private void GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments, int start, int length, StringBuilder sb) { sb.Append("(Of "); bool flag = true; for (int i = start; i < (start + length); i++) { if (flag) { flag = false; } else { sb.Append(", "); } if (i < typeArguments.Count) { sb.Append(this.GetTypeOutput(typeArguments[i])); } } sb.Append(')'); }
private void AddImportsForCodeTypeReferenceCollection(CodeNamespaceImportCollection curImports, CodeTypeReferenceCollection ctrc) { foreach (CodeTypeReference ctr in ctrc) { MaybeAddImport(curImports, ctr); } }
public void AddRange(CodeTypeReferenceCollection !value) { Contract.Requires(value != null); }
private void EmitGenericTypeArgs(CodeTypeReferenceCollection typeArgs) { if (typeArgs != null && typeArgs.Count > 0) { Write("["); for (int i = 0; i < typeArgs.Count; i++) { if (i != 0) Write(", "); Write(typeArgs[i].BaseType); } Write("]"); } }
/// <include file='doc\CodeTypeReferenceCollection.uex' path='docs/doc[@for="CodeTypeReferenceCollection.CodeTypeReferenceCollection1"]/*' /> /// <devdoc> /// <para> /// Initializes a new instance of <see cref='System.CodeDom.CodeTypeReferenceCollection'/> based on another <see cref='System.CodeDom.CodeTypeReferenceCollection'/>. /// </para> /// </devdoc> public CodeTypeReferenceCollection(CodeTypeReferenceCollection value) { this.AddRange(value); }
private string GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments) { StringBuilder builder1 = new StringBuilder(0x80); this.GetTypeArgumentsOutput(typeArguments, 0, typeArguments.Count, builder1); return builder1.ToString(); }
/// <devdoc> /// <para> /// Initializes a new instance of <see cref='System.CodeDom.CodeTypeReferenceCollection'/> based on another <see cref='System.CodeDom.CodeTypeReferenceCollection'/>. /// </para> /// </devdoc> public CodeTypeReferenceCollection(CodeTypeReferenceCollection value) { this.AddRange(value); }
private void GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments, int start, int length, StringBuilder sb) { sb.Append('<'); bool flag1 = true; for (int num1 = start; num1 < (start + length); num1++) { if (flag1) { flag1 = false; } else { sb.Append(", "); } if (num1 < typeArguments.Count) { sb.Append(this.GetTypeOutput(typeArguments[num1])); } } sb.Append('>'); }