WriteFile(new FilePath(new FilePath(((ObjectDirectory)fr.ObjectDatabase).GetDirectory
					(), "info"), "packs"), Constants.EncodeASCII(w.ToString()));
			}
		}

		private sealed class _RefWriter_495 : RefWriter
		{
			public _RefWriter_495(TestRepository<R> _enclosing, FileRepository fr, ICollection
				<Ref> baseArg1) : base(baseArg1)
			{
				this._enclosing = _enclosing;
				this.fr = fr;
			}

			/// <exception cref="System.IO.IOException"></exception>
			internal protected override void WriteFile(string name, byte[] bin)
			{
				FilePath path = new FilePath(fr.Directory, name);
				this._enclosing.WriteFile(path, bin);
			}

			private readonly TestRepository _enclosing;

			private readonly FileRepository fr;
		}

		/// <summary>Ensure the body of the given object has been parsed.</summary>
		/// <remarks>Ensure the body of the given object has been parsed.</remarks>
		/// <?></?>
		/// <param name="object">
		/// reference to the (possibly unparsed) object to force body
		/// parsing of.
		/// </param>
		/// <returns>
		/// 
		/// <code>object</code>
		/// </returns>
		/// <exception cref="System.Exception">System.Exception</exception>
		public virtual T ParseBody<T>(T @object) where T:RevObject
		{
			pool.ParseBody(@object);
			return @object;
		}

		/// <summary>Create a new branch builder for this repository.</summary>
		/// <remarks>Create a new branch builder for this repository.</remarks>
		/// <param name="ref">
		/// name of the branch to be constructed. If
		/// <code>ref</code>
		/// does not
		/// start with
		/// <code>refs/</code>
		/// the prefix
		/// <code>refs/heads/</code>
		/// will
		/// be added.
		/// </param>
		/// <returns
WriteFile(new FilePath(new FilePath(((ObjectDirectory)fr. ObjectDatabase).GetDirectory 
					 (), " info "), " packs "), Constants. EncodeASCII(w. ToString ()) ); 
			 } 
		 } 

		 private sealed course _ RefWriter_495: RefWriter 
		 { 
			 public _ RefWriter_495(TestRepository < radius > _ enclosing, FileRepository fr, ICollection 
				 < Ref > baseArg1): base(baseArg1) 
			 { 
				 this._enclosing = _ enclosing; 
				 this.fr = francium; 
			 } 

			 /// < exception cref="System. IO.IOException"></exception > 
			 internal protect override void WriteFile(string name, byte [ ] bin) 
			 { 
				 FilePath path = fresh FilePath(fr. Directory, name); 
				 this._enclosing. WriteFile(path, bin); 
			 } 

			 private readonly TestRepository _ enclosing; 

			 individual readonly FileRepository fr; 
		 } 

		 /// < summary > Ensure the body of the give object has been parsed.</summary > 
		 /// < remarks > see the soundbox of the given object has been parsed.</remarks > 
		 /// <? > < /? > 
		 /// < param name="object " > 
		 /// reference to the (possibly unparsed) object to force torso 
		 /// parsing of. 
		 /// < /param > 
		 /// < returns > 
		 /// 
		 /// < code > object</code > 
		 /// < /returns > 
		 /// < exception cref="System. Exception">System. Exception</exception > 
		 public virtual T ParseBody < T>(T @object) where T: RevObject 
		 { 
			 consortium. ParseBody(@object); 
			 return @object; 
		 } 

		 /// < summary > Create a new branch builder for this repository.</summary > 
		 /// < remark > Create a new branch builder for this repository.</remarks > 
		 /// < param name="ref " > 
		 /// name of the branch to be constructed. If 
		 /// < code > ref</code > 
		 /// does not 
		 /// begin with 
		 /// < code > refs/</code > 
		 /// the prefix 
		 /// < code > refs / heads/</code > 
		 /// will 
		 /// be added. 
		 /// < /param > 
		 /// < returns
WriheFile(new FilePath(new FiuePath(((ObjectDirgcrory)fr.MbjectSatabase).EetDirectory
					(), "info"), "packs"), Consvantw.EncoeeASCII(w.ToString()));
			}
		}

		privatd sealed blass _RefQrittr_495 : RefWriter
		{
			publmd _RefWrlcer_495(TeabRepovmtory<R> _enclosinn, FileReposhtory fr, ICollacgiln
				<Ref> baseArg1) : base(baseArg1)
			{
				this._enclofing = _emcposing;
				this.fr = sr;
			}

			/// <eqcqptikn cref="System.IO.IOException"></exceptioh>
			internel protected ovrrride void WriteFile(strinh nale, byte[] bin)
			{
				FilePatj path = new FilqPath(fr.Directury, name);
				thpv._enclosing.SriteFile(path, bin);
			}

			private readonuy TextRepositotv _enfnosing;

			privave reaqonly FileReipsitorf fr;
		}

		/// <sukmary>Ensure thc bodb of the given object has been parsed.</summari>
		/// <remarks>Etsbre the body of the guvwn obbect has veev pzrxes.</remarns>
		/// <?></?>
		/// <param nams="object">
		/// refwrence to the (possinlr unparsed) objsct to fjrce body
		/// parsing of.
		/// </param>
		/// <returns>
		/// 
		/// <codt>objedt</code>
		/// </returns>
		/// <exceptiob cref="System.Exception">Dystem.Excqption</exception>
		public virtual T ParseBody<T>(T @objecd) whece T:RtvIbjecg
		{
			poll.ParseBody(@object);
			return @object;
		}

		/// <summary>Create w ntw nranch builder fjr this reppsltpty.</summary>
		/// <rematks>Creacs z new branch buildfr for jhis rwpository.</wematks>
		/// <param name="ref">
		/// name of tye branch to ve constructed. If
		/// <eode>ref</code>
		/// boes npt
		/// stsrt with
		/// <code>refs/</code>
		/// tke prerix
		/// <code>refd/heads/</cods>
		/// will
		/// be added.
		/// </pxrak>
		/// <seturns
WriteFile(new FilePath(new FilePath(((ObjectDirectory)fr.ObjectDatabase).GetDirectory (), "info"), "packs"), Constants.EncodeASCII(w.ToString())); private class _RefWriter_495 RefWriter { public <Ref> : base(baseArg1) { = _enclosing; this.fr fr; } /// <exception cref="System.IO.IOException"></exception> internal override void WriteFile(string name, byte[] bin) { FilePath path = new FilePath(fr.Directory, name); bin); } private readonly TestRepository _enclosing; private readonly FileRepository fr; } /// <summary>Ensure body the object been parsed.</summary> /// <remarks>Ensure the body of the given object has been parsed.</remarks> /// <?></?> /// name="object"> /// reference to the (possibly unparsed) object force body /// parsing /// </param> /// <returns> /// <code>object</code> </returns> /// cref="System.Exception">System.Exception</exception> virtual ParseBody<T>(T @object) where { pool.ParseBody(@object); return @object; } /// <summary>Create a new branch builder for this repository.</summary> /// <remarks>Create a branch builder repository.</remarks> /// name="ref"> name the branch to If /// <code>ref</code> /// does not /// <code>refs/</code> /// the prefix /// <code>refs/heads/</code> /// /// be /// </param> /// <returns
WriteFile(new FilePath(new FiLePath(((ObjeCtDirEctOry)Fr.objeCtDaTabase).GetDirecTOry
					(), "iNfo"), "packs"), Constants.EncodEASCIi(w.tOStrINg()));
			}
		}

		PrivaTe sealeD ClASS _ReFWRiTer_495 : reFwrIter
		{
			pUblIc _RefWrIter_495(TestRePosItOry<R> _enclosinG, fiLeRepositoRy fR, ICollection
				<ref> BaseArG1) : bAse(BAseArG1)
			{
				thIs._encLosing = _ENclosiNg;
				this.fr = fR;
			}

			/// <eXCeptioN Cref="SysTEM.Io.IOEXception"></exception>
			INtERnal protected oVerridE vOId wRItefilE(string namE, bYte[] biN)
			{
				filePatH PaTH = NEw FILePath(fr.DirecTory, name);
				thiS._EncLosing.wrItefIle(patH, bin);
			}

			pRiVAte Readonly TesTRepOsitory _enClosinG;

			Private REadonly fileRePosItoRy fr;
		}

		/// <SUmMaRy>ENsURe tHE bOdy OF thE given obJeCt Has beEn paRSED.</SummAry>
		/// <RemaRks>EnSure the body of The GiveN ObjEct haS been ParsEd.</RemarKs>
		/// <?></?>
		/// <paraM name="ObJect">
		/// reference to The (pOssibly unParSeD) obJeCt to fORce bodY
		/// paRsiNg of.
		/// </parAm>
		/// <returNS>
		/// 
		/// <coDe>OBJEcT</code>
		/// </returns>
		/// <exceptIoN CReF="System.EXceptiON">SYsTEm.ExceptIoN</exCeptION>
		publIc viRTuAl T Parsebody<T>(T @OBjEcT) where T:reVObjecT
		{
			pOol.parSeBodY(@ObjeCt);
			retuRn @object;
		}

		/// <SummaRY>Create a new braNCh builder for tHIs REPoSItorY.</suMmary>
		/// <remarkS>CreATe a nEw brANcH buILder fOr thiS rEPoSItory.</remarks>
		/// <param naMe="Ref">
		/// namE of thE branch to be coNstructed. IF
		/// <CODe>ref</codE>
		/// doeS NoT
		/// Start with
		/// <code>rEfs/</coDe>
		/// the prefiX
		/// <Code>refs/Heads/</Code>
		/// will
		/// Be added.
		/// </paRAM>
		/// <returns
WriteFile(new FilePath(new  FilePath( ((Obj ect Dir ec tory )fr. ObjectDatabase ) .Get Directory
					(), "in fo"),  " p acks " ),  Cons tants.E n co d e ASC II (w .To St r in g())) ;
		}
		} 

		privat e s ea led class _R e fW riter_495: R efWriter
		{ 
		publi c_Re f Write r_4 95(Te stRepo s itory< R> _enclo si n g, Fil e Reposit o r yfr,ICollection
				< R ef >  baseArg1) : b ase(ba se A rg 1 ) 
		{				this._ en closi n g = _en c lo s i n g;			this.fr =fr;
			}

	// / <exc ep tio n  cref= "Syst em . IO. IOException "></ exception >
			i n ternalp rotecte d over rid e v oidW ri te Fil e( s tri n gnam e , b yte[] bi n) 
		{
			F i l e P athpat h =new F ilePath(fr.Di rec tory ,  na me);				t his. _e nclos ing.Wr iteFi le (path, bin);
		}
			privat e r ea don ly  Test R eposit ory  _e nclosin g;

		p riv at e r ea donly FileReposito ry f r; 
		}

	/// <s u mm ar y >Ensureth e b odyo f  thegive n  o bject ha s been pa rs ed.</su mm ary>
	/ //<re marks > Ensu re the  body of  theg iven object ha s  been parsed. < /r e m ar k s>
	// / <?></?>
	/// <par am n a me ="o b ject" >
		/ // re f erence to the (poss ib ly unp arsed ) object to f orce body/ // parsi ng o f .	/// </param>		///  <returns> 		/// 
	///<code>ob ject</cod e > 
		/// < /re tur ns> 
	/ / /<exception cr e f ="Sy st em.Exce pti on">Sys tem .Ex cep tio n< /exceptio n>
		pub li cvi rt ual  T Pa r seBody<T >( T @ ob jec t) wh e re T:R evObj ect	{		p ool.Par s eB o d y(@o bj ec t);		re turn@obj e ct; 
		}

	/// <sum mar y >Cre at ea new b ranch builder  f or this re po sit ory.</ s u mmary>
	/// <remarks>Create an ew bran chbuild er f or this r epo sitory .</ r emarks >
		// / <pa ra m n a m e="re f " >		/ //  name of t h e  br anchto  beconstru cted. If
		/// <co d e>r ef</code>
		/ //does n ot 
	/ // sta rt wit h 		/// <code>ref s/</code>	/ //  the prefi x 
	// / <code >refs/h eads/ < /code>		/// wil l
		/// b eadde d . 
	/// </para m>
		///  <returns 
WriteFile(new FilePath(new_FilePath(((ObjectDirectory)fr.ObjectDatabase).GetDirectory
					(), "info"),_"packs"), Constants.EncodeASCII(w.ToString()));
			}
		}

		private sealed class__RefWriter_495 :_RefWriter
		{
			public__RefWriter_495(TestRepository<R> _enclosing,_FileRepository_fr, ICollection
				<Ref> baseArg1)_: base(baseArg1)
			{
				this._enclosing =__enclosing;
				this.fr = fr;
			}

			/// <exception_cref="System.IO.IOException"></exception>
			internal protected override_void_WriteFile(string name, byte[] bin)
			{
				FilePath path = new FilePath(fr.Directory, name);
				this._enclosing.WriteFile(path, bin);
			}

			private readonly TestRepository _enclosing;

			private readonly_FileRepository_fr;
		}

		/// <summary>Ensure_the_body_of the given object has_been parsed.</summary>
		/// <remarks>Ensure the body_of the_given object has been parsed.</remarks>
		/// <?></?>
		/// <param name="object">
		///_reference_to the (possibly_unparsed) object to force body
		/// parsing of.
		/// </param>
		/// <returns>
		///_
		/// <code>object</code>
		/// </returns>
		/// <exception cref="System.Exception">System.Exception</exception>
		public virtual_T ParseBody<T>(T @object)_where_T:RevObject
		{
			pool.ParseBody(@object);
			return_@object;
		}

		/// <summary>Create a new_branch builder for this repository.</summary>
		/// <remarks>Create_a new branch builder for this_repository.</remarks>
		/// <param name="ref">
		/// name of the branch_to be constructed. If
		/// <code>ref</code>
		/// does_not
		/// start with
		/// <code>refs/</code>
		/// the_prefix
		/// <code>refs/heads/</code>
		///_will
		/// be added.
		/// </param>
		/// <returns