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 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);
}
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));
}
}
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");
}
public void Remove ()
{
CodeTypeReference ctr1 = new CodeTypeReference (string.Empty);
CodeTypeReference ctr2 = new CodeTypeReference (string.Empty);
CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
coll.Add (ctr1);
coll.Add (ctr2);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (ctr1), "#2");
Assert.AreEqual (1, coll.IndexOf (ctr2), "#3");
coll.Remove (ctr1);
Assert.AreEqual (1, coll.Count, "#4");
Assert.AreEqual (-1, coll.IndexOf (ctr1), "#5");
Assert.AreEqual (0, coll.IndexOf (ctr2), "#6");
}
public void AddRange_Self ()
{
CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
coll.Add (new CodeTypeReference (string.Empty));
Assert.AreEqual (1, coll.Count, "#1");
coll.AddRange (coll);
Assert.AreEqual (2, coll.Count, "#2");
}
public void AddRange ()
{
CodeTypeReference ref1 = new CodeTypeReference (string.Empty);
CodeTypeReference ref2 = new CodeTypeReference (string.Empty);
CodeTypeReference ref3 = new CodeTypeReference (string.Empty);
CodeTypeReferenceCollection coll1 = new CodeTypeReferenceCollection ();
coll1.Add (ref1);
coll1.Add (ref2);
CodeTypeReferenceCollection coll2 = new CodeTypeReferenceCollection ();
coll2.Add (ref3);
coll2.AddRange (coll1);
Assert.AreEqual (3, coll2.Count, "#1");
Assert.AreEqual (1, coll2.IndexOf (ref1), "#2");
Assert.AreEqual (2, coll2.IndexOf (ref2), "#3");
Assert.AreEqual (0, coll2.IndexOf (ref3), "#4");
CodeTypeReferenceCollection coll3 = new CodeTypeReferenceCollection ();
coll3.Add (ref3);
coll3.AddRange (new CodeTypeReference[] { ref1, ref2 });
Assert.AreEqual (3, coll2.Count, "#5");
Assert.AreEqual (1, coll2.IndexOf (ref1), "#6");
Assert.AreEqual (2, coll2.IndexOf (ref2), "#7");
Assert.AreEqual (0, coll2.IndexOf (ref3), "#8");
}
public void Insert ()
{
CodeTypeReference ref1 = new CodeTypeReference (string.Empty);
CodeTypeReference ref2 = new CodeTypeReference (string.Empty);
CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
coll.Add (ref1);
Assert.AreEqual (1, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (ref1), "#2");
coll.Insert (0, ref2);
Assert.AreEqual (2, coll.Count, "#3");
Assert.AreEqual (1, coll.IndexOf (ref1), "#4");
Assert.AreEqual (0, coll.IndexOf (ref2), "#5");
}
public void Add_Null ()
{
CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection ();
coll.Add ((CodeTypeReference) null);
}
private CodeTypeReferenceCollection GetCodeTypeReferenceInCodeStatement(CodeStatement statement)
{
CodeTypeReferenceCollection references = new CodeTypeReferenceCollection();
// Is this a variable declaration statement?
if (typeof(CodeVariableDeclarationStatement) == statement.GetType())
{
// Add CodeTypeReference used to define the type of the variable to output.
CodeVariableDeclarationStatement vdeclStatement = (CodeVariableDeclarationStatement)statement;
references.Add(vdeclStatement.Type);
// Do we have an initialization expression?
if (vdeclStatement.InitExpression != null)
{
// Add CodeTypeReference in the initialization statement if available.
CodeTypeReference r = GetCodeTypeReferenceInCodeExpression(vdeclStatement.InitExpression);
Debug.Assert(r != null, "Could not obtain a proper CodeTypeReference from the variable initialization expression.");
if (r == null)
{
Debugger.Break();
}
references.Add(r);
}
}
//// Is this a return statement?
//else if (typeof(CodeMethodReturnStatement) == statement.GetType())
//{
// CodeMethodReturnStatement retStatement = (CodeMethodReturnStatement)statement;
// // Add CodeTypeReference in the return statement if available.
// CodeTypeReference r = GetCodeTypeReferenceInCodeExpression(retStatement.Expression);
// Debug.Assert(r != null, "Could not obtain a proper CodeTypeReference from the variable initialization expression.");
// references.Add(r);
//}
// Finally return the references.
return references;
}
protected virtual void AddPageBaseTypes (CodeTypeReferenceCollection baseTypes)
{
baseTypes.Add (PageBaseClass);
baseTypes.Add (typeof(System.Web.IHttpHandler));
switch (parser.EnableSessionState) {
case PagesEnableSessionState.ReadOnly:
baseTypes.Add (typeof(IReadOnlySessionState));
break;
case PagesEnableSessionState.True:
baseTypes.Add (typeof(IRequiresSessionState));
break;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Declares the co class object.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="nameSpace">The name space.</param>
/// <param name="attributes">The attributes.</param>
/// <returns>The type declaration for the CoClass object. The CoClass object gets
/// named after the interface it implements with a leading underscore and "Class"
/// appended.</returns>
/// ------------------------------------------------------------------------------------
public CodeTypeDeclaration DeclareCoClassObject(CodeTypeDeclaration type,
CodeNamespace nameSpace, IDictionary attributes)
{
string coClassName = GetCoClassObjectName(type);
CodeTypeDeclaration coClass = new CodeTypeDeclaration(coClassName);
coClass.IsClass = true;
coClass.TypeAttributes = TypeAttributes.NestedAssembly;
coClass.CustomAttributes.Add(new CodeAttributeDeclaration("ComImport"));
coClass.CustomAttributes.Add(new CodeAttributeDeclaration("ClassInterface",
new CodeAttributeArgument(new CodeSnippetExpression("ClassInterfaceType.None"))));
coClass.CustomAttributes.Add(new CodeAttributeDeclaration("TypeLibType",
new CodeAttributeArgument(new CodeSnippetExpression("TypeLibTypeFlags.FCanCreate"))));
coClass.BaseTypes.Add(type.BaseTypes[0]);
coClass.BaseTypes.Add(new CodeTypeReference(type.Name));
// Prepare to remove redundant superclasses
CodeTypeReferenceCollection bases = new CodeTypeReferenceCollection();
Dictionary<string, StringCollection> allBases = new Dictionary<string, StringCollection>();
foreach (CodeTypeReference baseType in type.BaseTypes)
allBases[baseType.BaseType] = AllBases(baseType.BaseType, nameSpace);
foreach (CodeTypeReference baseType in type.BaseTypes)
{
bool fRedundant = false;
foreach (CodeTypeReference other in type.BaseTypes)
{
// Is this base class contained in another?
if (other != baseType && allBases[other.BaseType].Contains(baseType.BaseType))
{
fRedundant = true;
break;
}
}
if (!fRedundant)
bases.Add(baseType);
}
string interfaceType;
foreach (CodeTypeReference baseType in bases)
{
CodeTypeMemberCollection tmpColl = GetBaseMembers(baseType.BaseType, nameSpace,
out interfaceType);
if (tmpColl != null)
{
// adjust attributes
foreach (CodeTypeMember member in tmpColl)
{
//member.Attributes &= ~MemberAttributes.New;
member.Attributes = MemberAttributes.Public;
member.UserData.Add("extern", true);
AddMethodImplAttr(member, false);
}
tmpColl.AddRange(coClass.Members);
coClass.Members.Clear();
coClass.Members.AddRange(tmpColl);
}
}
// Add a region around this class
coClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start,
"Private " + coClassName + " class"));
coClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, coClassName));
AddAttributesToType(coClass, attributes);
return coClass;
}
