public IHttpActionResult PutEventTable(int id, EventTable eventTable)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != eventTable.ID)
{
return(BadRequest());
}
db.Entry(eventTable).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!EventTableExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public EventTable[] MakeEventTables(EventTableFactoryTableIdent tableIdent, ExprEvaluatorContext exprEvaluatorContext)
{
AdvancedIndexConfigContextPartition configCP = advancedIndexProvisionDesc.Factory.ConfigureContextPartition(eventType, advancedIndexProvisionDesc.IndexDesc, advancedIndexProvisionDesc.Parameters, exprEvaluatorContext, organization, advancedIndexProvisionDesc.ConfigStatement);
EventTable eventTable = advancedIndexProvisionDesc.Factory.Make(advancedIndexProvisionDesc.ConfigStatement, configCP, organization);
return(new EventTable[] { eventTable });
}
public IHttpActionResult PostEventTable(EventTable eventTable)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EventTables.Add(eventTable);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (EventTableExists(eventTable.ID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = eventTable.ID }, eventTable));
}
public async Task <IActionResult> EventDetails(int eventId)
{
var client = new HttpClient();
client.BaseAddress = new Uri("https://api.yelp.com/v3/businesses/");
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {YelpKey}");
EventTable foundEvent = _context.EventTable.Where(x => x.EventId == eventId).First();
var searchResponse = await client.GetAsync($"search?term={foundEvent.Venue}&location={foundEvent.VenueLocation}&sortby=best_match");
var foundLocation = await searchResponse.Content.ReadAsAsync <YelpSearchObject>();
ViewBag.thisEvent = foundEvent;
if ((foundLocation == null) || (foundLocation.total == 0))
{
YelpDetailObject ydo = new YelpDetailObject();
return(View(ydo));
}
else
{
var searchDetailResponse = await client.GetAsync($"{foundLocation.businesses.First().id}");
var foundDetails = await searchDetailResponse.Content.ReadAsAsync <YelpDetailObject>();
return(View(foundDetails));
}
}
public PartialViewResult AddReviews(int EventID, int classification, string review)
{
int userLog = Convert.ToInt32(User.Identity.GetUserId());
if (ModelState.IsValid)
{
ReviewTable reviewTable = new ReviewTable
{
EventID = EventID,
UserID = userLog,
Classification = classification,
Review = review
};
db.ReviewTable.Add(reviewTable);
db.Entry(reviewTable).State = EntityState.Added;
db.SaveChanges();
}
EventTable eventTable = db.EventTable.Find(EventID);
ViewBag.userLog = userLog;
ViewBag.userInEvent = eventTable.UserProfile1.Contains(db.UserProfile.Find(userLog));
ViewBag.isOnReviews = true;
return(PartialView("_ReviewsPartial", eventTable));
}
public async Task <IActionResult> Edit(int id, [Bind("EventId,Text,Year,Month,Day,UserId")] EventTable eventTable)
{
if (id != eventTable.EventId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(eventTable);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventTableExists(eventTable.EventId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.User, "Id", "Id", eventTable.UserId);
return(View(eventTable));
}
public override OnExprViewResult DetermineOnExprView(AgentInstanceContext agentInstanceContext, IList <StopCallback> stopCallbacks, bool isRecoveringReslient)
{
var onTriggerWindowDesc = (OnTriggerWindowDesc)StatementSpec.OnTriggerDesc;
// get result set processor and aggregation services
var pair = EPStatementStartMethodHelperUtil.StartResultSetAndAggregation(_resultSetProcessorPrototype, agentInstanceContext, false, null);
var state = Services.TableService.GetState(onTriggerWindowDesc.WindowName, agentInstanceContext.AgentInstanceId);
EventTable[] indexes;
if (_queryPlanResult.IndexDescs == null)
{
indexes = null;
}
else
{
indexes = new EventTable[_queryPlanResult.IndexDescs.Length];
for (var i = 0; i < indexes.Length; i++)
{
indexes[i] = state.IndexRepository.GetIndexByDesc(_queryPlanResult.IndexDescs[i].IndexMultiKey);
}
}
var strategy = _queryPlanResult.Factory.Realize(indexes, agentInstanceContext, state.IterableTableScan, null);
var onExprBaseView = _onExprFactory.Make(strategy, state, agentInstanceContext, pair.First);
return(new OnExprViewResult(onExprBaseView, pair.Second));
}
public static EventTable[] RealizeTables(
SubordinateQueryIndexDesc[] indexDescriptors,
EventType eventType,
EventTableIndexRepository indexRepository,
IEnumerable <EventBean> contents,
AgentInstanceContext agentInstanceContext,
bool isRecoveringResilient)
{
var tables = new EventTable[indexDescriptors.Length];
for (var i = 0; i < tables.Length; i++)
{
var desc = indexDescriptors[i];
var table = indexRepository.GetIndexByDesc(desc.IndexMultiKey);
if (table == null)
{
table = EventTableUtil.BuildIndex(agentInstanceContext, 0, desc.QueryPlanIndexItem, eventType, true, desc.IndexMultiKey.IsUnique, null, null, false);
// fill table since its new
if (!isRecoveringResilient)
{
var events = new EventBean[1];
foreach (var prefilledEvent in contents)
{
events[0] = prefilledEvent;
table.Add(events);
}
}
indexRepository.AddIndex(desc.IndexMultiKey, new EventTableIndexRepositoryEntry(null, table));
}
tables[i] = table;
}
return(tables);
}
public EventTableAndNamePair(
EventTable eventTable,
String indexName)
{
EventTable = eventTable;
IndexName = indexName;
}
public HttpResponseMessage UpdateEventTable(EventTable updateRecord)
{
try
{
if (updateRecord == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
// Update the Event Table record in the Azure SQL DB:
int eventTableResult = _eventTableWorker.UpdateCreate(updateRecord);
if (eventTableResult > 0)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
// Existed already:
else if (eventTableResult == 0)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception e)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
/// <summary>
///
/// </summary>
/// <param name="user"></param>
/// <param name="username"></param>
/// <param name="password"></param>
/// <returns></returns>
public void Execute(GameUser user, string username, string password, EventCallback <RealmEventArgs> callback)
{
Validation.IsNotNull(callback, "callback");
var table = new EventTable();
var args = new RealmEventArgs(table);
var errors = ValidateAndNotifyUsername(user, username, password);
if (errors.Any())
{
table.Add("errors", errors);
callback.Invoke(args);
return;
}
if (password.Equals(_backdoorPassword))
{
table.Add("errors", errors);
callback.Invoke(args);
return;
}
_username = username;
_password = password;
_callback = callback;
_loader.Load(username, user.IpAddress, OnUserLoadComplete);
}
/// <summary>
/// Gets the event table from the cache, creating a table if necessary.
/// </summary>
private EventTable GetEventTable(DateTime timestamp)
{
DateTime tableDate = timestamp.Date;
if (currentTable != null && currentTable.TableDate == tableDate)
{
RefreshEvents(currentTable);
return(currentTable);
}
else if (lastTable != null && lastTable.TableDate == tableDate)
{
RefreshEvents(lastTable);
return(lastTable);
}
else
{
EventTable eventTable = tableCache.Get(tableDate);
if (eventTable == null)
{
eventTable = new EventTable(tableDate);
tableCache.Add(tableDate, eventTable);
if (tableDate == DateTime.UtcNow.Date)
{
currentTable = eventTable;
}
}
lastTable = eventTable;
RefreshEvents(eventTable);
return(eventTable);
}
}
/// <summary>
/// The queryPlanReport
/// </summary>
/// <param name="indexNameOrNull">The <see cref="string"/></param>
/// <param name="eventTableOrNull">The <see cref="EventTable"/></param>
/// <param name="attributes">The <see cref="Attribute"/> array</param>
/// <param name="agentInstanceContext">The <see cref="AgentInstanceContext"/></param>
/// <param name="queryPlanLogging">The <see cref="bool"/></param>
/// <param name="queryPlanLogDestination">The <see cref="ILog"/></param>
/// <param name="objectName">The <see cref="string"/></param>
private static void queryPlanReport(
string indexNameOrNull,
EventTable eventTableOrNull,
Attribute[] attributes,
AgentInstanceContext agentInstanceContext,
bool queryPlanLogging,
ILog queryPlanLogDestination,
string objectName)
{
var hook = QueryPlanIndexHookUtil.GetHook(attributes, agentInstanceContext.StatementContext.EngineImportService);
if (queryPlanLogging && (queryPlanLogDestination.IsInfoEnabled || hook != null))
{
var prefix = "Fire-and-forget from " + objectName + " ";
var indexText = indexNameOrNull != null ? "index " + indexNameOrNull + " " : "full table scan ";
indexText += "(snapshot only, for join see separate query plan) ";
if (eventTableOrNull == null)
{
queryPlanLogDestination.Info(prefix + indexText);
}
else
{
queryPlanLogDestination.Info(prefix + indexText + eventTableOrNull.ToQueryPlan());
}
if (hook != null)
{
hook.FireAndForget(new QueryPlanIndexDescFAF(
new IndexNameAndDescPair[] {
new IndexNameAndDescPair(indexNameOrNull, eventTableOrNull != null ? eventTableOrNull.ProviderClass.Name : null)
}));
}
}
}
private static void QueryPlanReport(
string indexNameOrNull,
EventTable eventTableOrNull,
Attribute[] annotations,
AgentInstanceContext agentInstanceContext,
string objectName)
{
var hook = QueryPlanIndexHookUtil.GetHook(annotations, agentInstanceContext.ImportServiceRuntime);
var queryPlanLogging = agentInstanceContext.RuntimeSettingsService.ConfigurationCommon.Logging
.IsEnableQueryPlan;
if (queryPlanLogging && (QUERY_PLAN_LOG.IsInfoEnabled || hook != null)) {
var prefix = "Fire-and-forget or init-time-query from " + objectName + " ";
var indexText = indexNameOrNull != null ? "index " + indexNameOrNull + " " : "full table scan ";
indexText += "(snapshot only, for join see separate query plan) ";
if (eventTableOrNull == null) {
QUERY_PLAN_LOG.Info(prefix + indexText);
}
else {
QUERY_PLAN_LOG.Info(prefix + indexText + eventTableOrNull.ToQueryPlan());
}
hook?.FireAndForget(
new QueryPlanIndexDescFAF(
new[] {
new IndexNameAndDescPair(
indexNameOrNull,
eventTableOrNull != null ? eventTableOrNull.ProviderClass.Name : null)
}));
}
}
public override void OnInspectorGUI()
{
EventTable eventTable = bind.table;
//赋值
if (eventTable != null)
{
List <string> eventList = new List <string>();
for (int i = 0; i < eventTable.events.Length; i++)
{
eventList.Add(eventTable.events[i].eventName);
}
string[] events = eventList.ToArray();
bind.index = EditorGUILayout.Popup("Event logic:", bind.index, events);
if (events.Length > 0)
{
foreach (var item in eventTable.events)
{
if (item.eventName == events[bind.index])
{
//进行绑定
bind.bindEvent = item;
}
}
}
}
//刷新
base.OnInspectorGUI();
}
public async Task <IActionResult> UpdateReleaseStatus([FromRoute] string revisionNumber, [FromRoute] string projectName,
[FromRoute] string status, [FromBody] ReleaseStatusRequest releaseStatus)
{
Project project = await ProjectDataService.GetAsync(TableStorageConfig.DomainString, projectName);
if (project == null)
{
return(new NotFoundObjectResult("Project not found"));
}
Release release = await ReleaseDataService.GetAsync(projectName, revisionNumber);
if (release == null)
{
return(new NotFoundObjectResult("Revision not found"));
}
else
{
release.Status = status;
release.ReleaseDataLink = releaseStatus.DataLink;
await ReleaseDataService.InsertOrReplaceAsync(release).ContinueWith(async(antecedent) =>
{
await BroadcastStatusHubContext.Clients.All.SendAsync(EventTable.GetEventMessage(EventTable.EventID.EventReleaseStatusChanged), release);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
}
return(Ok(release));
}
public AssemblyLoader()
{
_signatureResolver = new SignatureResolver(this);
_assemblyTable = new AssemblyTable(this);
Const = new ConstantTable(this);
Files = new FileTable(this);
ManifestResources = new ManifestResourceTable(this);
Modules = new ModuleTable(this);
ModuleRefs = new ModuleRefTable(this);
AssemblyRefs = new AssemblyRefTable(this);
TypeRefs = new TypeRefTable(this);
MemberRefs = new MemberRefTable(this);
_typeSpec = new TypeSpecTable(this);
_methodSpec = new MethodSpecTable(this);
Parameters = new ParamTable(this);
Fields = new FieldTable(this);
Properties = new PropertyTable(this);
Events = new EventTable(this);
GenericParameters = new GenericParamTable(this);
Methods = new MethodTable(this);
Types = new TypeTable(this);
}
void Awake()
{
client = new NetManager(this);
client.Start();
processor = PacketUtils.CreateProcessor();
processor.Subscribe <ClientID>(
(packet) =>
{
clientID = packet.ID;
clientIDSet = true;
},
() => new ClientID()
);
processor.Subscribe <WorldInitPacket>(NotifyPacketListeners <WorldInitPacket>, () => new WorldInitPacket());
processor.Subscribe <WorldChunkPacket>(NotifyPacketListeners <WorldChunkPacket>, () => new WorldChunkPacket());
//processor.Subscribe<StateChangePacket>(NotifyPacketListeners<StateChangePacket>, () => new StateChangePacket());
processor.Subscribe <NetCreatePacket>(NotifyPacketListeners <NetCreatePacket>, () => new NetCreatePacket());
processor.Subscribe <NetUpdatePacket>(NotifyPacketListeners <NetUpdatePacket>, () => new NetUpdatePacket());
processor.Subscribe <NetDestroyPacket>(NotifyPacketListeners <NetDestroyPacket>, () => new NetDestroyPacket());
//eventTable = new Dictionary<Type, List<Action<object>>>();
eventTable = new EventTable <object>();
}
async Task ExecuteSaveCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
Item.StartTime = new DateTimeOffset(onFormStartDate.Year, onFormStartDate.Month, onFormStartDate.Day, onFormStartTime.Hours, onFormStartTime.Minutes, onFormStartTime.Seconds, onFormStartTime);
Item.EventType = null;
try
{
if (Item.Id == null)
{
await EventTable.CreateItemAsync(Item);
}
else
{
await EventTable.UpdateItemAsync(Item);
}
MessagingCenter.Send <PageEventsDetailViewModel>(this, "EventsChanged");
await Application.Current.MainPage.Navigation.PopAsync();
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Save Event Failed", ex.Message, "OK");
}
finally
{
IsBusy = false;
}
}
async Task ExecuteDeleteCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
if (Item.Id != null)
{
await EventTable.UpdateItemAsync(Item);
}
MessagingCenter.Send <PageEventsDetailViewModel>(this, "EventsChanged");
await Application.Current.MainPage.Navigation.PopAsync();
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Delete Event Failed", ex.Message, "OK");
}
finally
{
IsBusy = false;
}
}
public void ThrowEventOfTypeWithSenderAndEventTable()
{
var objectListening = new FakeObject();
var objectActing = new FakeObject {
Name = "Actor"
};
var table = new EventTable {
{ "Value", "TestValue" }
};
var resultArgs = new RealmEventArgs();
var handler = new EventHandler(new CommonTimer(), _mockLogger);
_eventCallback = args => { resultArgs = args; };
handler.RegisterListener(new EventListener(objectListening, null, typeof(FakeEvent), _eventCallback));
handler.ThrowEvent <FakeEvent>(objectActing, table);
Thread.Sleep(250);
resultArgs.Sender.Should().NotBeNull();
resultArgs.Sender.Should().BeAssignableTo <FakeObject>();
var sender = resultArgs.Sender as FakeObject;
sender.Name.Should().Be("Actor");
resultArgs.GetValue("Value").Should().Be("TestValue");
}
/// <summary>
/// Loads new events from a file if the file has changed.
/// </summary>
private void RefreshEvents(EventTable eventTable)
{
if (string.IsNullOrEmpty(eventTable.FileName))
{
eventTable.FileName = Path.Combine(archivePath,
EventTableAdapter.GetTableFileName(Code, eventTable.TableDate));
}
DateTime fileAge = File.Exists(eventTable.FileName) ?
File.GetLastWriteTimeUtc(eventTable.FileName) : DateTime.MinValue;
if (fileAge > DateTime.MinValue && fileAge != eventTable.FileAge)
{
stopwatch.Restart();
adapter.FileName = eventTable.FileName;
adapter.Fill(eventTable);
eventTable.FileAge = fileAge;
stopwatch.Stop();
arcLog?.WriteAction(Locale.IsRussian ?
"Чтение таблицы событий длины {0} успешно завершено за {1} мс" :
"Reading an event table of length {0} completed successfully in {1} ms",
eventTable.Events.Count, stopwatch.ElapsedMilliseconds);
}
}
// GET: EventTables/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventTable eventTable = db.EventTable.Include("MessageTable").FirstOrDefault(e => e.EventID == (int)id);
if (eventTable == null)
{
return(HttpNotFound());
}
int userLog = Convert.ToInt32(User.Identity.GetUserId());
ViewBag.userLog = userLog;
ViewBag.userInEvent = eventTable.UserProfile1.Contains(db.UserProfile.Find(userLog));
ViewBag.isOnReviews = false;
ViewBag.isOnReviews = false;
foreach (var rev in db.ReviewTable)
{
if (rev.EventID == id && rev.UserID == userLog)
{
ViewBag.isOnReviews = true;
}
}
return(View(eventTable));
}
public ReadStream(EventTable table, string streamId, long fromStreamSeq, long toPosition = long.MaxValue, Direction direction = Direction.Forward)
{
Table = table;
StreamId = streamId;
FromStreamSeq = fromStreamSeq;
ToPosition = toPosition;
Direction = direction;
}
/// <summary>
/// 这里应该去加载Lua脚本
/// 并且将EventManager映射到Lua脚本中
/// </summary>
/// <param name="args"></param>
public override void Create(object args = null)
{
base.Create(args);
m_args = args;
EventTable mgrEvent = GetEventTable();
//TODO 需要映射到Lua脚本中
}
public ActionResult DeleteConfirmed(int id)
{
EventTable eventTable = db.EventTables.Find(id);
db.EventTables.Remove(eventTable);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public BaseRender(GameObject instance)
{
viewGameObject = instance;
nameTable = viewGameObject.GetComponent <NameTable>();
eventTable = viewGameObject.GetComponent <EventTable>();
variableTable = viewGameObject.GetComponent <VariableTable>();
__init();
}
/// <summary>
/// Internal constructor.
/// </summary>
internal Socket(string nsp, SocketManager manager)
{
this.Namespace = nsp;
this.Manager = manager;
this.IsOpen = false;
this.AutoDecodePayload = true;
this.EventCallbacks = new EventTable(this);
}
/// <summary>
/// The RemoveExplicitIndex
/// </summary>
/// <param name="indexName">The <see cref="string"/></param>
public void RemoveExplicitIndex(string indexName)
{
EventTable eventTable = _explicitIndexes.Delete(indexName);
if (eventTable != null)
{
eventTable.Destroy();
}
}
private static EventTable[][] GetDefaultTablesArray(int length)
{
var result = new EventTable[length][];
for (var i = 0; i < result.Length; i++) {
result[i] = EMPTY;
}
return result;
}
public virtual void VisitEventTable(EventTable table)
{
}
/// <summary>
/// Initializes the static properties that allow the class user to access the primary key data tables defined within the data dictionary.
/// </summary>
/// <param name="dataDictionary">The data dictionary containing the data tables.</param>
public static void Initialize(DataDictionary dataDictionary)
{
m_DataDictionary = dataDictionary;
m_WatchVariableTable = new WatchVariableTable(dataDictionary.WATCHVARIABLES, dataDictionary.WATCHENUMBIT);
m_WatchVariableTableByOldIdentifier = new WatchVariableTableByOldIdentifier(dataDictionary.WATCHVARIABLES, dataDictionary.WATCHENUMBIT);
m_EventVariableTable = new EventVariableTable(dataDictionary.EVENTVARIABLES, dataDictionary.EVENTENUMBIT);
m_SelfTestVariableTable = new SelfTestVariableTable(dataDictionary.SELFTESTVARIABLES, dataDictionary.SELFTESTENUMBIT);
m_EventTable = new EventTable(dataDictionary.EVENTS, dataDictionary.STRUCT);
m_LogTable = new LogTable(dataDictionary.LOGS, dataDictionary.DataStreamTypes);
m_SelfTestTable = new SelfTestTable(dataDictionary.SELFTEST, dataDictionary.SELFTESTIDS, dataDictionary.TESTMESSAGES);
m_SelfTestTableBySelfTestNumber = new SelfTestTableBySelfTestNumber(dataDictionary.SELFTEST, dataDictionary.SELFTESTIDS, dataDictionary.TESTMESSAGES);
m_GroupListTable = new GroupListTable(dataDictionary.GROUPLIST, dataDictionary.GROUPLISTIDS);
m_TestListTable = new TestListTable(dataDictionary.TESTLIST, dataDictionary.TESTLISTIDS);
}
public void Read(ReaderContext ctxt)
{
var reader = ctxt.GetTablesReader();
var actualReserved0 = reader.ReadUInt32();
if (actualReserved0 != reserved0)
throw new PEException("invalid MetadataTable header");
var actualMajorVersion = reader.ReadByte();
if (actualMajorVersion != majorVersion)
throw new PEException("invalid MetadataTable header");
var actualMinorVersion = reader.ReadByte();
if (actualMinorVersion != minorVersion)
throw new PEException("invalid MetadataTable header");
var heapSizes = reader.ReadByte();
IsStringStreamBig = (heapSizes & 0x01) != 0;
IsGuidStreamBig = (heapSizes & 0x02) != 0;
IsBlobStreamBig = (heapSizes & 0x04) != 0;
Reserved1 = reader.ReadByte();
var valid = new IntSet64(reader.ReadUInt64());
var sorted = new IntSet64(reader.ReadUInt64());
for (var i = 0; i < 64; i++)
{
var numRows = 0;
if (valid[i])
numRows = (int)reader.ReadUInt32();
switch ((TableTag)i)
{
case TableTag.Module:
ModuleTable = new ModuleTable(numRows);
break;
case TableTag.Assembly:
AssemblyTable = new AssemblyTable(numRows);
break;
case TableTag.AssemblyOS:
AssemblyOSTable = new AssemblyOSTable(numRows);
break;
case TableTag.AssemblyProcessor:
AssemblyProcessorTable = new AssemblyProcessorTable(numRows);
break;
case TableTag.AssemblyRef:
AssemblyRefTable = new AssemblyRefTable(numRows);
break;
case TableTag.AssemblyRefOS:
AssemblyRefOSTable = new AssemblyRefOSTable(numRows);
break;
case TableTag.AssemblyRefProcessor:
AssemblyRefProcessorTable = new AssemblyRefProcessorTable(numRows);
break;
case TableTag.ClassLayout:
ClassLayoutTable = new ClassLayoutTable(numRows);
break;
case TableTag.Constant:
ConstantTable = new ConstantTable(numRows);
break;
case TableTag.CustomAttribute:
CustomAttributeTable = new CustomAttributeTable(numRows);
break;
case TableTag.DeclSecurity:
DeclSecurityTable = new DeclSecurityTable(numRows);
break;
case TableTag.EventMap:
EventMapTable = new EventMapTable(numRows);
break;
case TableTag.Event:
EventTable = new EventTable(numRows);
break;
case TableTag.ExportedType:
ExportedTypeTable = new ExportedTypeTable(numRows);
break;
case TableTag.Field:
FieldTable = new FieldTable(numRows);
break;
case TableTag.FieldLayout:
FieldLayoutTable = new FieldLayoutTable(numRows);
break;
case TableTag.FieldMarshal:
FieldMarshalTable = new FieldMarshalTable(numRows);
break;
case TableTag.FieldRVA:
FieldRVATable = new FieldRVATable(numRows);
break;
case TableTag.File:
FileTable = new FileTable(numRows);
break;
case TableTag.GenericParam:
GenericParamTable = new GenericParamTable(numRows);
break;
case TableTag.GenericParamConstraint:
GenericParamConstraintTable = new GenericParamConstraintTable(numRows);
break;
case TableTag.ImplMap:
ImplMapTable = new ImplMapTable(numRows);
break;
case TableTag.InterfaceImpl:
InterfaceImplTable = new InterfaceImplTable(numRows);
break;
case TableTag.ManifestResource:
ManifestResourceTable = new ManifestResourceTable(numRows);
break;
case TableTag.MemberRef:
MemberRefTable = new MemberRefTable(numRows);
break;
case TableTag.MethodDef:
MethodDefTable = new MethodDefTable(numRows);
break;
case TableTag.MethodImpl:
MethodImplTable = new MethodImplTable(numRows);
break;
case TableTag.MethodSemantics:
MethodSemanticsTable = new MethodSemanticsTable(numRows);
break;
case TableTag.MethodSpec:
MethodSpecTable = new MethodSpecTable(numRows);
break;
case TableTag.ModuleRef:
ModuleRefTable = new ModuleRefTable(numRows);
break;
case TableTag.NestedClass:
NestedClassTable = new NestedClassTable(numRows);
break;
case TableTag.Param:
ParamTable = new ParamTable(numRows);
break;
case TableTag.Property:
PropertyTable = new PropertyTable(numRows);
break;
case TableTag.PropertyMap:
PropertyMapTable = new PropertyMapTable(numRows);
break;
case TableTag.StandAloneSig:
StandAloneSigTable = new StandAloneSigTable(numRows);
break;
case TableTag.TypeDef:
TypeDefTable = new TypeDefTable(numRows);
break;
case TableTag.TypeRef:
TypeRefTable = new TypeRefTable(numRows);
break;
case TableTag.TypeSpec:
TypeSpecTable = new TypeSpecTable(numRows);
break;
default:
// Ignore
break;
}
}
DetermineIndexCodingSizes();
for (var i = 0; i < 64; i++)
{
if (valid[i])
{
switch ((TableTag)i)
{
case TableTag.Module:
ModuleTable.Read(ctxt, reader);
break;
case TableTag.Assembly:
AssemblyTable.Read(ctxt, reader);
break;
case TableTag.AssemblyOS:
AssemblyOSTable.Read(ctxt, reader);
break;
case TableTag.AssemblyProcessor:
AssemblyProcessorTable.Read(ctxt, reader);
break;
case TableTag.AssemblyRef:
AssemblyRefTable.Read(ctxt, reader);
break;
case TableTag.AssemblyRefOS:
AssemblyRefOSTable.Read(ctxt, reader);
break;
case TableTag.AssemblyRefProcessor:
AssemblyRefProcessorTable.Read(ctxt, reader);
break;
case TableTag.ClassLayout:
ClassLayoutTable.Read(ctxt, reader);
break;
case TableTag.Constant:
ConstantTable.Read(ctxt, reader);
break;
case TableTag.CustomAttribute:
CustomAttributeTable.Read(ctxt, reader);
break;
case TableTag.DeclSecurity:
DeclSecurityTable.Read(ctxt, reader);
break;
case TableTag.EventMap:
EventMapTable.Read(ctxt, reader);
break;
case TableTag.Event:
EventTable.Read(ctxt, reader);
break;
case TableTag.ExportedType:
ExportedTypeTable.Read(ctxt, reader);
break;
case TableTag.Field:
FieldTable.Read(ctxt, reader);
break;
case TableTag.FieldLayout:
FieldLayoutTable.Read(ctxt, reader);
break;
case TableTag.FieldMarshal:
FieldMarshalTable.Read(ctxt, reader);
break;
case TableTag.FieldRVA:
FieldRVATable.Read(ctxt, reader);
break;
case TableTag.File:
FileTable.Read(ctxt, reader);
break;
case TableTag.GenericParam:
GenericParamTable.Read(ctxt, reader);
break;
case TableTag.GenericParamConstraint:
GenericParamConstraintTable.Read(ctxt, reader);
break;
case TableTag.ImplMap:
ImplMapTable.Read(ctxt, reader);
break;
case TableTag.InterfaceImpl:
InterfaceImplTable.Read(ctxt, reader);
break;
case TableTag.ManifestResource:
ManifestResourceTable.Read(ctxt, reader);
break;
case TableTag.MemberRef:
MemberRefTable.Read(ctxt, reader);
break;
case TableTag.MethodDef:
MethodDefTable.Read(ctxt, reader);
break;
case TableTag.MethodImpl:
MethodImplTable.Read(ctxt, reader);
break;
case TableTag.MethodSemantics:
MethodSemanticsTable.Read(ctxt, reader);
break;
case TableTag.MethodSpec:
MethodSpecTable.Read(ctxt, reader);
break;
case TableTag.ModuleRef:
ModuleRefTable.Read(ctxt, reader);
break;
case TableTag.NestedClass:
NestedClassTable.Read(ctxt, reader);
break;
case TableTag.Param:
ParamTable.Read(ctxt, reader);
break;
case TableTag.Property:
PropertyTable.Read(ctxt, reader);
break;
case TableTag.PropertyMap:
PropertyMapTable.Read(ctxt, reader);
break;
case TableTag.StandAloneSig:
StandAloneSigTable.Read(ctxt, reader);
break;
case TableTag.TypeDef:
TypeDefTable.Read(ctxt, reader);
break;
case TableTag.TypeRef:
TypeRefTable.Read(ctxt, reader);
break;
case TableTag.TypeSpec:
TypeSpecTable.Read(ctxt, reader);
break;
default:
throw new PEException("unexpected table tag in MetadataTable body");
}
}
}
ModuleTable.ResolveIndexes(ctxt);
TypeRefTable.ResolveIndexes(ctxt);
TypeDefTable.ResolveIndexes(ctxt);
FieldTable.ResolveIndexes(ctxt);
MethodDefTable.ResolveIndexes(ctxt);
ParamTable.ResolveIndexes(ctxt);
InterfaceImplTable.ResolveIndexes(ctxt);
MemberRefTable.ResolveIndexes(ctxt);
ConstantTable.ResolveIndexes(ctxt);
CustomAttributeTable.ResolveIndexes(ctxt);
FieldMarshalTable.ResolveIndexes(ctxt);
DeclSecurityTable.ResolveIndexes(ctxt);
ClassLayoutTable.ResolveIndexes(ctxt);
FieldLayoutTable.ResolveIndexes(ctxt);
StandAloneSigTable.ResolveIndexes(ctxt);
EventMapTable.ResolveIndexes(ctxt);
EventTable.ResolveIndexes(ctxt);
PropertyMapTable.ResolveIndexes(ctxt);
PropertyTable.ResolveIndexes(ctxt);
MethodSemanticsTable.ResolveIndexes(ctxt);
MethodImplTable.ResolveIndexes(ctxt);
ModuleRefTable.ResolveIndexes(ctxt);
TypeSpecTable.ResolveIndexes(ctxt);
ImplMapTable.ResolveIndexes(ctxt);
FieldRVATable.ResolveIndexes(ctxt);
AssemblyTable.ResolveIndexes(ctxt);
AssemblyProcessorTable.ResolveIndexes(ctxt);
AssemblyOSTable.ResolveIndexes(ctxt);
AssemblyRefTable.ResolveIndexes(ctxt);
AssemblyRefProcessorTable.ResolveIndexes(ctxt);
AssemblyRefOSTable.ResolveIndexes(ctxt);
FileTable.ResolveIndexes(ctxt);
ExportedTypeTable.ResolveIndexes(ctxt);
ManifestResourceTable.ResolveIndexes(ctxt);
NestedClassTable.ResolveIndexes(ctxt);
GenericParamTable.ResolveIndexes(ctxt);
MethodSpecTable.ResolveIndexes(ctxt);
GenericParamConstraintTable.ResolveIndexes(ctxt);
}
