////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by rpcapi
////////////////////////////////////////////////////////////////////////////////

package service

import "fmt"

func (c callImport) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "Import(name: %v, Data: %v)",
		c.name, c.Data,
	)
}
func (r resultImport) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetCaptures) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetCaptures()")
}
func (r resultGetCaptures) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetDevices) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetDevices()")
}
func (r resultGetDevices) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetState) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetState(capture: %v, after: %v)",
		c.capture, c.after,
	)
}
func (r resultGetState) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetHierarchy) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetHierarchy(capture: %v)",
		c.capture,
	)
}
func (r resultGetHierarchy) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetMemoryInfo) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetMemoryInfo(capture: %v, after: %v, rng: %v)",
		c.capture, c.after, c.rng,
	)
}
func (r resultGetMemoryInfo) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetFramebufferColor) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetFramebufferColor(device: %v, capture: %v, api: %v, after: %v, settings: %v)",
		c.device, c.capture, c.api, c.after, c.settings,
	)
}
func (r resultGetFramebufferColor) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetFramebufferDepth) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetFramebufferDepth(device: %v, capture: %v, api: %v, after: %v)",
		c.device, c.capture, c.api, c.after,
	)
}
func (r resultGetFramebufferDepth) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callGetTimingInfo) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "GetTimingInfo(device: %v, capture: %v, mask: %v)",
		c.device, c.capture, c.mask,
	)
}
func (r resultGetTimingInfo) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callPrerenderFramebuffers) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "PrerenderFramebuffers(device: %v, capture: %v, api: %v, width: %v, height: %v, atomIds: %v)",
		c.device, c.capture, c.api, c.width, c.height, c.atomIds,
	)
}
func (r resultPrerenderFramebuffers) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callReplaceAtom) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ReplaceAtom(capture: %v, atomId: %v, atomType: %v, data: %v)",
		c.capture, c.atomId, c.atomType, c.data,
	)
}
func (r resultReplaceAtom) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveAtomStream) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveAtomStream(id: %v)",
		c.id,
	)
}
func (r resultResolveAtomStream) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveBinary) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveBinary(id: %v)",
		c.id,
	)
}
func (r resultResolveBinary) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveCapture) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveCapture(id: %v)",
		c.id,
	)
}
func (r resultResolveCapture) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveDevice) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveDevice(id: %v)",
		c.id,
	)
}
func (r resultResolveDevice) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveHierarchy) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveHierarchy(id: %v)",
		c.id,
	)
}
func (r resultResolveHierarchy) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveImageInfo) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveImageInfo(id: %v)",
		c.id,
	)
}
func (r resultResolveImageInfo) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveMemoryInfo) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveMemoryInfo(id: %v)",
		c.id,
	)
}
func (r resultResolveMemoryInfo) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveSchema) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveSchema(id: %v)",
		c.id,
	)
}
func (r resultResolveSchema) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}
func (c callResolveTimingInfo) Format(f fmt.State, r rune) {
	fmt.Fprintf(f, "ResolveTimingInfo(id: %v)",
		c.id,
	)
}
func (r resultResolveTimingInfo) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "res: %#v", r.value)
}

func (h ApiId) Valid() bool {
	return h.ID.Valid()
}
func (h AtomStreamId) Valid() bool {
	return h.ID.Valid()
}
func (h BinaryId) Valid() bool {
	return h.ID.Valid()
}
func (h CaptureId) Valid() bool {
	return h.ID.Valid()
}
func (h DeviceId) Valid() bool {
	return h.ID.Valid()
}
func (h HierarchyId) Valid() bool {
	return h.ID.Valid()
}
func (h ImageInfoId) Valid() bool {
	return h.ID.Valid()
}
func (h MemoryInfoId) Valid() bool {
	return h.ID.Valid()
}
func (h SchemaId) Valid() bool {
	return h.ID.Valid()
}
func (h TimingInfoId) Valid() bool {
	return h.ID.Valid()
}

func (a ApiIdArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]ApiIdˢ", len(a))
}
func (a ApiSchemaArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]ApiSchemaˢ", len(a))
}
func (a AtomGroupArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]AtomGroupˢ", len(a))
}
func (a AtomInfoArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]AtomInfoˢ", len(a))
}
func (a AtomRangeTimerArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]AtomRangeTimerˢ", len(a))
}
func (a AtomTimerArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]AtomTimerˢ", len(a))
}
func (a CaptureIdArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]CaptureIdˢ", len(a))
}
func (a ClassInfoArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]ClassInfoˢ", len(a))
}
func (a ClassInfoPtrArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]ClassInfoᵖˢ", len(a))
}
func (a DeviceIdArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]DeviceIdˢ", len(a))
}
func (a EnumEntryArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]EnumEntryˢ", len(a))
}
func (a EnumInfoArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]EnumInfoˢ", len(a))
}
func (a EnumInfoPtrArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]EnumInfoᵖˢ", len(a))
}
func (a FieldInfoArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]FieldInfoˢ", len(a))
}
func (a FieldInfoPtrArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]FieldInfoᵖˢ", len(a))
}
func (a MemoryRangeArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]MemoryRangeˢ", len(a))
}
func (a ParameterInfoArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]ParameterInfoˢ", len(a))
}
func (a TypeInfoArray) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]TypeInfoˢ", len(a))
}
func (a U64Array) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]U64ˢ", len(a))
}
func (a U8Array) Format(f fmt.State, c rune) {
	fmt.Fprintf(f, "[%d]U8ˢ", len(a))
}

func (i ImageFormat) IsRGBA8() bool            { return i == ImageFormatRGBA8 }
func (i ImageFormat) IsFloat32() bool          { return i == ImageFormatFloat32 }
func (i TimingMask) IsTimingPerCommand() bool  { return i == TimingMaskTimingPerCommand }
func (i TimingMask) IsTimingPerDrawCall() bool { return i == TimingMaskTimingPerDrawCall }
func (i TimingMask) IsTimingPerFrame() bool    { return i == TimingMaskTimingPerFrame }
func (i TypeKind) IsBool() bool                { return i == TypeKindBool }
func (i TypeKind) IsS8() bool                  { return i == TypeKindS8 }
func (i TypeKind) IsU8() bool                  { return i == TypeKindU8 }
func (i TypeKind) IsS16() bool                 { return i == TypeKindS16 }
func (i TypeKind) IsU16() bool                 { return i == TypeKindU16 }
func (i TypeKind) IsS32() bool                 { return i == TypeKindS32 }
func (i TypeKind) IsU32() bool                 { return i == TypeKindU32 }
func (i TypeKind) IsF32() bool                 { return i == TypeKindF32 }
func (i TypeKind) IsS64() bool                 { return i == TypeKindS64 }
func (i TypeKind) IsU64() bool                 { return i == TypeKindU64 }
func (i TypeKind) IsF64() bool                 { return i == TypeKindF64 }
func (i TypeKind) IsString() bool              { return i == TypeKindString }
func (i TypeKind) IsEnum() bool                { return i == TypeKindEnum }
func (i TypeKind) IsStruct() bool              { return i == TypeKindStruct }
func (i TypeKind) IsClass() bool               { return i == TypeKindClass }
func (i TypeKind) IsArray() bool               { return i == TypeKindArray }
func (i TypeKind) IsStaticArray() bool         { return i == TypeKindStaticArray }
func (i TypeKind) IsMap() bool                 { return i == TypeKindMap }
func (i TypeKind) IsPointer() bool             { return i == TypeKindPointer }
func (i TypeKind) IsMemory() bool              { return i == TypeKindMemory }
func (i TypeKind) IsAny() bool                 { return i == TypeKindAny }
func (i TypeKind) IsID() bool                  { return i == TypeKindID }

func CreateDevice(
	Name string,
	Model string,
	OS string,
	PointerSize uint8,
	PointerAlignment uint8,
	MaxMemorySize uint64,
	RequiresShaderPatching bool,
) *Device {
	return &Device{
		Name:                   Name,
		Model:                  Model,
		OS:                     OS,
		PointerSize:            PointerSize,
		PointerAlignment:       PointerAlignment,
		MaxMemorySize:          MaxMemorySize,
		RequiresShaderPatching: RequiresShaderPatching,
	}
}

func (c *Device) GetName() string                 { return c.Name }
func (c *Device) GetModel() string                { return c.Model }
func (c *Device) GetOS() string                   { return c.OS }
func (c *Device) GetPointerSize() uint8           { return c.PointerSize }
func (c *Device) GetPointerAlignment() uint8      { return c.PointerAlignment }
func (c *Device) GetMaxMemorySize() uint64        { return c.MaxMemorySize }
func (c *Device) GetRequiresShaderPatching() bool { return c.RequiresShaderPatching }

func CreateCapture(
	Name string,
	Atoms AtomStreamId,
	Apis ApiIdArray,
	Schema SchemaId,
) *Capture {
	return &Capture{
		Name:   Name,
		Atoms:  Atoms,
		Apis:   Apis,
		Schema: Schema,
	}
}

func (c *Capture) GetName() string        { return c.Name }
func (c *Capture) GetAtoms() AtomStreamId { return c.Atoms }
func (c *Capture) GetApis() ApiIdArray    { return c.Apis }
func (c *Capture) GetSchema() SchemaId    { return c.Schema }

func CreateBinary(
	Data U8Array,
) *Binary {
	return &Binary{
		Data: Data,
	}
}

func (c *Binary) GetData() U8Array { return c.Data }

func CreateAtomStream(
	Data U8Array,
) *AtomStream {
	return &AtomStream{
		Data: Data,
	}
}

func (c *AtomStream) GetData() U8Array { return c.Data }

func CreateHierarchy(
	Root AtomGroup,
) *Hierarchy {
	return &Hierarchy{
		Root: Root,
	}
}

func (c *Hierarchy) GetRoot() AtomGroup { return c.Root }

func CreateAtomGroup(
	Name string,
	Range AtomRange,
	SubGroups AtomGroupArray,
) *AtomGroup {
	return &AtomGroup{
		Name:      Name,
		Range:     Range,
		SubGroups: SubGroups,
	}
}

func (c *AtomGroup) GetName() string              { return c.Name }
func (c *AtomGroup) GetRange() AtomRange          { return c.Range }
func (c *AtomGroup) GetSubGroups() AtomGroupArray { return c.SubGroups }

func CreateAtomRange(
	First uint64,
	Count uint64,
) *AtomRange {
	return &AtomRange{
		First: First,
		Count: Count,
	}
}

func (c *AtomRange) GetFirst() uint64 { return c.First }
func (c *AtomRange) GetCount() uint64 { return c.Count }

func CreateMemoryInfo(
	Data U8Array,
	Stale MemoryRangeArray,
	Current MemoryRangeArray,
	Unknown MemoryRangeArray,
) *MemoryInfo {
	return &MemoryInfo{
		Data:    Data,
		Stale:   Stale,
		Current: Current,
		Unknown: Unknown,
	}
}

func (c *MemoryInfo) GetData() U8Array             { return c.Data }
func (c *MemoryInfo) GetStale() MemoryRangeArray   { return c.Stale }
func (c *MemoryInfo) GetCurrent() MemoryRangeArray { return c.Current }
func (c *MemoryInfo) GetUnknown() MemoryRangeArray { return c.Unknown }

func CreateMemoryRange(
	Base uint64,
	Size uint64,
) *MemoryRange {
	return &MemoryRange{
		Base: Base,
		Size: Size,
	}
}

func (c *MemoryRange) GetBase() uint64 { return c.Base }
func (c *MemoryRange) GetSize() uint64 { return c.Size }

func CreateImageInfo(
	Format ImageFormat,
	Width uint32,
	Height uint32,
	Data BinaryId,
) *ImageInfo {
	return &ImageInfo{
		Format: Format,
		Width:  Width,
		Height: Height,
		Data:   Data,
	}
}

func (c *ImageInfo) GetFormat() ImageFormat { return c.Format }
func (c *ImageInfo) GetWidth() uint32       { return c.Width }
func (c *ImageInfo) GetHeight() uint32      { return c.Height }
func (c *ImageInfo) GetData() BinaryId      { return c.Data }

func CreateTimingInfo(
	PerCommand AtomTimerArray,
	PerDrawCall AtomRangeTimerArray,
	PerFrame AtomRangeTimerArray,
) *TimingInfo {
	return &TimingInfo{
		PerCommand:  PerCommand,
		PerDrawCall: PerDrawCall,
		PerFrame:    PerFrame,
	}
}

func (c *TimingInfo) GetPerCommand() AtomTimerArray       { return c.PerCommand }
func (c *TimingInfo) GetPerDrawCall() AtomRangeTimerArray { return c.PerDrawCall }
func (c *TimingInfo) GetPerFrame() AtomRangeTimerArray    { return c.PerFrame }

func CreateAtomTimer(
	AtomId uint64,
	Nanoseconds uint64,
) *AtomTimer {
	return &AtomTimer{
		AtomId:      AtomId,
		Nanoseconds: Nanoseconds,
	}
}

func (c *AtomTimer) GetAtomId() uint64      { return c.AtomId }
func (c *AtomTimer) GetNanoseconds() uint64 { return c.Nanoseconds }

func CreateAtomRangeTimer(
	FromAtomId uint64,
	ToAtomId uint64,
	Nanoseconds uint64,
) *AtomRangeTimer {
	return &AtomRangeTimer{
		FromAtomId:  FromAtomId,
		ToAtomId:    ToAtomId,
		Nanoseconds: Nanoseconds,
	}
}

func (c *AtomRangeTimer) GetFromAtomId() uint64  { return c.FromAtomId }
func (c *AtomRangeTimer) GetToAtomId() uint64    { return c.ToAtomId }
func (c *AtomRangeTimer) GetNanoseconds() uint64 { return c.Nanoseconds }

func CreateRenderSettings(
	MaxWidth uint32,
	MaxHeight uint32,
	Wireframe bool,
) *RenderSettings {
	return &RenderSettings{
		MaxWidth:  MaxWidth,
		MaxHeight: MaxHeight,
		Wireframe: Wireframe,
	}
}

func (c *RenderSettings) GetMaxWidth() uint32  { return c.MaxWidth }
func (c *RenderSettings) GetMaxHeight() uint32 { return c.MaxHeight }
func (c *RenderSettings) GetWireframe() bool   { return c.Wireframe }

func CreateSchema(
	Atoms AtomInfoArray,
	Apis ApiSchemaArray,
) *Schema {
	return &Schema{
		Atoms: Atoms,
		Apis:  Apis,
	}
}

func (c *Schema) GetAtoms() AtomInfoArray { return c.Atoms }
func (c *Schema) GetApis() ApiSchemaArray { return c.Apis }

func CreateApiSchema(
	Api ApiId,
	State StructInfo,
) *ApiSchema {
	return &ApiSchema{
		Api:   Api,
		State: State,
	}
}

func (c *ApiSchema) GetApi() ApiId        { return c.Api }
func (c *ApiSchema) GetState() StructInfo { return c.State }

func CreateArrayInfo(
	Name string,
	Kind TypeKind,
	ElementType TypeInfo,
) *ArrayInfo {
	return &ArrayInfo{
		Name:        Name,
		Kind:        Kind,
		ElementType: ElementType,
	}
}

func (c *ArrayInfo) GetName() string          { return c.Name }
func (c *ArrayInfo) GetKind() TypeKind        { return c.Kind }
func (c *ArrayInfo) GetElementType() TypeInfo { return c.ElementType }

func CreateStaticArrayInfo(
	Name string,
	Kind TypeKind,
	ElementType TypeInfo,
	Size uint32,
) *StaticArrayInfo {
	return &StaticArrayInfo{
		Name:        Name,
		Kind:        Kind,
		ElementType: ElementType,
		Size:        Size,
	}
}

func (c *StaticArrayInfo) GetName() string          { return c.Name }
func (c *StaticArrayInfo) GetKind() TypeKind        { return c.Kind }
func (c *StaticArrayInfo) GetElementType() TypeInfo { return c.ElementType }
func (c *StaticArrayInfo) GetSize() uint32          { return c.Size }

func CreateMapInfo(
	Name string,
	Kind TypeKind,
	KeyType TypeInfo,
	ValueType TypeInfo,
) *MapInfo {
	return &MapInfo{
		Name:      Name,
		Kind:      Kind,
		KeyType:   KeyType,
		ValueType: ValueType,
	}
}

func (c *MapInfo) GetName() string        { return c.Name }
func (c *MapInfo) GetKind() TypeKind      { return c.Kind }
func (c *MapInfo) GetKeyType() TypeInfo   { return c.KeyType }
func (c *MapInfo) GetValueType() TypeInfo { return c.ValueType }

func CreateEnumInfo(
	Name string,
	Kind TypeKind,
	Entries EnumEntryArray,
	Extends EnumInfoPtrArray,
) *EnumInfo {
	return &EnumInfo{
		Name:    Name,
		Kind:    Kind,
		Entries: Entries,
		Extends: Extends,
	}
}

func (c *EnumInfo) GetName() string              { return c.Name }
func (c *EnumInfo) GetKind() TypeKind            { return c.Kind }
func (c *EnumInfo) GetEntries() EnumEntryArray   { return c.Entries }
func (c *EnumInfo) GetExtends() EnumInfoPtrArray { return c.Extends }

func CreateEnumEntry(
	Name string,
	Value uint32,
) *EnumEntry {
	return &EnumEntry{
		Name:  Name,
		Value: Value,
	}
}

func (c *EnumEntry) GetName() string  { return c.Name }
func (c *EnumEntry) GetValue() uint32 { return c.Value }

func CreateStructInfo(
	Name string,
	Kind TypeKind,
	Fields FieldInfoPtrArray,
) *StructInfo {
	return &StructInfo{
		Name:   Name,
		Kind:   Kind,
		Fields: Fields,
	}
}

func (c *StructInfo) GetName() string              { return c.Name }
func (c *StructInfo) GetKind() TypeKind            { return c.Kind }
func (c *StructInfo) GetFields() FieldInfoPtrArray { return c.Fields }

func CreateClassInfo(
	Name string,
	Kind TypeKind,
	Fields FieldInfoPtrArray,
	Extends ClassInfoPtrArray,
) *ClassInfo {
	return &ClassInfo{
		Name:    Name,
		Kind:    Kind,
		Fields:  Fields,
		Extends: Extends,
	}
}

func (c *ClassInfo) GetName() string               { return c.Name }
func (c *ClassInfo) GetKind() TypeKind             { return c.Kind }
func (c *ClassInfo) GetFields() FieldInfoPtrArray  { return c.Fields }
func (c *ClassInfo) GetExtends() ClassInfoPtrArray { return c.Extends }

func CreateFieldInfo(
	Name string,
	Type TypeInfo,
) *FieldInfo {
	return &FieldInfo{
		Name: Name,
		Type: Type,
	}
}

func (c *FieldInfo) GetName() string   { return c.Name }
func (c *FieldInfo) GetType() TypeInfo { return c.Type }

func CreateAtomInfo(
	Api ApiId,
	Type uint16,
	Name string,
	Parameters ParameterInfoArray,
	IsCommand bool,
	IsDrawCall bool,
	IsEndOfFrame bool,
	DocumentationUrl string,
) *AtomInfo {
	return &AtomInfo{
		Api:              Api,
		Type:             Type,
		Name:             Name,
		Parameters:       Parameters,
		IsCommand:        IsCommand,
		IsDrawCall:       IsDrawCall,
		IsEndOfFrame:     IsEndOfFrame,
		DocumentationUrl: DocumentationUrl,
	}
}

func (c *AtomInfo) GetApi() ApiId                     { return c.Api }
func (c *AtomInfo) GetType() uint16                   { return c.Type }
func (c *AtomInfo) GetName() string                   { return c.Name }
func (c *AtomInfo) GetParameters() ParameterInfoArray { return c.Parameters }
func (c *AtomInfo) GetIsCommand() bool                { return c.IsCommand }
func (c *AtomInfo) GetIsDrawCall() bool               { return c.IsDrawCall }
func (c *AtomInfo) GetIsEndOfFrame() bool             { return c.IsEndOfFrame }
func (c *AtomInfo) GetDocumentationUrl() string       { return c.DocumentationUrl }

func CreateParameterInfo(
	Name string,
	Type TypeInfo,
	Out bool,
) *ParameterInfo {
	return &ParameterInfo{
		Name: Name,
		Type: Type,
		Out:  Out,
	}
}

func (c *ParameterInfo) GetName() string   { return c.Name }
func (c *ParameterInfo) GetType() TypeInfo { return c.Type }
func (c *ParameterInfo) GetOut() bool      { return c.Out }

func CreateSimpleInfo(
	Name string,
	Kind TypeKind,
) *SimpleInfo {
	return &SimpleInfo{
		Name: Name,
		Kind: Kind,
	}
}

func (c *SimpleInfo) GetName() string   { return c.Name }
func (c *SimpleInfo) GetKind() TypeKind { return c.Kind }