public MethodRow(MDTable parent)
		{
			table = parent;
		}

		internal void AddToTable(MDTable tableIx, MetaDataElement elem) 
		{
			if (elem.Row > 0) {
				// Console.Out.WriteLine("ERROR - element already in table " + tableIx);
				return;
			}
			// updates Row field of the element
			// Console.WriteLine("Adding element to table " + (uint)tableIx);
			ArrayList table = GetTable(tableIx);
			elem.Row = (uint)table.Count + 1;
			table.Add(elem);
		}

		internal uint TableIndexSize(MDTable tabIx) 
		{
			if (largeIx[(uint)tabIx]) return 4;
			return 2;
		}

 internal void AddToList(ArrayList list, MDTable tabIx)
 {
     Contract.Requires(list != null);
     switch (tabIx)
     {
         case (MDTable.Field): fields.AddRange(list); break;
         case (MDTable.Method): methods.AddRange(list); break;
         case (MDTable.TypeDef): nestedClasses.AddRange(list); break;
         default: throw new Exception("Unknown list type");
     }
 }

		internal MapElem(ClassDef par, uint elIx, MDTable elemTab) 
		{
			parent = par;
			elemIx = elIx;
			elemTable = elemTab;
		}

 internal void AddToFeatureList(ArrayList list, MDTable tabIx)
 {
     if (tabIx == MDTable.Event) {
         events.AddRange(list);
     } else {
         properties.AddRange(list);
     }
 }

        internal void AddToTable(MDTable tableIx, MetaDataElement elem)
        {
            // Console.WriteLine("Adding element to table " + (uint)tableIx);

              ArrayList table = GetTable(tableIx);
              if (table.Contains(elem)) {
            Console.Out.WriteLine("ERROR - element already in table " + tableIx);
            return;
              }
              elem.Row = (uint)table.Count + 1;
              table.Add(elem);
        }

 internal MapElem(ClassDef classDef, ClassDef paren, MDTable tableIx)
 {
     theClass = classDef;
     parent = paren;
     tabIx = tableIx;
     sortTable = tabIx == MDTable.NestedClass;
 }

 internal void InsertInTable(MDTable tabIx, uint ix, MetaDataElement elem)
 {
     Contract.Requires(elem != null);
     tables[(int)tabIx][ix - 1] = elem;
 }

		/// <summary>
		/// Reads a column
		/// </summary>
		/// <param name="table">The table</param>
		/// <param name="rid">Row ID</param>
		/// <param name="column">Column</param>
		/// <param name="value">Result is put here or 0 if we return <c>false</c></param>
		/// <returns><c>true</c> if we could read the column, <c>false</c> otherwise</returns>
		public bool ReadColumn(MDTable table, uint rid, ColumnInfo column, out uint value) {
			if (table == null || table.IsInvalidRID(rid)) {
				value = 0;
				return false;
			}
			if (columnReader != null && columnReader.ReadColumn(table, rid, column, out value))
				return true;
			var reader = table.ImageStream;
			reader.Position = (rid - 1) * table.TableInfo.RowSize + column.Offset;
			value = column.Read(reader);
			return true;
		}

		public ParamRow(MDTable parent)
		{
			table = parent;
		}

 internal uint MakeCodedIndex(CIx code, MDTable tab, uint ix)
 {
     ix <<= MetaData.CIxShiftMap[(uint)code];
     ix &= (uint)tab;
     return ix;
 }

 internal static void Read(PEReader buff, TableRow[] maps, MDTable tab)
 {
     if (tab == MDTable.NestedClass) {
         for (int i=0; i < maps.Length; i++) {
             //maps[i] = new MapElem(buff,tab);
             uint nestClassIx = buff.GetIndex(MDTable.TypeDef);
             uint enclClassIx = buff.GetIndex(MDTable.TypeDef);
             ClassDef parent = (ClassDef)buff.GetElement(MDTable.TypeDef,enclClassIx);
             ClassDef nestClass = ((ClassDef)buff.GetElement(MDTable.TypeDef,nestClassIx)).MakeNestedClass(parent);
             buff.InsertInTable(MDTable.TypeDef,nestClass.Row,nestClass);
         }
     } else { // event or property map
         MapElem prev = new MapElem(buff,tab);
         maps[0] = prev;
         for (int i=1; i < maps.Length; i++) {
             maps[i] = new MapElem(buff,tab);
             prev.endIx = ((MapElem)maps[i]).elemIx;
             prev = (MapElem)maps[i];
         }
         switch (tab) {
             case MDTable.PropertyMap:
                 prev.endIx = buff.GetTableSize(MDTable.Property) + 1;
                 break;
             case MDTable.EventMap:
                 prev.endIx = buff.GetTableSize(MDTable.Event) + 1;
                 break;
             default:
                 prev.endIx = buff.GetTableSize(tab)+1;
                 break;
         }
     }
 }

 internal void SetElementPosition(MDTable tabIx, uint ix)
 {
     BaseStream.Position = tableStarts[(int)tabIx] + (md.elemSize[(int)tabIx] * (ix-1));
 }

 internal static uint Size(MetaData md, MDTable tabIx)
 {
     return md.TableIndexSize(MDTable.TypeDef) + md.TableIndexSize(tabIx);
 }

 internal static string[] GetFeatureNames(PEReader buff, MDTable tabIx, MDTable mapTabIx,
     ClassDef theClass, uint classIx)
 {
     buff.SetElementPosition(mapTabIx,0);
     uint start = 0, end = 0, i = 0;
     for (; (i < buff.GetTableSize(tabIx)) && (start == 0); i++) {
         if (buff.GetIndex(MDTable.TypeDef) == classIx) {
             start = buff.GetIndex(tabIx);
         }
     }
     if (start == 0) return null;
     if (i < buff.GetTableSize(mapTabIx)) {
         uint junk = buff.GetIndex(MDTable.TypeDef);
         end = buff.GetIndex(tabIx);
     } else
         end = buff.GetTableSize(tabIx);
     if (tabIx == MDTable.Event)
         theClass.eventIx = start;
     else
         theClass.propIx = start;
     string[] names = new string[end-start];
     buff.SetElementPosition(tabIx,start);
     for (i=start; i < end; i++) {
         uint junk = buff.ReadUInt16();
         names[i] = buff.GetString();
         if (tabIx == MDTable.Event)
             junk = buff.GetCodedIndex(CIx.TypeDefOrRef);
         else
             junk = buff.GetBlobIx();
     }
     return names;
 }

 internal TableRow(PEReader buff, uint ix, MDTable tableIx)
 {
     buffer = buff;
     row = ix;
     tabIx = tableIx;
 }

 internal void AddToFeatureList(ArrayList list, MDTable tabIx)
 {
     Contract.Requires(list != null);
     if (tabIx == MDTable.Event)
     {
         events.AddRange(list);
     }
     else
     {
         properties.AddRange(list);
     }
 }

 internal MetaDataElement GetElement(MDTable tabIx, uint ix)
 {
     if (ix == 0) return null;
     MetaDataElement elem = (MetaDataElement)tables[(int)tabIx][(int)ix-1];
     if ((elem != null) && (elem.unresolved)) {
         elem.Resolve(this);
         elem = (MetaDataElement)tables[(int)tabIx][(int)ix-1];
     }
     return elem;
 }

 internal void WriteIndex(MDTable tabIx,uint ix) {
   if (metaData.LargeIx(tabIx)) Write(ix);
   else Write((ushort)ix);
 }