static int CompareUsings(IUsing a, IUsing b)
{
if (a.HasAliases != b.HasAliases)
{
return(a.HasAliases ? 1 : -1);
}
if (a.Usings.Count != 0 && b.Usings.Count != 0)
{
string u1 = a.Usings[0];
string u2 = b.Usings[0];
if (IsSystemNamespace(u1) && !IsSystemNamespace(u2))
{
return(-1);
}
else if (!IsSystemNamespace(u1) && IsSystemNamespace(u2))
{
return(1);
}
return(u1.CompareTo(u2));
}
if (a.Aliases.Count != 0 && b.Aliases.Count != 0)
{
return(a.Aliases.Keys.First().CompareTo(b.Aliases.Keys.First()));
}
return(0);
}
public static void AddUsing(ArrayList result, IUsing u, IProjectContent projectContent)
{
if (u == null)
{
return;
}
bool importNamespaces = projectContent.Language.ImportNamespaces;
bool importClasses = projectContent.Language.CanImportClasses;
foreach (string name in u.Usings)
{
if (importClasses)
{
IClass c = projectContent.GetClass(name, 0);
if (c != null)
{
ArrayList members = new ArrayList();
IReturnType t = c.DefaultReturnType;
members.AddRange(t.GetMethods());
members.AddRange(t.GetFields());
members.AddRange(t.GetEvents());
members.AddRange(t.GetProperties());
foreach (IMember m in members)
{
if (m.IsStatic && m.IsPublic)
{
result.Add(m);
}
}
continue;
}
}
if (importNamespaces)
{
string newName = null;
if (projectContent.DefaultImports != null)
{
newName = projectContent.DefaultImports.SearchNamespace(name);
}
projectContent.AddNamespaceContents(result, newName ?? name, projectContent.Language, true);
}
else
{
foreach (object o in projectContent.GetNamespaceContents(name))
{
if (!(o is string))
{
result.Add(o);
}
}
}
}
if (u.HasAliases)
{
foreach (string alias in u.Aliases.Keys)
{
result.Add(alias);
}
}
}
public static FoldingRegion ToFold(this IEnumerable <IUsing> usings)
{
if (usings == null)
{
return(null);
}
var en = usings.GetEnumerator();
if (!en.MoveNext())
{
return(null);
}
IUsing first = en.Current;
IUsing last = first;
while (en.MoveNext())
{
if (en.Current.IsFromNamespace)
{
break;
}
last = en.Current;
}
if (first.Region.IsEmpty || last.Region.IsEmpty || first.Region.Start.Line == last.Region.End.Line)
{
return(null);
}
return(new FoldingRegion(new DomRegion(first.Region.Start, last.Region.End)));
}
static int UsingComparer(IUsing left, IUsing right)
{
if (left.Aliases.Any() && right.Aliases.Any())
{
return(left.Aliases.First().Key.CompareTo(right.Aliases.First().Key));
}
if (left.Aliases.Any())
{
return(1);
}
if (right.Aliases.Any())
{
return(-1);
}
bool leftIsSystem = left.Namespaces.First().StartsWith("System");
bool rightIsSystem = right.Namespaces.First().StartsWith("System");
if (leftIsSystem && !rightIsSystem)
{
return(-1);
}
if (!leftIsSystem && rightIsSystem)
{
return(1);
}
return(left.Namespaces.First().CompareTo(right.Namespaces.First()));
}
public virtual INode Visit(IUsing u, string data)
{
data += u.ToString() + "/";
foreach (KeyValuePair <string, IReturnType> val in u.Aliases)
{
val.Value.AcceptVisitor(this, data + "Aliases/");
}
return(null);
}
public override void AddGlobalNamespaceImport(RefactorerContext ctx, string fileName, string nsName)
{
IEditableTextFile file = ctx.GetFile(fileName);
int pos = 0;
ParsedDocument parsedDocument = parser.Parse(ctx.ParserContext, fileName, file.Text);
StringBuilder text = new StringBuilder();
if (parsedDocument.CompilationUnit != null)
{
IUsing lastUsing = null;
foreach (IUsing u in parsedDocument.CompilationUnit.Usings)
{
if (u.IsFromNamespace)
{
break;
}
lastUsing = u;
}
if (lastUsing != null)
{
pos = file.GetPositionFromLineColumn(lastUsing.Region.End.Line, lastUsing.Region.End.Column);
}
}
if (pos != 0)
{
text.AppendLine();
}
text.Append("using ");
text.Append(nsName);
text.Append(";");
if (file is Mono.TextEditor.ITextEditorDataProvider)
{
Mono.TextEditor.TextEditorData data = ((Mono.TextEditor.ITextEditorDataProvider)file).GetTextEditorData();
if (pos == 0)
{
text.Append(data.EolMarker);
}
int caretOffset = data.Caret.Offset;
int insertedChars = data.Insert(pos, text.ToString());
if (pos < caretOffset)
{
data.Caret.Offset = caretOffset + insertedChars;
}
}
else
{
if (pos == 0)
{
text.AppendLine();
}
file.InsertText(pos, text.ToString());
}
}
static bool CheckImports(IUsing u)
{
if (u == null)
{
return(false);
}
else
{
return(u.Usings.Contains(NamespaceName));
}
}
public virtual INode Visit(IUsing u, T data)
{
DomUsing result = new DomUsing();
result.Region = u.Region;
result.IsFromNamespace = u.IsFromNamespace;
foreach (string s in u.Namespaces)
{
result.Add(s);
}
foreach (KeyValuePair <string, IReturnType> val in u.Aliases)
{
result.Add(val.Key, val.Value);
}
return(result);
}
public static UsingDeclaration ConvertUsing(IUsing u)
{
List <Using> usings = new List <Using>();
foreach (string name in u.Usings)
{
usings.Add(new Using(name));
}
if (u.HasAliases)
{
foreach (KeyValuePair <string, IReturnType> pair in u.Aliases)
{
usings.Add(new Using(pair.Key, ConvertType(pair.Value, null)));
}
}
return(new UsingDeclaration(usings));
}
static int UsingComparer (IUsing left, IUsing right)
{
if (left.Aliases.Any () && right.Aliases.Any ())
return left.Aliases.First ().Key.CompareTo (right.Aliases.First ().Key);
if (left.Aliases.Any ())
return 1;
if (right.Aliases.Any ())
return -1;
bool leftIsSystem = left.Namespaces.First ().StartsWith ("System");
bool rightIsSystem = right.Namespaces.First ().StartsWith ("System");
if (leftIsSystem && !rightIsSystem)
return -1;
if (!leftIsSystem && rightIsSystem)
return 1;
return left.Namespaces.First ().CompareTo (right.Namespaces.First ());
}
static int CompareUsings(IUsing a, IUsing b)
{
if (a.HasAliases != b.HasAliases)
return a.HasAliases ? 1 : -1;
if (a.Usings.Count != 0 && b.Usings.Count != 0) {
string u1 = a.Usings[0];
string u2 = b.Usings[0];
if (IsSystemNamespace(u1) && !IsSystemNamespace(u2)) {
return -1;
} else if (!IsSystemNamespace(u1) && IsSystemNamespace(u2)) {
return 1;
}
return u1.CompareTo(u2);
}
if (a.Aliases.Count != 0 && b.Aliases.Count != 0) {
return a.Aliases.Keys.First().CompareTo(b.Aliases.Keys.First());
}
return 0;
}
bool SearchTypeInUsing(IUsing u, SearchTypeRequest request, ref SearchTypeResult result)
{
foreach (IReturnType r in u.SearchType(request.Name, request.TypeParameterCount))
{
result = new SearchTypeResult(r, u);
if (MatchesRequest(request, ref result))
{
return(true);
}
}
string nsResult = u.SearchNamespace(request.Name);
if (nsResult != null)
{
result = new SearchTypeResult(nsResult, null);
if (MatchesRequest(request, ref result))
{
return(true);
}
}
return(false);
}
/// <summary>
/// <para>Returns the index of a <see cref='.IUsing'/> in
/// the <see cref='.IUsingCollection'/> .</para>
/// </summary>
/// <param name='value'>The <see cref='.IUsing'/> to locate.</param>
/// <returns>
/// <para>The index of the <see cref='.IUsing'/> of <paramref name='value'/> in the
/// <see cref='.IUsingCollection'/>, if found; otherwise, -1.</para>
/// </returns>
/// <seealso cref='.IUsingCollection.Contains'/>
public int IndexOf(IUsing value)
{
return List.IndexOf(value);
}
/// <summary>
/// <para>Gets a value indicating whether the
/// <see cref='.IUsingCollection'/> contains the specified <see cref='.IUsing'/>.</para>
/// </summary>
/// <param name='value'>The <see cref='.IUsing'/> to locate.</param>
/// <returns>
/// <para><see langword='true'/> if the <see cref='.IUsing'/> is contained in the collection;
/// otherwise, <see langword='false'/>.</para>
/// </returns>
/// <seealso cref='.IUsingCollection.IndexOf'/>
public bool Contains(IUsing value)
{
return List.Contains(value);
}
void AddNamespaceImport(IUsing import)
{
AddCodeElement(new CodeImport(import));
}
public IClass SearchType(IUsing iusing, string partitialTypeName, bool caseSensitive)
{
return pdb.SearchType (db, iusing, partitialTypeName, caseSensitive);
}
void AddNamespaceImport(IUsing import)
{
AddCodeElement(new CodeImport(import));
}
public static void AddUsing(List<ICompletionEntry> result, IUsing u, IProjectContent projectContent)
{
if (u == null) {
return;
}
bool importNamespaces = projectContent.Language.ImportNamespaces;
bool importClasses = projectContent.Language.CanImportClasses;
foreach (string name in u.Usings) {
if (importClasses) {
IClass c = projectContent.GetClass(name, 0);
if (c != null) {
ArrayList members = new ArrayList();
IReturnType t = c.DefaultReturnType;
members.AddRange(t.GetMethods());
members.AddRange(t.GetFields());
members.AddRange(t.GetEvents());
members.AddRange(t.GetProperties());
foreach (IMember m in members) {
if (m.IsStatic && m.IsPublic) {
result.Add(m);
}
}
continue;
}
}
if (importNamespaces) {
string newName = null;
if (projectContent.DefaultImports != null) {
newName = projectContent.DefaultImports.SearchNamespace(name);
}
projectContent.AddNamespaceContents(result, newName ?? name, projectContent.Language, true);
} else {
foreach (ICompletionEntry o in projectContent.GetNamespaceContents(name)) {
if (!(o is NamespaceEntry))
result.Add(o);
}
}
}
if (u.HasAliases) {
foreach (string alias in u.Aliases.Keys) {
result.Add(new AliasEntry(alias));
}
}
}
public void AddAtTop(IUsing newUsing)
{
usings.Insert(0, newUsing);
}
public CodeImport(IUsing import)
{
this.import = import;
this.Namespace = GetNamespace();
}
public SearchTypeResult(IReturnType result, IUsing usedUsing)
{
this.result = result;
this.usedUsing = usedUsing;
}
public string Visit(IUsing u, OutputSettings settings)
{
return("NOT IMPLEMENTED");
}
static bool CheckImports(IUsing u)
{
if (u == null)
return false;
else
return u.Usings.Contains(NamespaceName);
}
public SearchTypeResult(IReturnType result, IUsing usedUsing)
{
this.result = result;
this.usedUsing = usedUsing;
}
/// <summary>
/// <para> Removes a specific <see cref='.IUsing'/> from the
/// <see cref='.IUsingCollection'/> .</para>
/// </summary>
/// <param name='value'>The <see cref='.IUsing'/> to remove from the <see cref='.IUsingCollection'/> .</param>
/// <returns><para>None.</para></returns>
/// <exception cref='System.ArgumentException'><paramref name='value'/> is not found in the Collection. </exception>
public void Remove(IUsing value)
{
List.Remove(value);
}
public virtual S Visit(IUsing u, T data)
{
return(default(S));
}
/// <summary>
/// <para>Adds a <see cref='.IUsing'/> with the specified value to the
/// <see cref='.IUsingCollection'/> .</para>
/// </summary>
/// <param name='value'>The <see cref='.IUsing'/> to add.</param>
/// <returns>
/// <para>The index at which the new element was inserted.</para>
/// </returns>
/// <seealso cref='.IUsingCollection.AddRange'/>
public int Add(IUsing value)
{
return List.Add(value);
}
public SearchTypeResult(IReturnType result, IUsing usedUsing)
{
_result = result;
_usedUsing = usedUsing;
}
public static UsingDirectiveSyntax Create(IUsing element) => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(element.Name));
IType SearchType(IUsing iusing, string partitialTypeName, IList <IReturnType> genericArguments, bool caseSensitive)
{
IType c = GetType(partitialTypeName, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
foreach (string str in iusing.Namespaces)
{
string possibleType = String.Concat(str, ".", partitialTypeName);
c = GetType(possibleType, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
}
IReturnType alias;
// search class in partial namespaces
if (iusing.Aliases.TryGetValue("", out alias))
{
string declaringNamespace = alias.FullName;
while (declaringNamespace.Length > 0)
{
string className = String.Concat(declaringNamespace, ".", partitialTypeName);
c = GetType(className, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
int index = declaringNamespace.IndexOf('.');
if (index > 0)
{
declaringNamespace = declaringNamespace.Substring(0, index);
}
else
{
break;
}
}
}
foreach (string aliasString in iusing.Aliases.Keys)
{
if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower()))
{
string className = null;
if (aliasString.Length > 0)
{
IReturnType rt = iusing.Aliases [aliasString];
className = String.Concat(rt.FullName, partitialTypeName.Remove(0, aliasString.Length));
c = GetType(className, genericArguments, false, caseSensitive);
if (c != null)
{
return(c);
}
}
}
}
return(null);
}
bool SearchTypeInUsing(IUsing u, SearchTypeRequest request, ref SearchTypeResult result)
{
foreach (IReturnType r in u.SearchType(request.Name, request.TypeParameterCount)) {
result = new SearchTypeResult(r, u);
if (MatchesRequest(request, ref result)) {
return true;
}
}
string nsResult = u.SearchNamespace(request.Name);
if (nsResult != null) {
result = new SearchTypeResult(nsResult, null);
if (MatchesRequest(request, ref result)) {
return true;
}
}
return false;
}
public CodeImport(IUsing import)
{
this.import = import;
this.Namespace = GetNamespace();
}
public string SearchNamespace(CodeCompletionDatabase db, IUsing usin, string partitialNamespaceName)
{
return SearchNamespace (db, usin, partitialNamespaceName, true);
}
public override void AddLocalNamespaceImport(RefactorerContext ctx, string fileName, string nsName, DomLocation caretLocation)
{
IEditableTextFile file = ctx.GetFile(fileName);
int pos = 0;
ParsedDocument parsedDocument = parser.Parse(ctx.ParserContext, fileName, file.Text);
StringBuilder text = new StringBuilder();
string indent = "";
if (parsedDocument.CompilationUnit != null)
{
IUsing containingUsing = null;
foreach (IUsing u in parsedDocument.CompilationUnit.Usings)
{
if (u.IsFromNamespace && u.Region.Contains(caretLocation))
{
containingUsing = u;
}
}
if (containingUsing != null)
{
indent = GetLineIndent(file, containingUsing.Region.Start.Line);
IUsing lastUsing = null;
foreach (IUsing u in parsedDocument.CompilationUnit.Usings)
{
if (u == containingUsing)
{
continue;
}
if (containingUsing.Region.Contains(u.Region))
{
if (u.IsFromNamespace)
{
break;
}
lastUsing = u;
}
}
if (lastUsing != null)
{
pos = file.GetPositionFromLineColumn(lastUsing.Region.End.Line, lastUsing.Region.End.Column);
}
else
{
pos = file.GetPositionFromLineColumn(containingUsing.ValidRegion.Start.Line, containingUsing.ValidRegion.Start.Column);
// search line end
while (pos < file.Length)
{
char ch = file.GetCharAt(pos);
if (ch == '\n')
{
if (file.GetCharAt(pos + 1) == '\r')
{
pos++;
}
break;
}
else if (ch == '\r')
{
break;
}
pos++;
}
}
}
else
{
AddGlobalNamespaceImport(ctx, fileName, nsName);
return;
}
}
if (pos != 0)
{
text.AppendLine();
}
text.Append(indent);
text.Append("\t");
text.Append("using ");
text.Append(nsName);
text.Append(";");
if (file is Mono.TextEditor.ITextEditorDataProvider)
{
Mono.TextEditor.TextEditorData data = ((Mono.TextEditor.ITextEditorDataProvider)file).GetTextEditorData();
if (pos == 0)
{
text.Append(data.EolMarker);
}
int caretOffset = data.Caret.Offset;
int insertedChars = data.Insert(pos, text.ToString());
if (pos < caretOffset)
{
data.Caret.Offset = caretOffset + insertedChars;
}
}
else
{
if (pos == 0)
{
text.AppendLine();
}
file.InsertText(pos, text.ToString());
}
}
public IClass SearchType(IUsing iusing, string partitialTypeName)
{
return pdb.SearchType (db, iusing, partitialTypeName);
}
public SearchTypeResult(IReturnType result, IUsing usedUsing)
{
this.result = result;
this.usedUsing = usedUsing;
this.namespaceResult = null;
}
/// <summary>
/// <para>Copies the elements of an array to the end of the <see cref='.IUsingCollection'/>.</para>
/// </summary>
/// <param name='value'>
/// An array of type <see cref='.IUsing'/> containing the objects to add to the collection.
/// </param>
/// <returns>
/// <para>None.</para>
/// </returns>
/// <seealso cref='.IUsingCollection.Add'/>
public void AddRange(IUsing[] value)
{
for (int i = 0; (i < value.Length); i = (i + 1)) {
this.Add(value[i]);
}
}
public IClass SearchType(CodeCompletionDatabase db, IUsing iusing, string partitialTypeName, bool caseSensitive)
{
// Runtime.LoggingService.Info("Search type : >{0}<", partitialTypeName);
IClass c = GetClass (db, partitialTypeName, caseSensitive);
if (c != null) {
return c;
}
foreach (string str in iusing.Usings) {
string possibleType = String.Concat(str, ".", partitialTypeName);
// Runtime.LoggingService.Info("looking for " + possibleType);
c = GetClass (db, possibleType, caseSensitive);
if (c != null) {
// Runtime.LoggingService.Info("Found!");
return c;
}
}
// search class in partitial namespaces
string declaringNamespace = (string)iusing.Aliases[""];
if (declaringNamespace != null) {
while (declaringNamespace.Length > 0) {
string className = String.Concat(declaringNamespace, ".", partitialTypeName);
// Runtime.LoggingService.Info("looking for " + className);
c = GetClass (db, className, caseSensitive);
if (c != null) {
// Runtime.LoggingService.Info("Found!");
return c;
}
int index = declaringNamespace.IndexOf('.');
if (index > 0) {
declaringNamespace = declaringNamespace.Substring(0, index);
} else {
break;
}
}
}
foreach (DictionaryEntry entry in iusing.Aliases) {
string aliasString = entry.Key.ToString();
if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower())) {
string className = null;
if (aliasString.Length > 0) {
className = String.Concat(entry.Value.ToString(), partitialTypeName.Remove(0, aliasString.Length));
// Runtime.LoggingService.Info("looking for " + className);
c = GetClass (db, className, caseSensitive);
if (c != null) {
// Runtime.LoggingService.Info("Found!");
return c;
}
}
}
}
return null;
}
/// <summary>
/// <para>Copies the <see cref='.IUsingCollection'/> values to a one-dimensional <see cref='System.Array'/> instance at the
/// specified index.</para>
/// </summary>
/// <param name='array'><para>The one-dimensional <see cref='System.Array'/> that is the destination of the values copied from <see cref='.IUsingCollection'/> .</para></param>
/// <param name='index'>The index in <paramref name='array'/> where copying begins.</param>
/// <returns>
/// <para>None.</para>
/// </returns>
/// <exception cref='System.ArgumentException'><para><paramref name='array'/> is multidimensional.</para> <para>-or-</para> <para>The number of elements in the <see cref='.IUsingCollection'/> is greater than the available space between <paramref name='arrayIndex'/> and the end of <paramref name='array'/>.</para></exception>
/// <exception cref='System.ArgumentNullException'><paramref name='array'/> is <see langword='null'/>. </exception>
/// <exception cref='System.ArgumentOutOfRangeException'><paramref name='arrayIndex'/> is less than <paramref name='array'/>'s lowbound. </exception>
/// <seealso cref='System.Array'/>
public void CopyTo(IUsing[] array, int index)
{
List.CopyTo(array, index);
}
public string SearchNamespace(IUsing iusing, string partitialNamespaceName, bool caseSensitive)
{
return pdb.SearchNamespace (db, iusing, partitialNamespaceName, caseSensitive);
}
/// <summary>
/// <para>Inserts a <see cref='.IUsing'/> into the <see cref='.IUsingCollection'/> at the specified index.</para>
/// </summary>
/// <param name='index'>The zero-based index where <paramref name='value'/> should be inserted.</param>
/// <param name=' value'>The <see cref='.IUsing'/> to insert.</param>
/// <returns><para>None.</para></returns>
/// <seealso cref='.IUsingCollection.Add'/>
public void Insert(int index, IUsing value)
{
List.Insert(index, value);
}
public SearchTypeResult(string namespaceResult, IUsing usedUsing)
{
this.result = null;
this.usedUsing = usedUsing;
this.namespaceResult = namespaceResult;
}
/// <summary>
/// <para>
/// Initializes a new instance of <see cref='.IUsingCollection'/> containing any array of <see cref='.IUsing'/> objects.
/// </para>
/// </summary>
/// <param name='value'>
/// A array of <see cref='.IUsing'/> objects with which to intialize the collection
/// </param>
public IUsingCollection(IUsing[] value)
{
this.AddRange(value);
}
public IClass SearchType(CodeCompletionDatabase db, IUsing iusing, string partitialTypeName)
{
return SearchType (db, iusing, partitialTypeName, true);
}
public void Add(IUsing newUsing)
{
usings.Add(newUsing);
}
public string SearchNamespace(CodeCompletionDatabase db, IUsing usin, string partitialNamespaceName, bool caseSensitive)
{
// Runtime.LoggingService.Info("SearchNamespace : >{0}<", partitialNamespaceName);
if (NamespaceExists (db, partitialNamespaceName, caseSensitive)) {
return partitialNamespaceName;
}
// search for partitial namespaces
string declaringNamespace = (string)usin.Aliases[""];
if (declaringNamespace != null) {
while (declaringNamespace.Length > 0) {
if ((caseSensitive ? declaringNamespace.EndsWith(partitialNamespaceName) : declaringNamespace.ToLower().EndsWith(partitialNamespaceName.ToLower()) ) && NamespaceExists (db, declaringNamespace, caseSensitive)) {
return declaringNamespace;
}
int index = declaringNamespace.IndexOf('.');
if (index > 0) {
declaringNamespace = declaringNamespace.Substring(0, index);
} else {
break;
}
}
}
// Remember:
// Each namespace has an own using object
// The namespace name is an alias which has the key ""
foreach (DictionaryEntry entry in usin.Aliases) {
string aliasString = entry.Key.ToString();
if (caseSensitive ? partitialNamespaceName.StartsWith(aliasString) : partitialNamespaceName.ToLower().StartsWith(aliasString.ToLower())) {
if (aliasString.Length >= 0) {
string nsName = nsName = String.Concat(entry.Value.ToString(), partitialNamespaceName.Remove(0, aliasString.Length));
if (NamespaceExists (db, nsName, caseSensitive)) {
return nsName;
}
}
}
}
return null;
}
IType SearchType (IUsing iusing, string partitialTypeName, IList<IReturnType> genericArguments, bool caseSensitive)
{
IType c = GetType (partitialTypeName, genericArguments, false, caseSensitive);
if (c != null) {
return c;
}
foreach (string str in iusing.Namespaces) {
string possibleType = String.Concat(str, ".", partitialTypeName);
c = GetType (possibleType, genericArguments, false, caseSensitive);
if (c != null)
return c;
}
IReturnType alias;
// search class in partial namespaces
if (iusing.Aliases.TryGetValue ("", out alias)) {
string declaringNamespace = alias.FullName;
while (declaringNamespace.Length > 0) {
string className = String.Concat(declaringNamespace, ".", partitialTypeName);
c = GetType (className, genericArguments, false, caseSensitive);
if (c != null)
return c;
int index = declaringNamespace.IndexOf('.');
if (index > 0) {
declaringNamespace = declaringNamespace.Substring(0, index);
} else {
break;
}
}
}
foreach (string aliasString in iusing.Aliases.Keys) {
if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower())) {
string className = null;
if (aliasString.Length > 0) {
IReturnType rt = iusing.Aliases [aliasString];
className = String.Concat (rt.FullName, partitialTypeName.Remove (0, aliasString.Length));
c = GetType (className, genericArguments, false, caseSensitive);
if (c != null)
return c;
}
}
}
return null;
}
public UsingHelper()
{
Using = MockRepository.GenerateStub <IUsing>();
Using.Stub(u => u.Usings).Return(Namespaces);
}
public SearchTypeResult(string namespaceResult, IUsing usedUsing)
{
this.result = null;
this.usedUsing = usedUsing;
this.namespaceResult = namespaceResult;
}
public string Visit(IUsing u, OutputSettings settings)
{
return("TODO");
}
public SearchTypeResult(IReturnType result, IUsing usedUsing)
{
this.result = result;
this.usedUsing = usedUsing;
this.namespaceResult = null;
}
public string SearchNamespace(IUsing iusing, string partitialNamespaceName)
{
return pdb.SearchNamespace (db, iusing, partitialNamespaceName);
}
