public bool Equals(CodeTypeReference x, CodeTypeReference y)
{
if (Object.ReferenceEquals(x, y))
{
return(true);
}
if (x == null || y == null || x.ArrayRank != y.ArrayRank || x.BaseType != y.BaseType)
{
return(false);
}
CodeTypeReferenceCollection xTypeArgs = x.TypeArguments;
CodeTypeReferenceCollection yTypeArgs = y.TypeArguments;
if (yTypeArgs.Count == xTypeArgs.Count)
{
foreach (CodeTypeReference xTypeArg in xTypeArgs)
{
foreach (CodeTypeReference yTypeArg in yTypeArgs)
{
if (!this.Equals(xTypeArg, xTypeArg))
{
return(false);
}
}
}
}
return(true);
}
private string GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments)
{
StringBuilder sb = new StringBuilder(128);
GetTypeArgumentsOutput(typeArguments, 0, typeArguments.Count, sb);
return(sb.ToString());
}
private static void ValidateTypeReferences(CodeTypeReferenceCollection refs)
{
for (int i = 0; i < refs.Count; i++)
{
ValidateTypeReference(refs[i]);
}
}
/// <summary>
/// Interfaces do not exist in python, however multi inheritance does. Instead of
/// using interfaces, use multi intheritance.
/// </summary>
private static void ReplaceInterfaceParameters(CodeTypeDeclaration e)
{
List <string> parameters = new List <string>();
CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection();
for (int i = 0; i < e.BaseTypes.Count; i++)
{
string baseType = null;
if (e.BaseTypes[i].BaseType.StartsWith("I") && Char.IsUpper(e.BaseTypes[i].BaseType[1]))
{
baseType = e.BaseTypes[i].BaseType.Remove(0, 1); //remove the first character ("I")
e.BaseTypes[i].BaseType = baseType; //assigning directly causes a bug
}
//if after removing the char I from an Interface, the type already exists remove it
if (!(parameters.Contains(baseType) || e.BaseTypes[i].BaseType.Equals(e.Name)))
{
parameters.Add(e.BaseTypes[i].BaseType);
coll.Add(e.BaseTypes[i]);
}
}
//copy coll in e.BaseTypes
e.BaseTypes.Clear();
foreach (CodeTypeReference tRef in coll)
{
e.BaseTypes.Add(tRef);
}
}
public FCO(
MgaObject subject,
CodeTypeReferenceCollection baseTypes,
CodeTypeReferenceCollection attributes) :
base(subject, baseTypes, attributes)
{
}
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");
}
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('>');
}
private void RefactorCodeTypeReferenceCollection(CodeTypeReferenceCollection codeTypeReferences, string oldName, string newName)
{
foreach (CodeTypeReference codeTypeReference in codeTypeReferences)
{
RefactorCodeTypeReference(codeTypeReference, oldName, newName);
}
}
public bool Equals(CodeTypeReference x, CodeTypeReference y)
{
if (!object.ReferenceEquals(x, y))
{
if (((x == null) || (y == null)) || ((x.ArrayRank != y.ArrayRank) || (x.BaseType != y.BaseType)))
{
return(false);
}
CodeTypeReferenceCollection typeArguments = x.TypeArguments;
CodeTypeReferenceCollection references2 = y.TypeArguments;
if (references2.Count == typeArguments.Count)
{
foreach (CodeTypeReference reference in typeArguments)
{
using (IEnumerator enumerator2 = references2.GetEnumerator())
{
while (enumerator2.MoveNext())
{
CodeTypeReference current = (CodeTypeReference)enumerator2.Current;
if (!this.Equals(reference, reference))
{
return(false);
}
}
}
}
}
}
return(true);
}
static CodeTypeReference[] _ToArray(CodeTypeReferenceCollection refs)
{
var result = new CodeTypeReference[refs.Count];
refs.CopyTo(result, 0);
return(result);
}
public static CodeTypeReferenceCollection ResolveUsings(this CodeTypeReferenceCollection @this, params string[] usings)
{
foreach (CodeTypeReference reference in @this)
{
ResolveUsings(reference, usings);
}
return(@this);
}
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 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 void Constructor1_NullItem()
{
CodeTypeReference[] refs = new CodeTypeReference[] {
new CodeTypeReference(string.Empty), null
};
CodeTypeReferenceCollection coll = new CodeTypeReferenceCollection(
refs);
}
/// <summary>
/// Get text of CodeTypeReferenceCollection in CSV
/// </summary>
/// <param name="collection"></param>
/// <returns></returns>
internal static string MapCodeTypeReferenceCollectionToTsText(CodeTypeReferenceCollection collection)
{
string[] ss = new string[collection.Count];
for (int i = 0; i < collection.Count; i++)
{
ss[i] = MapCodeTypeReferenceToTsText(collection[i]);
}
return(String.Join(", ", ss));
}
private void IterateTypeRefImpl(CodeTypeReferenceCollection col, List <object> list)
{
ThrowIfNull(col);
ThrowIfNull(list);
foreach (CodeTypeReference typeRef in col)
{
IterateTypeRefImpl(typeRef, list);
}
}
public static int IndexOf(this CodeTypeReferenceCollection references, string typeName)
{
for (int i = 0; i < references.Count; i++)
{
if (references[i].BaseType == typeName)
{
return(i);
}
}
return(-1);
}
public static bool ContainsType(this CodeTypeReferenceCollection collection, string type)
{
foreach (CodeTypeReference reference in collection)
{
if (reference.ContainsType(type))
{
return(true);
}
}
return(false);
}
public static void ReplaceType(this CodeTypeReferenceCollection collection, string oldType, string newType)
{
if (collection == null)
{
return;
}
foreach (CodeTypeReference reference in collection)
{
reference.ReplaceType(oldType, newType);
}
}
public static void AddBaseClass(this CodeTypeDeclaration pCodeType, string strBaseTypeName)
{
CodeTypeReferenceCollection pCollectionBackup = new CodeTypeReferenceCollection(pCodeType.BaseTypes);
pCodeType.BaseTypes.Clear();
CodeTypeReference pBaseTypeRef = new CodeTypeReference(strBaseTypeName);
pCodeType.BaseTypes.Add(pBaseTypeRef);
pCodeType.BaseTypes.AddRange(pCollectionBackup);
}
private void HandleImplementationTypes(CodeTypeReferenceCollection implementationTypes, string name, Context ctx)
{
if (implementationTypes.Count > 0)
{
ctx.Writer.Write(" Implements ");
for (int i = 0; i < implementationTypes.Count; i++)
{
ctx.HandlerProvider.TypeReferenceHandler.Handle(implementationTypes[i], ctx);
ctx.Writer.Write($".{name}");
}
}
}
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);
}
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(nameof(value));
}
int currentCount = value.Count;
for (int i = 0; i < currentCount; i++)
{
Add(value[i]);
}
}
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");
}
internal static string MapCodeTypeReferenceCollectionToTupleTsText(CodeTypeReferenceCollection collection)
{
if (collection.Count > 8)
{
throw new ArgumentException("Current supports only up to 8 members for tuple.", nameof(collection));
}
string[] ss = new string[collection.Count];
for (int i = 0; i < collection.Count; i++)
{
var typeName = MapCodeTypeReferenceToTsText(collection[i]);
var propertyName = (i < 7) ? "Item" + (i + 1).ToString() : "Rest";
ss[i] = (TsCodeGenerationOptions.Instance.CamelCase ? Fonlow.Text.StringExtensions.ToCamelCase(propertyName) : propertyName)
+ ": " + typeName;
}
return(String.Join(", ", ss));
}
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");
}
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;
}
}
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");
}
private static void ValidateTypeReferences(CodeTypeReferenceCollection refs)
{
for (int i = 0; i < refs.Count; i++)
{
ValidateTypeReference(refs[i]);
}
}
public CodeTypeReferenceCollection(CodeTypeReferenceCollection value) {}
public void AddRange(CodeTypeReferenceCollection value) {}
private String GetTypeArgumentsOutput(CodeTypeReferenceCollection typeArguments)
{
StringBuilder sb = new StringBuilder(128);
GetTypeArgumentsOutput(typeArguments, 0, typeArguments.Count, sb);
return sb.ToString();
}
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('>');
}
