127 lines
5.2 KiB
C#
127 lines
5.2 KiB
C#
// -----------------------------------------------------------------------------
|
|
// file="GlRegistryModel"
|
|
// Project: StgSharp
|
|
// Copyright (c) Nitload.
|
|
// SPDX-License-Identifier: MIT
|
|
// -----------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
|
|
namespace StgSharp.GenerateGL.Registry
|
|
{
|
|
/// <summary>
|
|
/// Contains the structural OpenGL registry model without managed type mapping.
|
|
/// </summary>
|
|
internal sealed class GlRegistryModel
|
|
{
|
|
|
|
public GlRegistryModel(
|
|
string sourcePath,
|
|
string? comment,
|
|
IEnumerable<GlTypeDefinition> types,
|
|
IEnumerable<GlKindDefinition> kinds,
|
|
IEnumerable<GlEnumGroup> enumGroups,
|
|
IEnumerable<GlEnumBlock> enumBlocks,
|
|
IEnumerable<GlCommandBlock> commandBlocks,
|
|
IEnumerable<GlFeatureDefinition> features,
|
|
IEnumerable<GlExtensionDefinition> extensions,
|
|
GlRegistryElement element
|
|
)
|
|
{
|
|
ArgumentException.ThrowIfNullOrWhiteSpace(sourcePath);
|
|
ArgumentNullException.ThrowIfNull(types);
|
|
ArgumentNullException.ThrowIfNull(kinds);
|
|
ArgumentNullException.ThrowIfNull(enumGroups);
|
|
ArgumentNullException.ThrowIfNull(enumBlocks);
|
|
ArgumentNullException.ThrowIfNull(commandBlocks);
|
|
ArgumentNullException.ThrowIfNull(features);
|
|
ArgumentNullException.ThrowIfNull(extensions);
|
|
ArgumentNullException.ThrowIfNull(element);
|
|
|
|
SourcePath = sourcePath;
|
|
Comment = comment;
|
|
Types = Freeze(types);
|
|
Kinds = Freeze(kinds);
|
|
EnumGroups = Freeze(enumGroups);
|
|
EnumBlocks = Freeze(enumBlocks);
|
|
CommandBlocks = Freeze(commandBlocks);
|
|
Commands = Freeze(CommandBlocks.SelectMany(value => value.Commands));
|
|
Features = Freeze(features);
|
|
Extensions = Freeze(extensions);
|
|
Element = element;
|
|
|
|
TypesByName = CreateIndex(Types, value => value.Name);
|
|
KindsByName = CreateIndex(Kinds, value => value.Name);
|
|
EnumGroupsByName = CreateIndex(EnumGroups, value => value.Name);
|
|
EnumsByName = CreateIndex(
|
|
EnumBlocks.SelectMany(value => value.Enums),
|
|
value => value.Name);
|
|
CommandsByName = CreateIndex(Commands, value => value.Name);
|
|
FeaturesByName = CreateIndex(Features, value => value.Name);
|
|
ExtensionsByName = CreateIndex(Extensions, value => value.Name);
|
|
}
|
|
|
|
public string SourcePath { get; }
|
|
|
|
public string? Comment { get; }
|
|
|
|
public IReadOnlyList<GlTypeDefinition> Types { get; }
|
|
|
|
public IReadOnlyList<GlKindDefinition> Kinds { get; }
|
|
|
|
public IReadOnlyList<GlEnumGroup> EnumGroups { get; }
|
|
|
|
public IReadOnlyList<GlEnumBlock> EnumBlocks { get; }
|
|
|
|
public IReadOnlyList<GlCommandBlock> CommandBlocks { get; }
|
|
|
|
public IReadOnlyList<GlCommandDefinition> Commands { get; }
|
|
|
|
public IReadOnlyList<GlFeatureDefinition> Features { get; }
|
|
|
|
public IReadOnlyList<GlExtensionDefinition> Extensions { get; }
|
|
|
|
public GlRegistryElement Element { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlTypeDefinition>> TypesByName { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlKindDefinition>> KindsByName { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlEnumGroup>> EnumGroupsByName { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlEnumDefinition>> EnumsByName { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlCommandDefinition>> CommandsByName { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlFeatureDefinition>> FeaturesByName { get; }
|
|
|
|
public IReadOnlyDictionary<string, IReadOnlyList<GlExtensionDefinition>> ExtensionsByName { get; }
|
|
|
|
private static ReadOnlyDictionary<string, IReadOnlyList<T>> CreateIndex<T>(
|
|
IEnumerable<T> values,
|
|
Func<T, string> readName
|
|
)
|
|
{
|
|
Dictionary<string, IReadOnlyList<T>> index = values.GroupBy(
|
|
readName,
|
|
StringComparer.Ordinal)
|
|
.ToDictionary(
|
|
value => value.Key,
|
|
value => (IReadOnlyList<T>)Freeze(value),
|
|
StringComparer.Ordinal);
|
|
return new ReadOnlyDictionary<string, IReadOnlyList<T>>(index);
|
|
}
|
|
|
|
private static ReadOnlyCollection<T> Freeze<T>(
|
|
IEnumerable<T> values
|
|
)
|
|
{
|
|
return Array.AsReadOnly(values.ToArray());
|
|
}
|
|
|
|
}
|
|
}
|