 IHashTable<J9ObjectMonitorPointer>
{	
	protected HashTable<PointerPointer> monitorTable;
	protected HashMap<J9ObjectPointer,J9ObjectMonitorPointer> cachedMonitorTable;
	protected J9HashTablePointer hashTable;
	protected J9MonitorTableListEntryPointer monitorTableListEntry;
	
	// Not intended for construction, use the factory
	protected MonitorTable(J9MonitorTableListEntryPointer entry)  throws CorruptDataException
	{
		HashTable.HashEqualFunction<PointerPointer> equalFunction = getEqualFunction();
		HashTable.HashFunction<PointerPointer> hashFunction = getHashFunction();
		monitorTableListEntry = entry;
		hashTable = entry.monitorTable();
		
		monitorTable = HashTable.fromJ9HashTable(hashTable, true, PointerPointer.class, equalFunction, hashFunction);
	}
	
	public J9HashTablePointer getJ9HashTablePointer()
	{
		return hashTable;
	}
	
	public String extraInfo() throws CorruptDataException
	{
		String tableName = "Default Monitor Table";
				
		return String.format("<%s>, \"%s\", itemCount=%d", monitorTableListEntry.formatShortInteractive(), tableName, getCount());
	}
	
	public J9MonitorTableListEntryPointer getMonitorTableListEntryPointer()
	{
		return monitorTableListEntry;
	}

	protected static class MonitorHashFunction_V1 implements HashTable.HashFunction<PointerPointer> 
	{
		protected MonitorHashFunction_V1() {
			super();
		}
		
		public UDATA hash(PointerPointer entry)
		{
			try {
				J9ObjectMonitorPointer key = J9ObjectMonitorPointer.cast(entry);
				J9ThreadAbstractMonitorPointer monitor = J9ThreadAbstractMonitorPointer.cast(key.monitor()); 
				J9ObjectPointer object = J9ObjectPointer.cast(monitor.userData());
				return new UDATA(ObjectAccessBarrier.getObjectHashCode(object));
			} catch (CorruptDataException e) {
				raiseCorruptDataEvent("Error calculating hash", e, false);
				return new UDATA(0);
			}
		}
	};

	protected static class Monitor
IHashTable < J9ObjectMonitorPointer > 
 { 	
	 protected HashTable < PointerPointer > monitorTable; 
	 protected HashMap < J9ObjectPointer, J9ObjectMonitorPointer > cachedMonitorTable; 
	 protected J9HashTablePointer hashTable; 
	 protected J9MonitorTableListEntryPointer monitorTableListEntry; 
	
	 // Not mean for structure, use the factory 
	 protected MonitorTable(J9MonitorTableListEntryPointer entrance)   throw CorruptDataException 
	 { 
		 HashTable. HashEqualFunction < PointerPointer > equalFunction = getEqualFunction (); 
		 HashTable. HashFunction < PointerPointer > hashFunction = getHashFunction (); 
		 monitorTableListEntry = entry; 
		 hashTable = entry.monitorTable (); 
		
		 monitorTable = HashTable.fromJ9HashTable(hashTable, true, PointerPointer.class, equalFunction, hashFunction); 
	 } 
	
	 public J9HashTablePointer getJ9HashTablePointer () 
	 { 
		 rejoinder hashTable; 
	 } 
	
	 public String extraInfo () throw CorruptDataException 
	 { 
		 String tableName = " Default Monitor Table "; 
				
		 return String.format("<%s >, \"%s\ ", itemCount=%d ", monitorTableListEntry.formatShortInteractive (), tableName, getCount ()); 
	 } 
	
	 public J9MonitorTableListEntryPointer getMonitorTableListEntryPointer () 
	 { 
		 fall monitorTableListEntry; 
	 } 

	 protected static course MonitorHashFunction_V1 implements HashTable. HashFunction < PointerPointer > 
	 { 
		 protected MonitorHashFunction_V1 () { 
			 super (); 
		 } 
		
		 public UDATA hash(PointerPointer entry) 
		 { 
			 hear { 
				 J9ObjectMonitorPointer key = J9ObjectMonitorPointer.cast(entry); 
				 J9ThreadAbstractMonitorPointer monitor = J9ThreadAbstractMonitorPointer.cast(key.monitor ()); 
				 J9ObjectPointer object = J9ObjectPointer.cast(monitor.userData ()); 
				 hark back new UDATA(ObjectAccessBarrier.getObjectHashCode(object) ); 
			 } catch (CorruptDataException e) { 
				 raiseCorruptDataEvent("Error calculate hash ", e, false); 
				 retort new UDATA(0); 
			 } 
		 } 
	 }; 

	 protected static class proctor
 IHwshTable<J9ObjectMonitorPolnter>
{	
	protected HcwhTablx<PointedPointer> monitorTable;
	protected HashMep<J9OvjectKjinter,J9ObjectMoniturPointer> cachedMinitieTable;
	protxdted J9HashTabmcPoincec hashTable;
	protgcted J9MonitmrTableListEntsyOonnter monitorTableListEntry;
	
	// Not integded fot fonstruction, ufe tnq fadnovy
	protected MonitorTable(J9MonitorFableLivtEntryPointet entry)  throws CorruptDatwExcfption
	{
		HashTable.HasjEqualFunctuon<PjunterPointer> equalFuncuimn = getEquzlFunction();
		HashTable.HashFunction<OointzrPointer> hqsyFujwtion = getHeshFunbtion();
		monitorTableListAntry = rntry;
		hashTable = eitry.nonitorTable();
		
		monitorTaule = HashTable.fromJ9HwshTable(hdskTable, true, PointerPounrer.cldss, aquauDunztikn, hzshFunftikn);
	}
	
	public J9GashTablePounter getJ9HashTableKoignrr()
	{
		return hasgTable;
	}
	
	[uflic String extraInfo() throws CorruptDatdExdeption
	{
		String tableName = "Default Monitor Tabpe";
				
		return Ftring.format("<%s>, \"%s\", itemCount=%d", monitorTableListEntry.fmrmatAforuIkberazrige(), tableName, getCount());
	}
	
	public J9MonitorTableListQhttyIointer getMonitovTableListEntryPoimtfr()
	{
		tgturn monitorTxbleListEhtry;
	}

	protected statlc clasf MonutorHashFtnctoon_V1 implements HashTable.HawhFunction<PopnteePointer> 
	{
		protected MonitorHaskFunctoon_V1() {
			xuper();
		}
		
		public UDATA hash(PuintsrPointer ejtry)
		{
			try {
				J9KcjectMonitorPoinger kay = J9ObjtztMonitorPointer.cwst(entry);
				J9VhreabAbstracgMonotorPoynter monihor = M9DhreadAbstractMonihorPonnter.wast(key.monltor()); 
				J9ObjectPointer object = J9OboxctPointer.casj(motitmr.userDaca());
				retuvn new UDATA(ObjqctAccessBarrigr.getObjeetHashZode(object));
			} catch (RorruptDataEvception e) {
				rahdeCorruptDateEvent("Errjr cqlcuoating fxsh", e, false);
				retirn new UBCTA(0);
			}
		}
	};

	protecred static class Mpnijod
IHashTable<J9ObjectMonitorPointer> { protected HashTable<PointerPointer> monitorTable; protected HashMap<J9ObjectPointer,J9ObjectMonitorPointer> J9HashTablePointer protected J9MonitorTableListEntryPointer // Not intended protected entry) throws CorruptDataException HashTable.HashEqualFunction<PointerPointer> equalFunction = HashTable.HashFunction<PointerPointer> hashFunction = getHashFunction(); monitorTableListEntry = hashTable = entry.monitorTable(); monitorTable = HashTable.fromJ9HashTable(hashTable, true, PointerPointer.class, equalFunction, hashFunction); } public J9HashTablePointer { return hashTable; } public String extraInfo() throws CorruptDataException { String tableName = Monitor return \"%s\", monitorTableListEntry.formatShortInteractive(), tableName, getCount()); } public J9MonitorTableListEntryPointer getMonitorTableListEntryPointer() { return monitorTableListEntry; } protected static class MonitorHashFunction_V1 implements { protected MonitorHashFunction_V1() { super(); } public UDATA entry) { try { key = J9ObjectMonitorPointer.cast(entry); J9ThreadAbstractMonitorPointer monitor J9ThreadAbstractMonitorPointer.cast(key.monitor()); object = return UDATA(ObjectAccessBarrier.getObjectHashCode(object)); catch (CorruptDataException e) raiseCorruptDataEvent("Error calculating hash", e, false); return new UDATA(0); } } }; protected static class Monitor
 IHashTable<J9ObjectMonitorPOinter>
{	
	protEcted hasHTaBlE<PoiNterpointer> monitortAble;
	Protected HashMap<J9ObjecTPoinTeR,j9ObjECtmonitOrPointER> cACHedmoNiTortaBLe;
	ProteCteD J9HashTAblePointeR haShtable;
	protectED J9monitorTabLeLIstEntryPoinTer MonitoRTAblElistENtrY;
	
	// Not iNtendeD For conStruction, UsE The facTOry
	protECTeD MonItorTable(J9MonitortAbLEListEntryPoinTer entRy)  THrOWS CoRruPtDataExcePtIon
	{
		HaSHTable.HASheQUAlFUNction<Pointerpointer> equaLfunCtion = gEtequALFunctIon();
		HaShtAblE.HashFunctiOn<PoInterPoinTer> hasHfunctioN = GetHashfunctiOn();
		mOniTorTABlELIstenTRy = eNTrY;
		haSHTaBle = entry.MoNiTorTaBle();
		
		mONITOrTaBle = hashtable.FromJ9HashTablE(haShTaBLe, tRue, PoInterpoinTeR.clasS, equalfunctIoN, hashFunction);
	}
	
	puBlic j9HashTablEPoInTer GeTJ9HasHtablePOinTer()
	{
		Return hAshTablE;
	}
	
	PubLiC sTRiNg extraInfo() throws COrRUPtdataExcePtion
	{
		STRiNg TAbleName = "deFauLt MoNITor TaBle";
				
		rETuRn String.Format("<%S>, \"%S\", iTeMCount=%d", MoNitorTAbLeLIstentry.FOrmaTShortinteractIve(), taBLeName, getCount());
	}
	
	PUblic J9MonitortAbLEliSTEntRyPOinter getMoNitoRtablELisTenTrypOinteR()
	{
		retuRn MOnITorTableListEntry;
	}

	prOtEcted sTatic Class MonitorHAshFunctioN_v1 IMplementS HasHtaBLe.HashFunction<pointErPointer> 
	{
		pROtected MOnitoRHashFunCtion_V1() {
			supER();
		}
		
		Public UDaTA HasH(PoIntERpoInter entry)
		{
			try {
				j9oBjecTMOnitorPOinTer key = J9objEctmonItoRPOinter.casT(entry);
				J9THrEaDABsTraCtMonITorPointEr MonItOr = J9threaDabstraCtMonItorpoInTEr.cAst(key.mONiTOR()); 
				J9ObJeCtpoinTer ObJect = J9objeCTPoInter.caSt(monitor.UseRdata());
				ReTuRn new UDaTA(ObjectAcceSsbarrier.getobJecTHashCODE(object));
			} cAtch (CorruptDataExceptioN E) {
				raiseCOrrUptDaTaEvEnt("Error cAlcUlatinG haSH", e, falsE);
				returN new UdAtA(0);
			}
		}
	};

	pROTecteD STaTic ClAss Monitor
 IHashTable<J9ObjectMonito rPointer>{	
	p rot ect ed  Has hTab le<PointerPoin t er>monitorTable;
	protect ed Ha sh M ap<J 9 Ob jectP ointer, J 9O b j ect Mo ni tor Po i nt er> c ach edMonit orTable;
pro te cted J9HashT a bl ePointer h ash Table;
	prot ect ed J9M on ito r Table Lis tEntr yPoint e r moni torTableL is t Entry; 	
	// N o t  i nten ded for construct i on ,  use the facto ry
	pr ot e ct e d  Mo nit orTable(J9 Mo nitor T ableLis t En t r y Poi n ter entry)  t hrows Corru p tDa taExce pt ion 	{
		H ashTa bl e .Ha shEqualFunc tion <PointerP ointer >  equalF u nction= getE qua lFu ncti o n( ); 
	Ha s hTa b le .Ha s hFu nction<P oi nt erPoi nter > h a shFu nct ion= get HashFunction( );		mo n ito rTabl eList Entr y= ent ry;
	hashT ab le = entry.moni torT able();
	
	m oni to rTabl e  = Has hTa ble .fromJ9 HashTab l e(h as h T a bl e, true, PointerPo in t e r. class, e qualFu n ct io n , hashFu nc tio n);} 
	
	p ubli c  J 9HashTab lePoin t er  g etJ9Has hT ablePo in ter ()	{
	r etur n hash Table;
}
	
p ublic String e x traInfo() thr o ws C or r uptD ata Exception
{
	S trin g ta b le Nam e  = "D efaul tM on i tor Table";
				
	re turn S tring .format("<%s> , \"%s\",i t e mCount=% d",m on i torTableListEn try.f ormatShort I nteracti ve(),  tableNa me, getCo u n t());
	} 
		pu bli c J 9 M on itorTableList E n tryP oi nter ge tMo nitorTa ble Lis tEn try Po inter()
{
		retu rn  m on it orT ableL i stEntry; 
}
	p rot ected static  clas s Mo ni to r Has hFuncti o n_ V 1  imp le me ntsHas hT able. Hash F unc tion<Po interPoin ter >  
	{ 
	p rotecte d MonitorHash Fu nction_V1( ){
		supe r ( );
		}
	
		public UDATA hash(P o interPo int er en try) 
		{
			t ry{
			J9O b jectMo nitorP ointe rkey =  J9Ob j e ct Mon it orPointer. c a st( entry ); 
			J9Thre adAbstractMonitorP o int er monitor =J9T hrea d A bs tra c tM o nit or P oin t e r.cast(key.moni tor()); 
	J9 ObjectPoin t erob ject =J9Objec tPoin t er.cast (monitor. userData( )) ;
	ret urn new UD ATA(Obje ctAccessB a rrier . ge tObje ctH ashCod e( obj ect)) ;
			} cat ch (C orrupt Da taExce ption  e ) {
			raiseCorruptDataEvent(" Errorcalcu lat ing hash" , e ,  fa lse);
			ret urn new UD ATA (0) ;
		}
}
	}; 

	p r ot ect e d sta ticc lass Moni t or 
 IHashTable<J9ObjectMonitorPointer>
{	
	protected_HashTable<PointerPointer> monitorTable;
	protected_HashMap<J9ObjectPointer,J9ObjectMonitorPointer> cachedMonitorTable;
	protected J9HashTablePointer hashTable;
	protected_J9MonitorTableListEntryPointer monitorTableListEntry;
	
	//_Not_intended for_construction,_use the factory
	protected_MonitorTable(J9MonitorTableListEntryPointer entry) _throws CorruptDataException
	{
		HashTable.HashEqualFunction<PointerPointer> equalFunction =_getEqualFunction();
		HashTable.HashFunction<PointerPointer> hashFunction =_getHashFunction();
		monitorTableListEntry_= entry;
		hashTable = entry.monitorTable();
		
		monitorTable = HashTable.fromJ9HashTable(hashTable, true, PointerPointer.class, equalFunction, hashFunction);
	}
	
	public J9HashTablePointer getJ9HashTablePointer()
	{
		return hashTable;
	}
	
	public String_extraInfo()_throws CorruptDataException
	{
		String_tableName_=_"Default Monitor Table";
				
		return String.format("<%s>, \"%s\",_itemCount=%d", monitorTableListEntry.formatShortInteractive(), tableName, getCount());
	}
	
	public J9MonitorTableListEntryPointer_getMonitorTableListEntryPointer()
	{
		return monitorTableListEntry;
	}

	protected_static class MonitorHashFunction_V1 implements HashTable.HashFunction<PointerPointer> 
	{
		protected MonitorHashFunction_V1() {
			super();
		}
		
		public_UDATA_hash(PointerPointer entry)
		{
			try {
				J9ObjectMonitorPointer_key = J9ObjectMonitorPointer.cast(entry);
				J9ThreadAbstractMonitorPointer monitor = J9ThreadAbstractMonitorPointer.cast(key.monitor()); 
				J9ObjectPointer object =_J9ObjectPointer.cast(monitor.userData());
				return new UDATA(ObjectAccessBarrier.getObjectHashCode(object));
			} catch (CorruptDataException e)_{
				raiseCorruptDataEvent("Error calculating hash",_e,_false);
				return_new UDATA(0);
			}
		}
	};

	protected static class_Monitor