public FoundInfo(bool exists, TypeInfo TypeInfo=null, using_namespace un=null)
{
this.exists = exists;
if (exists)
{
type_infos = new List<TypeNamespaceInfo>();
type_infos.Add(new TypeNamespaceInfo(TypeInfo,un));
}
}
public namespace_unit_node(using_namespace namespace_name)
{
this.namespace_name = namespace_name;
}
///<summary>
///Searches the entire sorted ArrayList for an element using the specified comparer and returns the zero-based index of the element.
///</summary>
///<param name="index">The zero-based starting index of the range to search.<param>
///<param name="count">The length of the range to search.<param>
///<param name="value">The Object to locate. The value can be a null reference.<param>
///<param name="comparer">The IComparer implementation to use when comparing elements. -or- A null reference (Nothing in Visual Basic) to use the default comparer that is the IComparable implementation of each element.<param>
///<returns>The zero-based index of value in the sorted using_namespaceArrayList, if value is found; otherwise, a negative number, which is the bitwise complement of the index of the next element that is larger than value or, if there is no larger element, the bitwise complement of Count.</returns>
public void BinarySearch(int index,int count,using_namespace value,System.Collections.IComparer comparer)
{
arr.BinarySearch(value,comparer);
}
///<summary>
///Uses a binary search algorithm to locate a specific element in the sorted using_namespaceArrayList or a portion of it.
///</summary>
///<param name="value">The Object to locate. The value can be a null reference.<param>
///<returns>The zero-based index of value in the sorted using_namespaceArrayList, if value is found; otherwise, a negative number, which is the bitwise complement of the index of the next element that is larger than value or, if there is no larger element, the bitwise complement of Count.</returns>
public int BinarySearch(using_namespace value)
{
return arr.BinarySearch(value);
}
public void SetRange(int index,using_namespace[] tnarr)
{
SetRange(index,tnarr);
}
///<summary>
///Adds the elements of an using_namespace[] to the end of the using_namespaceArrayList
///</summary>
///<param name="array">The using_namespace[] whose elements should be added to the end of the ArrayList. The using_namespace[] itself cannot be a null reference, but it can contain elements that are a null reference.<param>
///<returns>Return value is void</returns>
public void AddRange(using_namespace[] array)
{
arr.AddRange(array);
}
///<summary>
///Searches for the specified using_namespace and returns the zero-based index of the first occurrence within the section of the using_namespaceArrayList that extends from the specified index to the last element.
///</summary>
///<param name="value">The using_namespace to locate in the using_namespaceArrayList. The value can be a null reference.<param>
///<param name="startIndex">The zero-based starting index of the search.<param>
///<returns>The zero-based index of the first occurrence of value within the section of the using_namespaceArrayList that extends from startIndex to the last element, if found; otherwise, -1.</returns>
public int IndexOf(using_namespace value,int startIndex)
{
return arr.IndexOf(value,startIndex);
}
///<summary>
///Removes the first occurrence of a specific object from the ArrayList.
///</summary>
///<param name="value">The using_namespace to remove from the ArrayList. The value can be a null reference.<param>
///<returns>Return value is void</returns>
public void Remove(using_namespace value)
{
arr.Remove(value);
}
///<summary>
///Copies the entire ArrayList to a compatible one-dimensional using_namespace[], starting at the specified index of the target array.
///</summary>
///<param name="array">The one-dimensional using_namespace[] that is the destination of the elements copied from using_namespaceArrayList. The Array must have zero-based indexing.<param>
///<param name="arrayIndex">The zero-based index in array at which copying begins.<param>
///<returns>Return value is void</returns>
public void CopyTo(using_namespace[] array,int arrayIndex)
{
arr.CopyTo(array,arrayIndex);
}
///<summary>
///Adds an using_namespace to the end of the using_namespaceArrayList.
///</summary>
///<param name="value">The using_namespace to be added to the end of the ArrayList. The value can be a null reference.<param>
///<returns>The using_namespaceArrayList index at which the value has been added.</returns>
public int Add(using_namespace value)
{
return arr.Add(value);
}
///<summary>
///Searches for the specified using_namespace and returns the zero-based index of the last occurrence within the section of the using_namespaceArrayList that contains the specified number of elements and ends at the specified index.
///</summary>
///<param name="value">The using_namespace to locate in the using_namespaceArrayList. The value can be a null reference.<param>
///<param name="startIndex">The zero-based starting index of the backward search.<param>
///<param name="count">The number of elements in the section to search.<param>
///<returns>The zero-based index of the last occurrence of value within the section of the using_namespaceArrayList that extends from the first element to startIndex, if found; otherwise, -1.</returns>
public int LastIndexOf(using_namespace value,int startIndex,int count)
{
return arr.LastIndexOf(value,startIndex,count);
}
///<summary>
///Searches for the specified using_namespace and returns the zero-based index of the last occurrence within the entire using_namespaceArrayList.
///</summary>
///<param name="value">The using_namespace to locate in the using_namespaceArrayList. The value can be a null reference.<param>
///<returns>The zero-based index of the last occurrence of value within the entire the ArrayList, if found; otherwise, -1.</returns>
public int LastIndexOf(using_namespace value)
{
return arr.LastIndexOf(value);
}
///<summary>
///Inserts the elements of a using_namespace into the using_namespaceArrayList at the specified index.
///</summary>
///<param name="index">The zero-based index at which the new elements should be inserted.<param>
///<param name="arr">The using_namespace[] whose elements should be inserted into the using_namespaceArrayList. The using_namespace[] itself cannot be a null reference, but it can contain elements that are a null reference.<param>
///<returns>Return value is void</returns>
public void InsertRange(int index,using_namespace[] using_namespace_arr)
{
arr.InsertRange(index,arr);
}
///<summary>
///Inserts an element into the using_namespaceArrayList at the specified index.
///</summary>
///<param name="index">The zero-based index at which value should be inserted.<param>
///<param name="value">The using_namespace to insert. The value can be a null reference.<param>
///<returns>Return value is void</returns>
public void Insert(int index,using_namespace value)
{
arr.Insert(index,value);
}
public namespace_unit_node(using_namespace namespace_name, location loc)
{
this.namespace_name = namespace_name;
this.loc = loc;
}
///<summary>
///Copies the entire using_namespaceArrayList to a compatible one-dimensional using_namespace[], starting at the beginning of the target array.
///</summary>
///<param name="array">The one-dimensional using_namespace[] that is the destination of the elements copied from using_namespaceArrayList. The Array must have zero-based indexing.<param>
///<returns>Return value is void</returns>
public void CopyTo(using_namespace[] array)
{
arr.CopyTo(array);
}
public TypeNamespaceInfo(TypeInfo type_info, using_namespace us_ns)
{
this.type_info = type_info;
this.us_ns = us_ns;
}
///<summary>
///Copies the entire ArrayList to a compatible one-dimensional using_namespace[], starting at the specified index of the target array.
///</summary>
///<param name="index">The zero-based index in the source ArrayList at which copying begins.<param>
///<param name="array">The one-dimensional using_namespace[] that is the destination of the elements copied from using_namespaceArrayList. The Array must have zero-based indexing.<param>
///<param name="arrayIndex">The zero-based index in array at which copying begins.<param>
///<param name="count">The number of elements to copy.<param>
///<returns>Return value is void</returns>
public void CopyTo(int index,using_namespace[] array,int arrayIndex,int count)
{
arr.CopyTo(index,array,arrayIndex,count);
}
public namespace_unit_node(using_namespace namespace_name)
{
this.namespace_name = namespace_name;
}
///<summary>
///Determines whether an element is in the using_namespaceArrayList.
///</summary>
///<param name="item">The using_namespace to locate in the ArrayList. The value can be a null reference.<param>
///<returns>true if item is found in the using_namespaceArrayList; otherwise, false.</returns>
public bool Contains(using_namespace item)
{
return arr.Contains(item);
}