public void Read(ClrModuleReader reader)
 {
     this.Offset = reader.Binary.ReadUInt32();
     this.Flags = (ManifestResourceAttributes)reader.Binary.ReadUInt32();
     this.Name = reader.ReadString();
     this.Implementation = reader.ReadCodedIndex<Implementation>();
 }

		private void LoadData(CLIFile pFile)
		{
			Offset = pFile.ReadUInt32();
			Flags = (ManifestResourceAttributes)pFile.ReadUInt32();
			Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
			Implementation.LoadData(pFile);
		}

 public LinkedResource(string name, ManifestResourceAttributes flags, string resourceFileName, byte[] hash)
     : base(name, flags)
 {
     this.resourceFileName = name;
     this.hash = hash;
     this.hashSource = LinkedResourceHashSource.Explicit;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ManifestResourceRow" /> struct.
        /// </summary>
        /// <param name="offset">The offset.</param>
        /// <param name="flags">The flags.</param>
        /// <param name="nameString">Index of the name string.</param>
        /// <param name="implementation">The implementation.</param>
        public ManifestResourceRow(uint offset, ManifestResourceAttributes flags, HeapIndexToken nameString,
			Token implementation)
        {
            Offset = offset;
            Flags = flags;
            NameString = nameString;
            Implementation = implementation;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ManifestResourceRow"/> struct.
        /// </summary>
        /// <param name="offset">The offset.</param>
        /// <param name="flags">The flags.</param>
        /// <param name="nameStringIndex">Index of the name string.</param>
        /// <param name="implementation">The implementation table idx.</param>
        public ManifestResourceRow(uint offset, ManifestResourceAttributes flags, HeapIndexToken nameStringIndex,
			Token implementation)
        {
            _offset = offset;
            _flags = flags;
            _nameStringIdx = nameStringIndex;
            _implementation = implementation;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ManifestResourceRow"/> struct.
 /// </summary>
 /// <param name="offset">The offset.</param>
 /// <param name="flags">The flags.</param>
 /// <param name="nameStringIndex">Index of the name string.</param>
 /// <param name="implementationTableIdx">The implementation table idx.</param>
 public ManifestResourceRow(uint offset, ManifestResourceAttributes flags, TokenTypes nameStringIndex,
     TokenTypes implementationTableIdx)
 {
     _offset = offset;
     _flags = flags;
     _nameStringIdx = nameStringIndex;
     _implementationTableIdx = implementationTableIdx;
 }

		internal static string ToString(ManifestResourceAttributes flags) {
			var sb = new StringBuilder();

			switch ((flags & ManifestResourceAttributes.VisibilityMask)) {
			case ManifestResourceAttributes.Public: sb.Append("Public"); break;
			case ManifestResourceAttributes.Private: sb.Append("Private"); break;
			default: sb.Append("Visibility_UNKNOWN"); break;
			}

			return sb.ToString();
		}

 public void AddManifestResource(
     ManifestResourceAttributes attributes,
     StringHandle name,
     EntityHandle implementation,
     long offset)
 {
     _manifestResourceTable.Add(new ManifestResourceRow
     {
         Flags = (uint)attributes,
         Name = name,
         Implementation = implementation.IsNil ? 0 : (uint)CodedIndex.ToImplementation(implementation),
         Offset = (uint)offset
     });
 }

		void AddManifestResource (uint offset, string name, ManifestResourceAttributes flags, MetadataToken impl)
		{
			ManifestResourceTable mrTable = m_tableWriter.GetManifestResourceTable ();
			ManifestResourceRow mrRow = m_rowWriter.CreateManifestResourceRow (
				offset,
				flags,
				m_mdWriter.AddString (name),
				impl);

			mrTable.Rows.Add (mrRow);
		}

 public ManifestResource(string name, ManifestResourceAttributes attributes, MetaDataMember implementation, uint offset)
     : base(new MetaDataRow(offset, (uint)attributes, 0U, 0U))
 {
     this._name = name;
     this._implementation = implementation;
 }

 public EmbeddedResource(string name, ManifestResourceAttributes attributes, Stream stream)
     : base(name, attributes)
 {
     this.stream = stream;
 }

		public LinkedResource (string name, ManifestResourceAttributes flags, string file)
			: base (name, flags)
		{
			this.file = file;
		}

		public AssemblyLinkedResource (string name, ManifestResourceAttributes flags, AssemblyNameReference reference)
			: base (name, flags)
		{
			this.reference = reference;
		}

		internal Resource (string name, ManifestResourceAttributes attributes)
		{
			this.name = name;
			this.attributes = (uint) attributes;
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="name">Name of resource</param>
		/// <param name="file">The file</param>
		/// <param name="flags">Resource flags</param>
		public LinkedResource(UTF8String name, FileDef file, ManifestResourceAttributes flags)
			: base(name, flags) {
			this.file = file;
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="name">Name of resource</param>
		/// <param name="asmRef">Assembly reference</param>
		/// <param name="flags">Resource flags</param>
		public AssemblyLinkedResource(UTF8String name, AssemblyRef asmRef, ManifestResourceAttributes flags)
			: base(name, flags) {
			if (asmRef == null)
				throw new ArgumentNullException("asmRef");
			this.asmRef = asmRef;
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="name">Name of resource</param>
		/// <param name="dataStream">Resource data</param>
		/// <param name="flags">Resource flags</param>
		public EmbeddedResource(UTF8String name, IImageStream dataStream, ManifestResourceAttributes flags)
			: base(name, flags) {
			if (dataStream == null)
				throw new ArgumentNullException("dataStream");
			this.dataStream = dataStream;
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="name">Name</param>
		/// <param name="flags">flags</param>
		protected Resource(UTF8String name, ManifestResourceAttributes flags) {
			this.name = name;
			this.flags = flags;
		}

 internal EmbeddedResource(uint offset, ManifestResourceAttributes attributes, string name)
 {
     this.Offset = offset;
     this.Attributes = attributes;
     this.Name = name;
 }

 public ManifestResourceRow CreateManifestResourceRow(uint _offset, ManifestResourceAttributes _flags, uint _name, MetadataToken _implementation)
 {
     ManifestResourceRow row = new ManifestResourceRow ();
     row.Offset = _offset;
     row.Flags = _flags;
     row.Name = _name;
     row.Implementation = _implementation;
     return row;
 }